void CVehicleMovementAerodynamic::DumpVector(string _strName,const Vec3 *_pv3)
{
DumpText("%s",_strName.c_str());
DumpText("X=%f",_pv3->x);
DumpText("Y=%f",_pv3->y);
DumpText("Z=%f\n",_pv3->z);
}
static void print_opt_link ( control_t * ctrl, const info_t * info )
{
ASSERT(ctrl);
ASSERT(ctrl->cf);
ASSERT(ctrl->opt_prefix);
ASSERT(info);
if (!InsertStringField(&ctrl->opt_done,info->c_name,false))
return;
if ( ctrl->need_sep )
{
ctrl->need_sep = false;
if ( ctrl->n_cmd_opt )
fprintf(ctrl->cf,"\n\tOptionInfo + OPT_NONE, // separator\n\n" );
}
if ( !info->help || info->type & T_DEF_OPT )
fprintf(ctrl->cf,"\tOptionInfo + OPT_%s,\n", info->c_name );
else
fprintf(ctrl->cf,"\t&option_%s_%s,\n", ctrl->opt_prefix, info->c_name );
if (ctrl->cmd_name)
{
fprintf(ctrl->df,"#:def_cmd_opt( \"%s\", \"%s\", \\\n",
ctrl->cmd_name, info->c_name );
DumpText(ctrl->df,0,0,info->param,1,", \\\n");
DumpText(ctrl->df,0,0,info->help,1," )\n\n");
}
ctrl->n_cmd_opt++;
}
VOID RedrawArea(UWORD startx, struct line_node *startline, UWORD stopx, struct line_node *stopline, struct InstData *data)
{
struct pos_info pos1, pos2;
LONG line_nr1 = LineToVisual(startline, data) - 1;
LONG line_nr2 = LineToVisual(stopline, data) - 1;
ENTER();
OffsetToLines(startx, startline, &pos1, data);
if(stopx >= stopline->line.Length)
stopx = stopline->line.Length-1;
OffsetToLines(stopx, stopline, &pos2, data);
if((line_nr1 += pos1.lines-1) < 0)
line_nr1 = 0;
if((line_nr2 += pos2.lines-1) >= data->maxlines)
line_nr2 = data->maxlines-1;
if(line_nr1 <= line_nr2)
{
DumpText(data->visual_y+line_nr1, line_nr1, line_nr2+1, TRUE, data);
}
LEAVE();
}
static void print_info_opt
(
control_t * ctrl,
const info_t * info,
const info_t * default_info,
ccp cmd_name
)
{
ASSERT(ctrl);
ASSERT(info);
FILE * cf = ctrl->cf;
ASSERT(cf);
if (cmd_name)
fprintf(cf,"const InfoOption_t option_%s_%s_%s =\n",
ctrl->opt_prefix, cmd_name, info->c_name );
fprintf(cf," {\tOPT_%s, ",info->c_name);
ccp start = ( default_info ? default_info : info ) -> namelist;
if ( *start && start[1] == '|' )
{
fprintf(cf,"'%c', ",*start);
start += 2;
}
else
fprintf(cf,"0, ");
ccp end = start;
while ( *end && *end != '|' )
end++;
fprintf(cf,"\"%.*s\",\n", (int)(end-start), start );
ccp param = info->param;
ccp help = info->help;
if (default_info)
{
if (!help)
help = default_info->help;
if (!param)
param = default_info->param;
}
if ( info->type & F_OPT_XPARAM || default_info && default_info->type & F_OPT_XPARAM )
fprintf(cf,"\t\"%s\",\n", param && *param ? param : "param" );
else
fprintf(cf,"\t0,\n");
DumpText(cf,0,0,help,0,"");
fprintf(cf,"\n }%c\n\n",cmd_name ? ';' : ',' );
}
void CVehicleMovementAerodynamic::UpdateWing(SWing *_pWing,float _fAngle,float _fDeltaTime)
{
Matrix34 matWing = m_pEntity->GetWorldTM() * Matrix33::CreateRotationXYZ(Ang3(DEG2RAD(_pWing->fAngleX),
DEG2RAD(_pWing->fAngleY),
DEG2RAD(_pWing->fAngleZ))).GetInverted();
Vec3 vRight = matWing.GetColumn(0);
Vec3 vLook = matWing.GetColumn(1);
Vec3 vUp = matWing.GetColumn(2);
pe_status_dynamics StatusDynamics;
GetPhysics()->GetStatus(&StatusDynamics);
// v(relativepoint) = v + w^(relativepoint-center)
Vec3 vVelocity = StatusDynamics.v + StatusDynamics.w.Cross(m_pEntity->GetWorldTM().TransformVector(_pWing->vPos));
Vec3 vVelocityNormalized = vVelocity.GetNormalizedSafe(vLook);
// TODO:
float fAngleOfAttack = RAD2DEG(asin(vRight.Dot(vVelocityNormalized.Cross(vLook))));
DumpText("AoA=%f",fAngleOfAttack);
fAngleOfAttack += _fAngle;
float Cl = GetCoefficient(_pWing->pLiftPointsMap,fAngleOfAttack) * _pWing->fCl;
float Cd = GetCoefficient(_pWing->pDragPointsMap,fAngleOfAttack) * _pWing->fCd;
Vec3 vVelocityNormal = vRight.Cross(vVelocityNormalized).GetNormalized();
float fVelocitySquared = vVelocity.len2();
const float c_fDynamicPressure = 1.293f;
float fLift = 0.5f * c_fDynamicPressure * _pWing->fSurface * Cl * fVelocitySquared * _fDeltaTime;
float fDrag = 0.5f * c_fDynamicPressure * _pWing->fSurface * Cd * fVelocitySquared * _fDeltaTime;
Vec3 vLiftImpulse = +fLift * vVelocityNormal;
Vec3 vDragImpulse = -fDrag * vVelocityNormalized;
AddForce(&vLiftImpulse,&_pWing->vPos,ColorF(0,1,0,1));
AddForce(&vDragImpulse,&_pWing->vPos,ColorF(1,0,1,1));
}
void CParachute::ProcessMovement(const float deltatime)
{
#define MetersPerSecondToKilometersPerHour(fValue) (fValue*3.6f)
#define SquareFeetToSquareMeters(fValue) (fValue*0.0929f)
IPhysicalEntity* pPhysics = GetEntity()->GetPhysics();
if (!pPhysics)
return;
float fDeltaTime = min(deltatime,0.1f);
pe_status_dynamics statusDynamics;
if (!pPhysics->GetStatus(&statusDynamics))
return;
ResetTextPos();
DumpVector("Velocity", &statusDynamics.v);
DumpVector("AVelocity", &statusDynamics.w);
DumpVector("Acceleration", &statusDynamics.a);
DumpVector("WAcceleration", &statusDynamics.wa);
DumpText("DeltaTime=%f",fDeltaTime);
DumpText("Velocity=%f m/s",statusDynamics.v.len());
DumpText("Velocity=%f km/h",MetersPerSecondToKilometersPerHour(statusDynamics.v.len()));
DumpText("Yaw=%f", m_movementAction.rotateYaw);
DumpText("Pitch=%f",m_movementAction.rotatePitch);
DumpText("Roll=%f", m_movementAction.rotateRoll);
/* Vec3 p1 = GetEntity()->GetWorldTM().GetColumn(3);
Vec3 p2 = p1 + statusDynamics.v * 10.0f;
gEnv->pRenderer->GetIRenderAuxGeom()->DrawLine(p1,ColorF(1,1,0,1),p2,ColorF(1,1,0,1));
gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere(p1,0.6f,ColorF(0,0,1,1));*/
if(m_movementAction.rotatePitch > 0.0f)
{
pe_action_impulse actionImpulse;
actionImpulse.impulse = Vec3(0,0,5000*fDeltaTime);
pPhysics->Action(&actionImpulse);
}
else if(statusDynamics.v.z < 0.0f)
{
for(int iCel=0; iCel<7; iCel++)
{
SWing *pCel = &m_aCels[iCel];
pCel->fCl = 1.0f;
pCel->fCd = 1.0f;
float fPosY = 0.25f;
m_aCels[0].vPos = Vec3(-3.7f,fPosY,5.2f);
m_aCels[1].vPos = Vec3(-2.7f,fPosY,5.7f);
m_aCels[2].vPos = Vec3(-1.6f,fPosY,6.0f);
m_aCels[3].vPos = Vec3(+0.0f,fPosY,6.1f);
m_aCels[4].vPos = Vec3(+1.6f,fPosY,6.0f);
m_aCels[5].vPos = Vec3(+2.7f,fPosY,5.7f);
m_aCels[6].vPos = Vec3(+3.7f,fPosY,5.2f);
m_aCels[0].fAngleX = 7.0f;
m_aCels[1].fAngleX = 7.0f;
m_aCels[2].fAngleX = 7.0f;
m_aCels[3].fAngleX = 7.0f;
m_aCels[4].fAngleX = 7.0f;
m_aCels[5].fAngleX = 7.0f;
m_aCels[6].fAngleX = 7.0f;
if(m_movementAction.rotateYaw < 0.0f)
{
m_aCels[0].fCl = 1.3f;
// m_aCels[1].fCl = 1.3f;
// m_aCels[2].fCl = 1.2f;
m_aCels[0].fCd = 2.9f;
// m_aCels[1].fCd = 2.2f;
// m_aCels[2].fCd = 2.1f;
}
else if(m_movementAction.rotateYaw > 0.0f)
{
// m_aCels[4].fCl = 1.2f;
// m_aCels[5].fCl = 1.3f;
m_aCels[6].fCl = 1.3f;
// m_aCels[4].fCd = 2.1f;
// m_aCels[5].fCd = 2.2f;
m_aCels[6].fCd = 2.9f;
}
else if(m_movementAction.rotatePitch < 0.0f)
{
/* m_aCels[0].vPos = Vec3(-3.6f,fPosY,4.6f);
m_aCels[1].vPos = Vec3(-2.6f,fPosY,5.3f);
m_aCels[2].vPos = Vec3(-1.6f,fPosY,5.9f);
m_aCels[0].fAngleX = -15.0f;
m_aCels[1].fAngleX = -8.0f;
m_aCels[2].fAngleX = 0.0f;
m_aCels[4].vPos = Vec3(+1.6f,fPosY,5.9f);
m_aCels[5].vPos = Vec3(+2.6f,fPosY,5.3f);
m_aCels[6].vPos = Vec3(+3.6f,fPosY,4.6f);
m_aCels[4].fAngleX = 0.0f;
m_aCels[5].fAngleX = -8.0f;
m_aCels[6].fAngleX = -15.0f;*/
m_aCels[0].fCl = 1.1f;
m_aCels[1].fCl = 1.2f;
m_aCels[2].fCl = 1.3f;
m_aCels[0].fCd = 2.1f;
m_aCels[1].fCd = 2.2f;
m_aCels[2].fCd = 2.3f;
m_aCels[4].fCl = 1.3f;
m_aCels[5].fCl = 1.2f;
m_aCels[6].fCl = 1.1f;
m_aCels[4].fCd = 2.3f;
m_aCels[5].fCd = 2.2f;
m_aCels[6].fCd = 2.1f;
}
UpdateWing(pCel,0,fDeltaTime);
}
}
}
static void print_links ( control_t * ctrl )
{
ASSERT(ctrl);
FILE * cf = ctrl->cf;
ASSERT(cf);
print_section(cf,sep1,"InfoOption tabs");
char * temp_param = iobuf;
char * temp_help = iobuf + sizeof(iobuf)/8;
char * sum_beg = iobuf + sizeof(iobuf)/2;
char * sum_end = iobuf + sizeof(iobuf);
char * sum = sum_beg;
const info_t * info_cmd = ctrl->info;
ASSERT ( info_cmd->type & T_DEF_TOOL );
fprintf(cf,"const InfoOption_t * option_tab_tool[] =\n{\n");
ctrl->n_cmd_opt = 0;
ctrl->need_sep = false;
print_links_iterator(ctrl,info_cmd,"def");
fprintf(cf,"\n\t0\n};\n\n");
DumpText(0,temp_param,iobuf+sizeof(iobuf),info_cmd->param,0,"");
DumpText(0,temp_help,iobuf+sizeof(iobuf),info_cmd->help,0,"");
sum += snprintf(sum,sum_end-sum,
" {\t0,\n" // id
"\tfalse,\n" // hidden
"\tfalse,\n" // separator
"\t\"%s\",\n" // name1
"\t0,\n" // name2
"%s,\n" // param
"%s,\n" // help
"\t%u,\n" // n_opt
"\toption_tab_tool,\n" // opt
"\t0\n" // opt_allowed
" },\n\n"
,info_cmd->c_name
,temp_param
,temp_help
,ctrl->n_cmd_opt
);
bool separator = false;
for ( info_cmd++; info_cmd < ctrl->end; info_cmd++ )
{
if ( info_cmd->type & T_SEP_CMD )
separator = true;
//if ( !( info_cmd->type & T_DEF_CMD ) || info_cmd->type & F_HIDDEN )
if ( !( info_cmd->type & T_DEF_CMD ) )
continue;
fprintf(cf,"static const InfoOption_t * option_tab_cmd_%s[] =\n{\n",
info_cmd->c_name);
ctrl->n_cmd_opt = 0;
ctrl->need_sep = false;
ctrl->cmd_name = info_cmd->c_name;
ResetStringField(&ctrl->opt_done);
const info_t * info;
for ( info = info_cmd; info < ctrl->end; info++ )
if ( info->type & T_CMD_BEG && !strcmp(info->c_name,info_cmd->c_name) )
{
print_links_iterator(ctrl,info,"cmd");
break;
}
fprintf(cf,"\n\t0\n};\n\n");
ccp name1 = info_cmd->namelist, ptr = name1;
while ( *ptr && *ptr != '|' )
ptr++;
const int len1 = ptr - name1;
char name2[100] = "0";
if ( *ptr == '|' )
{
ccp n2 = ++ptr;
while ( *ptr && *ptr != '|' )
ptr++;
if ( ptr > n2 )
snprintf(name2,sizeof(name2),"\"%.*s\"",(int)(ptr-n2),n2);
}
DumpText(0,temp_param,iobuf+sizeof(iobuf),info_cmd->param,0,"");
DumpText(0,temp_help,iobuf+sizeof(iobuf),info_cmd->help,0,"");
sum += snprintf(sum,sum_end-sum,
" {\tCMD_%s,\n" // id
"\t%s,\n" // hidden
"\t%s,\n" // separator
"\t\"%.*s\",\n" // name1
"\t%s,\n" // name2
"%s,\n" // param
"%s,\n" // help
"\t%u,\n" // n_opt
"\toption_tab_cmd_%s,\n" // opt
"\toption_allowed_cmd_%s\n" // opt_allowed
" },\n\n"
,info_cmd->c_name
,info_cmd->type & F_HIDDEN ? "true" : "false"
,separator ? "true" : "false"
,len1 ,name1
,name2
,temp_param
,temp_help
,ctrl->n_cmd_opt
,info_cmd->c_name
,info_cmd->c_name
);
separator = false;
}
print_section(cf,sep1,"InfoCommand");
fprintf(cf,"const InfoCommand_t CommandInfo[CMD__N+1] =\n{\n");
fputs(sum_beg,cf);
fprintf(cf," {0,0,0,0,0,0,0,0,0}\n};\n");
}
int main ( int argc, char ** argv )
{
SetupLib(argc,argv,"gen-ui",PROG_UNKNOWN);
static ccp def_null_name = "/dev/null";
FILE * nf = fopen(def_null_name,"wb");
if (!nf)
{
fprintf(stderr,"!!! Can't create file: %s\n",def_null_name);
return ERR_CANT_CREATE;
}
static ccp def_fname = "src/ui/ui.def";
FILE * df = fopen(def_fname,"wb");
if (!df)
{
fprintf(stderr,"!!! Can't create file: %s\n",def_fname);
return ERR_CANT_CREATE;
}
char fname[200];
info_t * info = info_tab;
while ( info->type != T_END )
{
if ( ! ( info->type & T_DEF_TOOL ) )
{
fprintf(stderr,"!!! Missing T_DEF_TOOL entry.\n");
return ERR_SYNTAX;
}
control_t ctrl;
memset(&ctrl,0,sizeof(ctrl));
ctrl.df = nf;
ctrl.opt_prefix = "";
InitializeStringField(&ctrl.gopt);
InitializeStringField(&ctrl.copt);
InitializeStringField(&ctrl.opt_done);
if ( !( info->type & F_HIDDEN ) )
{
ctrl.df = df;
snprintf(iobuf,sizeof(iobuf),"Tool '%s'",info->c_name);
print_section(df,sep2,iobuf);
fprintf(df,"#:def_tool( \"%s\", \\\n",info->c_name);
DumpText(df,0,0,info->param,1,", \\\n");
DumpText(df,0,0,info->help,1," )\n\n");
}
snprintf(fname,sizeof(fname),"src/ui/ui-%s.c",info->c_name);
ctrl.cf = fopen(fname,"wb");
if (!ctrl.cf)
{
fprintf(stderr,"!!! Can't create file: %s\n",fname);
return ERR_CANT_CREATE;
}
snprintf(fname,sizeof(fname),"src/ui/ui-%s.h",info->c_name);
ctrl.hf = fopen(fname,"wb");
if (!ctrl.hf)
{
fprintf(stderr,"!!! Can't create file: %s\n",fname);
return ERR_CANT_CREATE;
}
ctrl.info = info++;
while ( ! ( info->type & (T_END|T_DEF_TOOL)) )
{
if ( info->type & T_DEF_OPT )
{
if ( info->type & F_OPT_GLOBAL )
{
InsertStringField(&ctrl.gopt,info->c_name,false);
++ctrl.n_opt;
//opt_index = 0 for global options
}
else
{
InsertStringField(&ctrl.copt,info->c_name,false);
info->index = ++ctrl.n_opt_specific;
}
if ( !info->help )
{
// copy 'param' and 'help' info from previous tool
const info_t * search;
for ( search = info; search >= info_tab; search-- )
if ( search->type & T_DEF_OPT
&& search->help
&& !strcmp(search->c_name,info->c_name) )
{
info->help = search->help;
if (!info->param)
info->param = search->param;
break;
}
}
if ( !( info->type & F_HIDDEN ) )
{
fprintf(ctrl.df,"#:def_opt( \"%s\", \"%s\", \"%s%s%s%s%s\", \\\n",
info->c_name, info->namelist,
info->type & F_OPT_COMMAND ? "C" : "",
info->type & F_OPT_GLOBAL ? "G" : "",
info->type & F_OPT_MULTIUSE ? "M" : "",
info->type & F_OPT_PARAM ? "P" : "",
info->type & F_OPT_OPTPARAM ? "O" : "" );
DumpText(ctrl.df,0,0,info->param,1,", \\\n");
DumpText(ctrl.df,0,0,info->help,1," )\n\n");
}
}
else if ( info->type & T_DEF_CMD )
{
info->index = ++ctrl.n_cmd;
if ( !info->help )
{
// copy 'param' and 'help' info from previous tool
const info_t * search = info-1;
for ( search = info; search >= info_tab; search-- )
if ( search->type & T_DEF_CMD
&& search->help
&& !strcmp(search->c_name,info->c_name) )
{
info->help = search->help;
if (!info->param)
info->param = search->param;
break;
}
}
if ( !( info->type & F_HIDDEN ) )
{
fprintf(ctrl.df,"#:def_cmd( \"%s\", \"%s\", \\\n",
info->c_name, info->namelist );
DumpText(ctrl.df,0,0,info->param,1,", \\\n");
DumpText(ctrl.df,0,0,info->help,1," )\n\n");
}
}
else if ( info->type & T_GRP_BEG )
info->index = ctrl.n_grp++; // NULL based
else if ( info->type & (T_CMD_OPT|T_CMD_BEG|T_COPY_GRP|T_COPY_CMD) )
{
const int type = info->type & T_CMD_OPT ? T_DEF_OPT
: info->type & T_COPY_GRP ? T_GRP_BEG
: T_DEF_CMD;
const info_t * search;
for ( search = ctrl.info; search < info; search++ )
if ( search->type & type
&& !strcmp(search->c_name,info->c_name) )
{
//PRINT("COPY INDEX #%x: %s\n",info->type,info->c_name);
info->index = search->index;
break;
}
}
info++;
}
ctrl.end = info;
if (ctrl.n_cmd)
ctrl.n_cmd++; // one more for CMD_NONE;
if (ctrl.n_opt_specific)
ctrl.n_opt += ++ctrl.n_opt_specific;
TRACE("N: cmd=%u, grp=%u, opt=%d/%d\n",
ctrl.n_cmd, ctrl.n_grp, ctrl.n_opt_specific, ctrl.n_opt );
const enumError err = Generate(&ctrl);
fclose(ctrl.cf);
fclose(ctrl.hf);
ResetStringField(&ctrl.gopt);
ResetStringField(&ctrl.copt);
ResetStringField(&ctrl.opt_done);
if (err)
return err;
}
AddTables(df);
print_section(df,sep2,"END");
fclose(df);
fclose(nf);
CloseAll();
return ERR_OK;
}
/*---------------------*
* Split line into two *
*---------------------*/
BOOL SplitLine(LONG x, struct line_node *line, BOOL move_crsr, struct UserAction *buffer, struct InstData *data)
{
struct line_node *newline;
struct line_node *next;
struct pos_info pos;
LONG line_nr, lines;
ULONG c;
UWORD crsr_x = data->CPos_X;
struct line_node *crsr_l = data->actualline;
ENTER();
OffsetToLines(x, line, &pos, data);
lines = pos.lines;
next = line->next;
if((newline = AllocLine(data)) != NULL)
{
UWORD *styles = line->line.Styles;
UWORD *newstyles = NULL;
UWORD *colors = line->line.Colors;
UWORD *newcolors = NULL;
data->HasChanged = TRUE;
Init_LineNode(newline, line, line->line.Contents+x, data);
newline->line.Color = line->line.Color;
newline->line.Flow = line->line.Flow;
newline->line.Separator = line->line.Separator;
if(buffer != NULL)
{
newline->line.Color = buffer->del.style;
newline->line.Flow = buffer->del.flow;
newline->line.Separator = buffer->del.separator;
}
if(styles != NULL)
{
LONG style = 0;
LONG length = 0;
UWORD *ostyles;
while(*styles++ <= x+1)
{
if(*styles > 0xff)
style &= *styles++;
else
style |= *styles++;
}
styles--;
ostyles = styles;
while(*(styles+length) != EOS)
length += 2;
length = (length*2) + 16;
if((newstyles = MyAllocPooled(data->mypool, length)) != NULL)
{
UWORD *nstyles = newstyles;
if(isFlagSet(style, BOLD))
{
*nstyles++ = 1;
*nstyles++ = BOLD;
}
if(isFlagSet(style, ITALIC))
{
*nstyles++ = 1;
*nstyles++ = ITALIC;
}
if(isFlagSet(style, UNDERLINE))
{
*nstyles++ = 1;
*nstyles++ = UNDERLINE;
}
while(*styles != EOS)
{
*nstyles++ = (*styles++) - x;
*nstyles++ = *styles++;
}
*nstyles = EOS;
}
if(isFlagSet(style, BOLD))
{
*ostyles++ = x+1;
*ostyles++ = ~BOLD;
}
if(isFlagSet(style, ITALIC))
{
*ostyles++ = x+1;
*ostyles++ = ~ITALIC;
}
if(isFlagSet(style, UNDERLINE))
{
*ostyles++ = x+1;
*ostyles++ = ~UNDERLINE;
}
if(x != 0)
ostyles = line->line.Styles;
*ostyles = EOS;
}
newline->line.Styles = newstyles;
if(colors != NULL)
{
UWORD color = GetColor(x, line);
UWORD length = 0;
UWORD *ocolors;
while(*colors <= x+1)
{
colors += 2;
}
ocolors = colors;
while(*(colors+length) != 0xffff)
length += 2;
length = (length*2) + 16;
if((newcolors = MyAllocPooled(data->mypool, length)) != NULL)
{
UWORD *ncolors = newcolors;
if(color && *colors-x != 1)
{
*ncolors++ = 1;
*ncolors++ = color;
}
while(*colors != 0xffff)
{
*ncolors++ = (*colors++) - x;
*ncolors++ = *colors++;
}
*ncolors = 0xffff;
}
if(x != 0)
ocolors = line->line.Colors;
*ocolors = 0xffff;
}
newline->line.Colors = newcolors;
newline->next = next;
if(next != NULL)
next->previous = newline;
*(line->line.Contents+x) = '\n';
*(line->line.Contents+x+1) = '\0';
line->line.Length = x+1;
/*------------------*/
c = line->visual;
line->visual = VisualHeight(line, data);
CompressLine(line, data);
line_nr = LineToVisual(line, data) + line->visual - 1;
if(line_nr < 0)
line_nr = 0;
if(move_crsr)
{
data->CPos_X = 0;
data->actualline = data->actualline->next;
}
if(x == 0)
{
line->line.Color = 0;
line->line.Separator = 0;
if(!(line->previous && line->previous->line.Flow == line->line.Flow))
{
line->line.Flow = MUIV_TextEditor_Flow_Left;
}
if(line_nr != data->maxlines)
{
data->totallines += 1;
if(data->fastbackground)
{
if(line_nr)
{
ScrollDown(line_nr-1, 1, data);
PrintLine(0, line, line_nr, FALSE, data);
}
else
{
ScrollDown(line_nr, 1, data);
}
}
else DumpText(data->visual_y+line_nr-1, line_nr-1, data->maxlines, TRUE, data);
}
else
{
data->visual_y++;
data->totallines += 1;
if(isFlagClear(data->flags, FLG_Quiet))
{
struct Hook *oldhook;
oldhook = InstallLayerHook(data->rport->Layer, LAYERS_NOBACKFILL);
ScrollRasterBF(data->rport, 0, data->height,
data->xpos, data->ypos,
data->xpos + data->innerwidth - 1, (data->ypos + ((data->maxlines-1) * data->height)) - 1);
InstallLayerHook(data->rport->Layer, oldhook);
PrintLine(0, line, data->maxlines-1, FALSE, data);
if(!data->fastbackground)
{
DumpText(data->visual_y+data->maxlines-1, data->maxlines-1, data->maxlines, TRUE, data);
}
}
}
RETURN(TRUE);
return(TRUE);
}
if(x == (LONG)(line->line.Length + newline->line.Length - 2))
{
data->totallines += 1;
if(buffer == NULL)
{
line->next->line.Color = 0;
line->next->line.Separator = 0;
}
SetCursor(crsr_x, crsr_l, FALSE, data);
if(line_nr < data->maxlines)
{
if(data->fastbackground)
{
ScrollDown(line_nr, 1, data);
if(line_nr+1 <= data->maxlines)
PrintLine(0, line->next, line_nr+1, FALSE, data);
}
else DumpText(data->visual_y+line_nr, line_nr, data->maxlines, TRUE, data);
}
RETURN(TRUE);
return(TRUE);
}
x = line->line.Length;
OffsetToLines(x-1, line, &pos, data);
if(((ULONG)(line->visual + line->next->visual) >= c) && (line->visual == lines))
{
if((ULONG)(line->visual + line->next->visual) > c)
data->totallines += 1;
PrintLine(pos.bytes, line, line_nr, TRUE, data);
if((line_nr+line->next->visual-1 < data->maxlines) && ((ULONG)(line->visual + line->next->visual) > c))
{
ScrollDown(line_nr+line->next->visual-1, 1, data);
}
}
else
{
PrintLine((x-1)-pos.x, line, line_nr, TRUE, data);
if((line_nr < data->maxlines) && ((ULONG)(line->visual + line->next->visual) < c))
{
data->totallines -= 1;
ScrollUp(line_nr, 1, data);
}
}
/*------------------*/
line = line->next;
line_nr++;
c = 0;
while((c < line->line.Length) && (line_nr <= data->maxlines))
c = c + PrintLine(c, line, line_nr++, TRUE, data);
/* Her printes !HELE! den nye linie, burde optimeres! */
RETURN(TRUE);
return (TRUE);
}
else
{
RETURN(FALSE);
return (FALSE);
}
}
/*--------------------------*
* Merge two lines into one *
*--------------------------*/
BOOL MergeLines(struct line_node *line, struct InstData *data)
{
struct line_node *next;
char *newbuffer;
LONG visual, oldvisual, line_nr;
LONG emptyline = FALSE;
LONG color = line->line.Color;
UWORD flow = line->line.Flow;
UWORD separator = line->line.Separator;
ENTER();
data->HasChanged = TRUE;
if(line->line.Length == 1)
{
emptyline = TRUE;
color = line->next->line.Color;
flow = line->next->line.Flow;
separator = line->next->line.Separator;
}
visual = line->visual + line->next->visual;
if((newbuffer = MyAllocPooled(data->mypool, line->line.Length+line->next->line.Length+1)) != NULL)
{
memcpy(newbuffer, line->line.Contents, line->line.Length-1);
memcpy(newbuffer+line->line.Length-1, line->next->line.Contents, line->next->line.Length+1);
MyFreePooled(data->mypool, line->line.Contents);
MyFreePooled(data->mypool, line->next->line.Contents);
if(emptyline == TRUE)
{
if(line->line.Styles != NULL)
MyFreePooled(data->mypool, line->line.Styles);
line->line.Styles = line->next->line.Styles;
if(line->line.Colors != NULL)
MyFreePooled(data->mypool, line->line.Colors);
line->line.Colors = line->next->line.Colors;
}
else
{
UWORD *styles;
UWORD *styles1 = line->line.Styles;
UWORD *styles2 = line->next->line.Styles;
UWORD *colors;
UWORD *colors1 = line->line.Colors;
UWORD *colors2 = line->next->line.Colors;
UWORD length = 12;
if(styles1 != NULL)
length += *((long *)styles1-1) - 4;
if(styles2 != NULL)
length += *((long *)styles2-1) - 4;
if((styles = MyAllocPooled(data->mypool, length)) != NULL)
{
unsigned short* t_styles = styles;
unsigned short style = 0;
SHOWVALUE(DBF_CLIPBOARD, length);
SHOWVALUE(DBF_CLIPBOARD, styles);
SHOWVALUE(DBF_CLIPBOARD, styles1);
SHOWVALUE(DBF_CLIPBOARD, styles2);
if(styles2 != NULL)
{
unsigned short* t_styles2 = styles2;
while(*t_styles2++ == 1)
{
if(*t_styles2 > 0xff)
style &= *t_styles2++;
else
style |= *t_styles2++;
}
}
if(styles1 != NULL)
{
while(*styles1 != EOS)
{
if((*styles1 == line->line.Length) && ((~*(styles1+1) & style) == (*(styles1+1) ^ 0xffff)))
{
style &= *(styles1+1);
styles1 += 2;
}
else
{
*styles++ = *styles1++;
*styles++ = *styles1++;
}
}
SHOWVALUE(DBF_CLIPBOARD, line->line.Styles);
MyFreePooled(data->mypool, line->line.Styles);
}
if(styles2 != NULL)
{
while(*styles2 != EOS)
{
if((*styles2 == 1) && (!(*(styles2+1) & style)))
{
styles2 += 2;
}
else
{
*styles++ = *styles2++ + line->line.Length - 1;
*styles++ = *styles2++;
}
}
SHOWVALUE(DBF_CLIPBOARD, line->next->line.Styles);
MyFreePooled(data->mypool, line->next->line.Styles);
}
*styles = EOS;
line->line.Styles = t_styles;
}
length = 12;
if(colors1 != NULL)
length += *((long *)colors1-1) - 4;
if(colors2 != NULL)
length += *((long *)colors2-1) - 4;
if((colors = MyAllocPooled(data->mypool, length)) != NULL)
{
UWORD *t_colors = colors;
UWORD end_color = 0;
SHOWVALUE(DBF_CLIPBOARD, length);
SHOWVALUE(DBF_CLIPBOARD, colors);
SHOWVALUE(DBF_CLIPBOARD, colors1);
SHOWVALUE(DBF_CLIPBOARD, colors2);
if(colors1 != NULL)
{
while(*colors1 < line->line.Length && *colors1 != 0xffff)
{
*colors++ = *colors1++;
end_color = *colors1;
*colors++ = *colors1++;
}
SHOWVALUE(DBF_CLIPBOARD, line->line.Colors);
MyFreePooled(data->mypool, line->line.Colors);
}
if(end_color && (colors2 == NULL || *colors2 != 1))
{
*colors++ = line->line.Length;
*colors++ = 0;
}
if(colors2 != NULL)
{
if(*colors2 == 1 && *(colors2+1) == end_color)
colors2 += 2;
while(*colors2 != 0xffff)
{
*colors++ = *colors2++ + line->line.Length - 1;
*colors++ = *colors2++;
}
SHOWVALUE(DBF_CLIPBOARD, line->next->line.Colors);
MyFreePooled(data->mypool, line->next->line.Colors);
}
*colors = 0xffff;
line->line.Colors = t_colors;
}
}
line->line.Contents = newbuffer;
line->line.Length = strlen(newbuffer);
next = line->next;
line->next = line->next->next;
if(line->next != NULL)
line->next->previous = line;
oldvisual = line->visual;
line->visual = VisualHeight(line, data);
line->line.Color = color;
line->line.Flow = flow;
line->line.Separator = separator;
FreeLine(next, data);
line_nr = LineToVisual(line, data);
// handle that we have to scroll up/down due to word wrapping
// that occurrs when merging lines
if(visual > line->visual)
{
data->totallines -= 1;
if(line_nr+line->visual-1 < data->maxlines)
{
if(emptyline && line_nr > 0)
{
if(data->fastbackground)
{
ScrollUp(line_nr - 1, 1, data);
SetCursor(data->CPos_X, data->actualline, TRUE, data);
}
else
DumpText(data->visual_y+line_nr-1, line_nr-1, data->maxlines, TRUE, data);
}
else
{
if(data->fastbackground)
ScrollUp(line_nr + line->visual - 1, 1, data);
else
DumpText(data->visual_y+line_nr+line->visual-1, line_nr+line->visual-1, data->maxlines, TRUE, data);
}
}
}
else if(visual < line->visual)
{
data->totallines += 1;
if(line_nr+line->visual-1 < data->maxlines)
ScrollDown(line_nr + line->visual - 2, 1, data);
}
if(!(emptyline && (line_nr + line->visual - 1 < data->maxlines)))
{
LONG t_oldvisual = oldvisual;
LONG t_line_nr = line_nr;
ULONG c = 0;
while((--t_oldvisual) && (t_line_nr++ <= data->maxlines))
c = c + LineCharsWidth(line->line.Contents+c, data);
while((c < line->line.Length) && (t_line_nr <= data->maxlines))
c = c + PrintLine(c, line, t_line_nr++, TRUE, data);
}
if(line_nr + oldvisual == 1 && line->visual == visual-1)
{
data->visual_y--;
data->totallines -= 1;
if(data->fastbackground)
DumpText(data->visual_y, 0, visual-1, TRUE, data);
else
DumpText(data->visual_y, 0, data->maxlines, TRUE, data);
}
RETURN(TRUE);
return(TRUE);
}
else
{
RETURN(FALSE);
return(FALSE);
}
}
/*----------------------*
* Paste from Clipboard *
*----------------------*/
BOOL PasteClip (LONG x, struct line_node *actline, struct InstData *data)
{
struct line_node *line = NULL;
struct line_node *startline = NULL;
struct line_node *previous = NULL;
UWORD *styles = NULL;
UWORD *colors = NULL;
STRPTR textline;
BOOL newline = TRUE;
BOOL res = FALSE;
ENTER();
if(InitClipboard(data, IFFF_READ))
{
if(StopChunk(data->iff, ID_FTXT, ID_CHRS) == 0 &&
StopChunk(data->iff, ID_FTXT, ID_FLOW) == 0 &&
StopChunk(data->iff, ID_FTXT, ID_HIGH) == 0 &&
StopChunk(data->iff, ID_FTXT, ID_SBAR) == 0 &&
StopChunk(data->iff, ID_FTXT, ID_COLS) == 0 &&
StopChunk(data->iff, ID_FTXT, ID_STYL) == 0 &&
StopChunk(data->iff, ID_FTXT, ID_CSET) == 0)
{
LONG error, codeset = 0;
UWORD flow = MUIV_TextEditor_Flow_Left;
UWORD color = FALSE;
UWORD separator = 0;
BOOL ownclip = FALSE;
LONG updatefrom;
while(TRUE)
{
struct ContextNode *cn;
error = ParseIFF(data->iff, IFFPARSE_SCAN);
SHOWVALUE(DBF_CLIPBOARD, error);
if(error == IFFERR_EOC)
continue;
else if(error)
break;
if((cn = CurrentChunk(data->iff)) != NULL)
{
switch (cn->cn_ID)
{
case ID_CSET:
D(DBF_CLIPBOARD, "reading FLOW");
SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
if(cn->cn_Size >= 4)
{
/* Only the first four bytes are interesting */
if(ReadChunkBytes(data->iff, &codeset, 4) != 4)
{
codeset = 0;
}
SHOWVALUE(DBF_CLIPBOARD, codeset);
}
break;
case ID_FLOW:
D(DBF_CLIPBOARD, "reading FLOW");
SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
if(cn->cn_Size == 2)
{
if(ReadChunkBytes(data->iff, &flow, 2) == 2)
if(flow > MUIV_TextEditor_Flow_Right)
flow = MUIV_TextEditor_Flow_Left;
SHOWVALUE(DBF_CLIPBOARD, flow);
}
break;
case ID_HIGH:
D(DBF_CLIPBOARD, "reading HIGH");
SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
if (cn->cn_Size == 2)
{
error = ReadChunkBytes(data->iff, &color, 2);
SHOWVALUE(DBF_CLIPBOARD, color);
SHOWVALUE(DBF_CLIPBOARD, error);
}
break;
case ID_SBAR:
D(DBF_CLIPBOARD, "reading SBAR");
SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
if (cn->cn_Size == 2)
{
error = ReadChunkBytes(data->iff, &separator, 2);
SHOWVALUE(DBF_CLIPBOARD, separator);
SHOWVALUE(DBF_CLIPBOARD, error);
}
break;
case ID_COLS:
D(DBF_CLIPBOARD, "reading COLS");
SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
if(colors)
{
MyFreePooled(data->mypool, colors);
colors = NULL;
}
// allocate one word more than the chunk tell us, because we terminate the array with an additional value
if(cn->cn_Size > 0 && (colors = (UWORD *)MyAllocPooled(data->mypool, cn->cn_Size + sizeof(UWORD))) != NULL)
{
error = ReadChunkBytes(data->iff, colors, cn->cn_Size);
SHOWVALUE(DBF_CLIPBOARD, error);
colors[cn->cn_Size / 2] = 0xffff;
}
break;
case ID_STYL:
D(DBF_CLIPBOARD, "reading STYL");
SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
ownclip = TRUE;
if(styles)
{
MyFreePooled(data->mypool, styles);
styles = NULL;
}
// allocate one word more than the chunk tell us, because we terminate the array with an additional value
if(cn->cn_Size > 0 && (styles = (UWORD *)MyAllocPooled(data->mypool, cn->cn_Size + sizeof(UWORD))) != NULL)
{
error = ReadChunkBytes(data->iff, styles, cn->cn_Size);
SHOWVALUE(DBF_CLIPBOARD, error);
styles[cn->cn_Size / 2] = EOS;
}
break;
case ID_CHRS:
{
D(DBF_CLIPBOARD, "reading CHRS");
SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
data->HasChanged = TRUE;
if(cn->cn_Size > 0 && !ownclip)
{
char *contents;
ULONG length = cn->cn_Size;
if((contents = (char *)MyAllocPooled(data->mypool, length + 1)) != NULL)
{
error = ReadChunkBytes(data->iff, contents, length);
SHOWVALUE(DBF_CLIPBOARD, error);
if(contents[length - 1] != '\n')
{
newline = FALSE;
}
else
{
length--;
}
contents[length] = '\0';
#if defined(__MORPHOS__)
if (codeset == CODESET_UTF8)
{
if (IS_MORPHOS2)
contents = utf8_to_ansi(data, contents);
}
#endif
if((line = ImportText(contents, data, &ImPlainHook, data->ImportWrap)))
{
if(!startline)
startline = line;
if(previous)
previous->next = line;
line->previous = previous;
line->visual = VisualHeight(line, data);
data->totallines += line->visual;
while(line->next)
{
line = line->next;
line->visual = VisualHeight(line, data);
data->totallines += line->visual;
}
previous = line;
}
MyFreePooled(data->mypool, contents);
}
}
else
{
ULONG length = cn->cn_Size;
if(length > 0 && (textline = (char *)MyAllocPooled(data->mypool, length + 2)) != NULL)
{
error = ReadChunkBytes(data->iff, textline, length);
SHOWVALUE(DBF_CLIPBOARD, error);
if (textline[length - 1] != '\n')
{
newline = FALSE;
textline[length] = '\n';
length++;
}
textline[length] = '\0';
if((line = AllocLine(data)))
{
line->next = NULL;
line->previous = previous;
line->line.Contents = textline;
line->line.Length = length;
line->visual = VisualHeight(line, data);
line->line.Color = color;
line->line.Flow = flow;
line->line.Separator = separator;
line->line.Styles = styles;
line->line.Colors = colors;
data->totallines += line->visual;
if(!startline)
startline = line;
if(previous)
previous->next = line;
previous = line;
}
else
{
if(styles)
MyFreePooled(data->mypool, (void *)styles);
if(colors)
MyFreePooled(data->mypool, (void *)colors);
}
}
else
{
if(styles)
MyFreePooled(data->mypool, styles);
if(colors)
MyFreePooled(data->mypool, (void *)colors);
}
styles = NULL;
colors = NULL;
flow = MUIV_TextEditor_Flow_Left;
color = FALSE;
separator = 0;
ownclip = FALSE;
}
}
break;
}
}
}
if(line)
{
BOOL oneline = FALSE;
SplitLine(x, actline, FALSE, NULL, data);
line->next = actline->next;
actline->next->previous = line;
actline->next = startline;
startline->previous = actline;
data->CPos_X = line->line.Length-1;
if(actline->next == line)
{
data->CPos_X += actline->line.Length-1;
oneline = TRUE;
}
if(!newline)
MergeLines(line, data);
MergeLines(actline, data);
if(oneline)
line = actline;
if(newline)
{
line = line->next;
data->CPos_X = 0;
}
data->actualline = line;
}
else
{
switch(error)
{
case IFFERR_MANGLED:
case IFFERR_SYNTAX:
case IFFERR_NOTIFF:
D(DBF_CLIPBOARD, "no FTXT clip!");
DoMethod(data->object, MUIM_TextEditor_HandleError, Error_ClipboardIsNotFTXT);
break;
default:
D(DBF_CLIPBOARD, "clipboard is empty!");
DoMethod(data->object, MUIM_TextEditor_HandleError, Error_ClipboardIsEmpty);
break;
}
}
data->update = TRUE;
ScrollIntoDisplay(data);
updatefrom = LineToVisual(actline, data)-1;
if(updatefrom < 0)
updatefrom = 0;
DumpText(data->visual_y+updatefrom, updatefrom, data->maxlines, TRUE, data);
if(data->update)
res = TRUE;
else
data->update = TRUE;
}
EndClipSession(data);
}
RETURN(res);
return res;
}
void SequenceViewer::ExportAlignment(eExportType type)
{
// get filename
wxString extension, wildcard;
if (type == asFASTA) { extension = ".fsa"; wildcard = "FASTA Files (*.fsa)|*.fsa"; }
else if (type == asFASTAa2m) { extension = ".a2m"; wildcard = "A2M FASTA (*.a2m)|*.a2m"; }
else if (type == asText) { extension = ".txt"; wildcard = "Text Files (*.txt)|*.txt"; }
else if (type == asHTML) { extension = ".html"; wildcard = "HTML Files (*.html)|*.html"; }
else if (type == asPSSM) { extension = ".pssm"; wildcard = "PSSM Files (*.pssm)|*.pssm"; }
wxString outputFolder = wxString(GetUserDir().c_str(), GetUserDir().size() - 1); // remove trailing /
wxString baseName, outputFile;
wxFileName::SplitPath(GetWorkingFilename().c_str(), NULL, &baseName, NULL);
wxFileDialog dialog(sequenceWindow, "Choose a file for alignment export:", outputFolder,
#ifdef __WXGTK__
baseName + extension,
#else
baseName,
#endif
wildcard, wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
dialog.SetFilterIndex(0);
if (dialog.ShowModal() == wxID_OK)
outputFile = dialog.GetPath();
if (outputFile.size() > 0) {
// create output stream
auto_ptr<CNcbiOfstream> ofs(new CNcbiOfstream(WX_TO_STD(outputFile).c_str(), IOS_BASE::out));
if (!(*ofs)) {
ERRORMSG("Unable to open output file " << outputFile.c_str());
return;
}
// map display row order to rows in BlockMultipleAlignment
vector < int > rowOrder;
const SequenceDisplay *display = GetCurrentDisplay();
for (unsigned int i=0; i<display->rows.size(); ++i) {
DisplayRowFromAlignment *alnRow = dynamic_cast<DisplayRowFromAlignment*>(display->rows[i]);
if (alnRow) rowOrder.push_back(alnRow->row);
}
// actually write the alignment
if (type == asFASTA || type == asFASTAa2m) {
INFOMSG("exporting" << (type == asFASTAa2m ? " A2M " : " ") << "FASTA to " << outputFile.c_str());
DumpFASTA((type == asFASTAa2m), alignmentManager->GetCurrentMultipleAlignment(),
rowOrder, sequenceWindow->GetCurrentJustification(), *ofs);
} else if (type == asText || type == asHTML) {
INFOMSG("exporting " << (type == asText ? "text" : "HTML") << " to " << outputFile.c_str());
DumpText((type == asHTML), alignmentManager->GetCurrentMultipleAlignment(),
rowOrder, sequenceWindow->GetCurrentJustification(), *ofs);
} else if (type == asPSSM) {
static string prevTitle;
if (prevTitle.size() == 0)
prevTitle = GetWorkingTitle();
string title = WX_TO_STD(wxGetTextFromUser(
"Enter a name for this PSSM (to be used by other applications like PSI-BLAST or RPS-BLAST):",
"PSSM Title?", prevTitle.c_str(), *viewerWindow).Strip(wxString::both));
if (title.size() > 0) {
INFOMSG("exporting PSSM (" << title << ") to " << outputFile.c_str());
alignmentManager->GetCurrentMultipleAlignment()->GetPSSM().OutputPSSM(*ofs, title);
prevTitle = title;
}
}
}
}
LONG CutBlock2(struct InstData *data, BOOL Clipboard, BOOL NoCut, struct marking *newblock, BOOL update)
{
LONG tvisual_y, error;
LONG startx, stopx;
LONG res = 0;
struct line_node *startline, *stopline;
ENTER();
startx = newblock->startx;
stopx = newblock->stopx;
startline = newblock->startline;
stopline = newblock->stopline;
//D(DBF_STARTUP, "CutBlock2: %ld-%ld %lx-%lx %ld %ld", startx, stopx, startline, stopline, Clipboard, NoCut);
if(startline != stopline)
{
struct line_node *c_startline = startline->next;
data->update = FALSE;
if(Clipboard == TRUE)
{
if(InitClipboard(data, IFFF_WRITE))
{
D(DBF_CLIPBOARD, "writing FORM");
error = PushChunk(data->iff, ID_FTXT, ID_FORM, IFFSIZE_UNKNOWN);
SHOWVALUE(DBF_CLIPBOARD, error);
ClipChars(startx, startline, startline->line.Length-startx, data);
}
else
{
Clipboard = FALSE;
}
}
while(c_startline != stopline)
{
if(Clipboard == TRUE)
{
ClipLine(c_startline, data);
}
if(NoCut == FALSE)
{
struct line_node *cc_startline = c_startline;
MyFreePooled(data->mypool, c_startline->line.Contents);
if(c_startline->line.Styles != NULL)
MyFreePooled(data->mypool, c_startline->line.Styles);
data->totallines -= c_startline->visual;
c_startline = c_startline->next;
//D(DBF_STARTUP, "FreeLine %08lx", cc_startline);
FreeLine(cc_startline, data);
}
else
c_startline = c_startline->next;
}
if(Clipboard == TRUE)
{
if(stopx != 0)
ClipChars(0, stopline, stopx, data);
EndClipSession(data);
}
if(NoCut == FALSE)
{
startline->next = stopline;
stopline->previous = startline;
//D(DBF_STARTUP, "RemoveChars: %ld %ld %08lx %ld", startx, stopx, startline, startline->line.Length);
if(startline->line.Length-startx-1 > 0)
RemoveChars(startx, startline, startline->line.Length-startx-1, data);
if(stopx != 0)
RemoveChars(0, stopline, stopx, data);
data->CPos_X = startx;
data->actualline = startline;
MergeLines(startline, data);
}
}
else
{
if(Clipboard == TRUE)
{
if(InitClipboard(data, IFFF_WRITE))
{
D(DBF_CLIPBOARD, "writing FORM");
error = PushChunk(data->iff, ID_FTXT, ID_FORM, IFFSIZE_UNKNOWN);
SHOWVALUE(DBF_CLIPBOARD, error);
ClipChars(startx, startline, stopx-startx, data);
EndClipSession(data);
}
if(update == TRUE && NoCut == TRUE)
{
MarkText(data->blockinfo.startx, data->blockinfo.startline, data->blockinfo.stopx, data->blockinfo.stopline, data);
goto end;
}
}
if(NoCut == FALSE)
{
data->CPos_X = startx;
RemoveChars(startx, startline, stopx-startx, data);
if(update == TRUE)
goto end;
}
}
tvisual_y = LineToVisual(startline, data)-1;
if(tvisual_y < 0 || tvisual_y > data->maxlines)
{
//D(DBF_STARTUP, "ScrollIntoDisplay");
ScrollIntoDisplay(data);
tvisual_y = 0;
}
if(update == TRUE)
{
//D(DBF_STARTUP, "DumpText! %ld %ld %ld", data->visual_y, tvisual_y, data->maxlines);
data->update = TRUE;
DumpText(data->visual_y+tvisual_y, tvisual_y, data->maxlines, TRUE, data);
}
res = tvisual_y;
end:
RETURN(res);
return res;
}
