LineEditWithHistory::LineEditWithHistory(QWidget *parent) :
QLineEdit(parent)
{
m_nCurrentCommand = -1;
m_history.reserve(100);
QObject::connect(this, SIGNAL(returnPressed()), this, SLOT(StoreLine()));
}
void MorphEffect::Render(Effect *effect, const SettingsMap &SettingsMap, RenderBuffer &buffer) {
int start_x1 = SettingsMap.GetInt("SLIDER_Morph_Start_X1", 0);
int start_y1 = SettingsMap.GetInt("SLIDER_Morph_Start_Y1", 0);
int start_x2 = SettingsMap.GetInt("SLIDER_Morph_Start_X2", 0);
int start_y2 = SettingsMap.GetInt("SLIDER_Morph_Start_Y2", 0);
int end_x1 = SettingsMap.GetInt("SLIDER_Morph_End_X1", 0);
int end_y1 = SettingsMap.GetInt("SLIDER_Morph_End_Y1", 0);
int end_x2 = SettingsMap.GetInt("SLIDER_Morph_End_X2", 0);
int end_y2 = SettingsMap.GetInt("SLIDER_Morph_End_Y2", 0);
int start_length = SettingsMap.GetInt("SLIDER_MorphStartLength", 0);
int end_length = SettingsMap.GetInt("SLIDER_MorphEndLength", 0);
bool start_linked = SettingsMap.GetBool("CHECKBOX_Morph_Start_Link");
bool end_linked = SettingsMap.GetBool("CHECKBOX_Morph_End_Link");
int duration = SettingsMap.GetInt("SLIDER_MorphDuration", 0);
int acceleration = SettingsMap.GetInt("SLIDER_MorphAccel", 0);
bool showEntireHeadAtStart = SettingsMap.GetBool("CHECKBOX_ShowHeadAtStart");
int repeat_count = SettingsMap.GetInt("SLIDER_Morph_Repeat_Count", 0);
int repeat_skip = SettingsMap.GetInt("SLIDER_Morph_Repeat_Skip", 0);
int stagger = SettingsMap.GetInt("SLIDER_Morph_Stagger", 0);
double eff_pos = buffer.GetEffectTimeIntervalPosition();
double step_size = 0.1;
int hcols = 0, hcole = 1;
int tcols = 2, tcole = 3;
int num_tail_colors = 2;
switch (buffer.palette.Size()) {
case 1: //one color selected, use it for all
hcols = hcole = tcols = tcole = 0;
break;
case 2: //two colors, head/tail
hcols = hcole = 0;
tcols = tcole = 1;
break;
case 3: //three colors, head /tail start/end
hcols = hcole = 0;
tcols = 1;
tcole = 2;
break;
case 4:
break;
case 5:
num_tail_colors = 3;
break;
case 6:
num_tail_colors = 4;
break;
}
int x1a = calcPosition(start_x1, buffer.BufferWi);
int y1a = calcPosition(start_y1, buffer.BufferHt);
int x2a = calcPosition(end_x1, buffer.BufferWi);
int y2a = calcPosition(end_y1, buffer.BufferHt);
int x1b, x2b, y1b, y2b;
if( start_linked )
{
x1b = x1a;
y1b = y1a;
}
else
{
x1b = calcPosition(start_x2, buffer.BufferWi);
y1b = calcPosition(start_y2, buffer.BufferHt);
}
if( end_linked )
{
x2b = x2a;
y2b = y2a;
}
else
{
x2b = calcPosition(end_x2, buffer.BufferWi);
y2b = calcPosition(end_y2, buffer.BufferHt);
}
xlColor head_color, tail_color, test_color;
// compute direction
int delta_xa = x2a - x1a;
int delta_xb = x2b - x1b;
int delta_ya = y2a - y1a;
int delta_yb = y2b - y1b;
int direction = delta_xa + delta_xb + delta_ya + delta_yb;
int repeat_x = 0;
int repeat_y = 0;
double effect_pct = 1.0;
double stagger_pct = 0.0;
if( repeat_count > 0 )
{
if( (std::abs((float)delta_xa) + std::abs((float)delta_xb)) < (std::abs((float)delta_ya) + std::abs((float)delta_yb)) )
{
repeat_x = repeat_skip;
}
else
{
repeat_y = repeat_skip;
}
double stagger_val = (double)(std::abs((double)stagger))/200.0;
effect_pct = 1.0 / (1 + stagger_val * repeat_count);
stagger_pct = effect_pct * stagger_val;
}
std::vector<int> v_ax;
std::vector<int> v_ay;
std::vector<int> v_bx;
std::vector<int> v_by;
StoreLine(x1a, y1a, x2a, y2a, &v_ax, &v_ay); // store side a
StoreLine(x1b, y1b, x2b, y2b, &v_bx, &v_by); // store side b
int size_a = v_ax.size();
int size_b = v_bx.size();
std::vector<int> *v_lngx; // pointer to longest vector x
std::vector<int> *v_lngy; // pointer to longest vector y
std::vector<int> *v_shtx; // pointer to shorter vector x
std::vector<int> *v_shty; // pointer to shorter vector y
if( size_a > size_b )
{
v_lngx = &v_ax;
v_lngy = &v_ay;
v_shtx = &v_bx;
v_shty = &v_by;
}
else
{
v_lngx = &v_bx;
v_lngy = &v_by;
v_shtx = &v_ax;
v_shty = &v_ay;
}
double pos_a, pos_b;
double total_tail_length, alpha_pct;
double total_length = v_lngx->size(); // total length of longest vector
double head_duration = duration/100.0; // time the head is in the frame
double head_end_of_head_pos = total_length + 1;
double tail_end_of_head_pos = total_length + 1;
double head_end_of_tail_pos = -1;
double tail_end_of_tail_pos = -1;
for( int repeat = 0; repeat <= repeat_count; repeat++ )
{
double eff_pos_adj = buffer.calcAccel(eff_pos, acceleration);
double eff_start_pct = (stagger >= 0) ? stagger_pct*repeat : stagger_pct*(repeat_count-repeat);
double eff_end_pct = eff_start_pct + effect_pct;
eff_pos_adj = (eff_pos_adj - eff_start_pct) / (eff_end_pct - eff_start_pct);
if( eff_pos_adj < 0.0 )
{
head_end_of_head_pos = -1;
tail_end_of_head_pos = -1;
head_end_of_tail_pos = -1;
tail_end_of_tail_pos = -1;
total_tail_length = 1.0;
if( showEntireHeadAtStart )
{
head_end_of_head_pos = start_length;
}
}
else
{
if( head_duration > 0.0 )
{
double head_loc_pct = eff_pos_adj / head_duration;
head_end_of_head_pos = total_length * head_loc_pct;
double current_total_head_length = end_length * head_loc_pct + start_length * (1.0 - head_loc_pct); // adjusted head length excluding clipping
head_end_of_head_pos += current_total_head_length * head_loc_pct * head_duration;
total_tail_length = total_length * ( 1 / head_duration - 1.0);
if( showEntireHeadAtStart )
{
head_end_of_head_pos += current_total_head_length * (1.0 - eff_pos_adj);
}
tail_end_of_head_pos = head_end_of_head_pos - current_total_head_length;
head_end_of_tail_pos = tail_end_of_head_pos - step_size;
tail_end_of_tail_pos = head_end_of_tail_pos - total_tail_length;
buffer.Get2ColorBlend(hcols, hcole, std::min( head_loc_pct, 1.0), head_color);
}
else
{
total_tail_length = total_length;
head_end_of_tail_pos = total_length * 2 * eff_pos_adj;
tail_end_of_tail_pos = head_end_of_tail_pos - total_tail_length;
}
}
// draw the tail
for( double i = std::min(head_end_of_tail_pos, total_length-1); i >= tail_end_of_tail_pos && i >= 0.0; i -= step_size )
{
double pct = ((total_length == 0) ? 0.0 : i / total_length);
pos_a = i;
pos_b = v_shtx->size() * pct;
double tail_color_pct = (i-tail_end_of_tail_pos) / total_tail_length;
if( num_tail_colors > 2 )
{
double color_index = ((double)num_tail_colors - 1.0) * (1.0 - tail_color_pct);
tail_color_pct = color_index - (double)((int)color_index);
tcols = (int)color_index + 2;
tcole = tcols + 1;
if( tcole == num_tail_colors+1 )
{
alpha_pct = (1.0 - tail_color_pct);
}
else
{
alpha_pct = 1.0;
}
buffer.Get2ColorBlend(tcols, tcole, tail_color_pct, tail_color);
}
else
{
if( tail_color_pct > 0.5 )
{
alpha_pct = 1.0;
}
else
{
alpha_pct = tail_color_pct / 0.5;
}
buffer.Get2ColorBlend(tcole, tcols, tail_color_pct, tail_color);
}
if( buffer.allowAlpha ) {
tail_color.alpha = 255 * alpha_pct;
}
buffer.DrawThickLine( (*v_lngx)[pos_a]+(repeat_x*repeat), (*v_lngy)[pos_a]+(repeat_y*repeat), (*v_shtx)[pos_b]+(repeat_x*repeat), (*v_shty)[pos_b]+(repeat_y*repeat), tail_color, direction >= 0);
}
// draw the head
for( double i = std::max(tail_end_of_head_pos, 0.0); i <= head_end_of_head_pos && i < total_length; i += step_size )
{
double pct = ((total_length == 0) ? 0.0 : i / total_length);
pos_a = i;
pos_b = v_shtx->size() * pct;
buffer.DrawThickLine( (*v_lngx)[pos_a]+(repeat_x*repeat), (*v_lngy)[pos_a]+(repeat_y*repeat), (*v_shtx)[pos_b]+(repeat_x*repeat), (*v_shty)[pos_b]+(repeat_y*repeat), head_color, direction >= 0);
}
}
}
BOOL FAR MergeFile(LPSTR FileName, int view)
{
HCURSOR hSaveCursor;
char line[MAX_USER_LINE + 1];
int offset; //Current offset of storage in block
int lineLen; // length of line
BYTE prevLength; //Previous line size
LPVIEWREC v = &Views[view];
WORD res;
LPDOCREC d =&Docs[v->Doc];
LPLINEREC pCurLine, pLastLine;
LPBLOCKDEF pCurBlock, pNewBlock;
long y;
Assert( v->Doc >= 0);
if ((hFileDoc = _lopen(FileName, OF_READ)) == HFILE_ERROR)
return ErrorBox(ERR_File_Open, (LPSTR)FileName);
if ((pszBufferDoc = DocAlloc(DISK_BLOCK_SIZE)) == NULL) {
ErrorBox(SYS_Allocate_Memory);
goto error1;
}
dwBytesReadDoc = DISK_BLOCK_SIZE;
dwOffsetDoc = DISK_BLOCK_SIZE;
lineLen = 0;
//Delete selected text if any
if (v->BlockStatus) {
long XR, YR;
GetBlockCoord (view, &(v->X), &(v->Y), &XR, &YR);
DeleteStream(view, v->X, v->Y, XR, YR, FALSE);
}
//Set the Hour glass cursor
hSaveCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
//Insert first line
res = LoadLine(line, &lineLen, d->NbLines);
if (res == END_OF_FILE || res == END_OF_LINE) {
//Add a CR+LF
if (res == END_OF_LINE) {
line[lineLen] = CR;
line[lineLen + 1] = LF;
lineLen += 2;
}
if (!InsertBlock(v->Doc, v->X, v->Y, (WORD) lineLen, line))
goto error2;
}
else {
if (res == ERR_File_Read || res == ERR_Not_A_Text_File)
ErrorBox(res, (LPSTR)FileName);
goto error2;
}
if (res != END_OF_FILE) {
//Get current line status (we just inserted it)
y = v->Y;
if (!FirstLine(v->Doc, &pCurLine, &y, &pCurBlock))
return FALSE;
//Get next line (just after the line we just inserted)
if (!NextLine(v->Doc, &pCurLine, &y, &pCurBlock))
return FALSE;
//Set offset to StoreLine start
offset = (LPSTR)pCurLine - (LPSTR)pCurBlock->Data;
prevLength = pCurLine->PrevLength;
//Split block in 2 blocks by first allocating a new block and then
//copying right side of block in new block
if (!AllocateBlock(pCurBlock, pCurBlock->NextBlock, &pNewBlock))
return FALSE;
pLastLine = (LPLINEREC)(pCurBlock->Data + pCurBlock->LastLineOffset);
memmove(pNewBlock->Data, (LPSTR)pCurLine,
(LPSTR)pLastLine - (LPSTR)pCurLine + pLastLine->Length);
//Set new old block len and new new block len
pCurBlock->LastLineOffset = (LPSTR)pCurLine - (LPSTR)pCurBlock->Data - pCurLine->PrevLength;
pNewBlock->LastLineOffset = (LPSTR)pLastLine - (LPSTR)pCurLine;
//Backward links next block with new one
if (pCurBlock->NextBlock == NULL)
d->LastBlock = pNewBlock;
else
(pCurBlock->NextBlock)->PrevBlock = pNewBlock;
//Forward link current block with new block
pCurBlock->NextBlock = pNewBlock;
CloseLine(v->Doc, &pCurLine, y, &pCurBlock);
//Read and store all lines in new blocks
res = LoadLine(line, &lineLen, d->NbLines);
while (res == END_OF_LINE) {
//Truncate a file too large
if (d->NbLines >= MAX_LINE_NUMBER - 1) {
ErrorBox(ERR_Truncate_Doc);
res = END_OF_FILE;
break;
}
if (!StoreLine(line, lineLen, &offset, &prevLength, &pCurBlock)) {
res = END_ABORT;
break;
}
res = LoadLine(line, &lineLen, ++d->NbLines);
}
//Take decisions
switch (res) {
case END_OF_FILE:
//Store last line
if (StoreLine(line, lineLen, &offset, &prevLength, &pCurBlock)) {
d->NbLines++;
//Forward link of last allocated block with new block
pCurBlock->NextBlock = pNewBlock;
//Backward link of new block with last allocated block
pNewBlock->PrevBlock = pCurBlock;
((LPLINEREC)(pNewBlock->Data))->PrevLength = (BYTE)(lineLen + LHD);
//Free memory
if (!DocFree(pszBufferDoc))
InternalErrorBox(SYS_Free_Memory);
//Restore cursor
SetCursor(hSaveCursor);
//Check syntax if C
if (d->language == C_LANGUAGE) {
d->lineTop = 0;
d->lineBottom = d->NbLines;
CheckSyntax(v->Doc);
}
SetVerticalScrollBar(view, TRUE);
PosXY(view, v->X, v->Y, FALSE);
InvalidateRect(v->hwndClient, (LPRECT)NULL, FALSE);
CloseHandle (hFileDoc);
return TRUE;
}
else
goto abort;
case ERR_File_Read:
case ERR_Not_A_Text_File:
ErrorBox(res, (LPSTR)FileName);
//Fall through
case END_ABORT:
{
abort:
SetCursor(hSaveCursor);
break;
}
default:
Assert(FALSE);
break;
}
} else
InvalidateRect(v->hwndClient, (LPRECT)NULL, FALSE);
error2: {
SetCursor (hSaveCursor);
if (!DocFree(pszBufferDoc))
InternalErrorBox(SYS_Free_Memory);
}
error1: {
CloseHandle (hFileDoc);
}
return FALSE;
} /* MergeFile() */
BOOL
LoadFile(
int doc
)
{
LPDOCREC d =&Docs[doc];
char line[MAX_USER_LINE + 1];
int offset; //Current offset of storage in block
int lineLen;
BYTE prevLength; //Previous line size
HCURSOR hSaveCursor;
WORD res;
WORD nbLines = 0;
//
// Documents are now always read only. Because WinDbg is no longer and IDE, it
// is strictly a debugger now.
//
hFileDoc = CreateFile(d->szFileName, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (INVALID_HANDLE_VALUE == hFileDoc) {
ErrorBox( ERR_File_Open, (LPSTR)d->szFileName );
return FALSE;
}
d->readOnly = TRUE;
//Store file date
if (!GetFileTimeByName( d->szFileName, NULL, NULL, &d->time ) ) {
GetSystemTimeAsFileTime(&d->time);
}
if ((pszBufferDoc = DocAlloc(DISK_BLOCK_SIZE)) == NULL) {
ErrorBox(SYS_Allocate_Memory);
goto error1;
}
//Alloc first block
if (!AllocateBlock(NULL, NULL, &d->FirstBlock)) {
return FALSE;
}
//If we are in reload mode, and a message box shows up, a repaint
//of the document being loaded is done, so force number of lines
//to a value != 0
d->NbLines = MAX_LINE_NUMBER;
d->LastBlock = d->FirstBlock;
dwBytesReadDoc = DISK_BLOCK_SIZE;
dwOffsetDoc = DISK_BLOCK_SIZE;
offset = 0;
prevLength = 0;
//Set the Hour glass cursor
hSaveCursor = SetCursor (LoadCursor(NULL, IDC_WAIT));
//Read file line after line
res = LoadLine(line, &lineLen, nbLines);
while (res == END_OF_LINE) {
//Truncate a file too large
if (nbLines >= MAX_LINE_NUMBER - 1) {
ErrorBox(ERR_Truncate_Doc);
res = END_OF_FILE;
break;
}
if (!StoreLine(line, lineLen, &offset, &prevLength, &d->LastBlock)) {
res = END_ABORT;
break;
}
res = LoadLine(line, &lineLen, ++nbLines);
}
//Take decisions
switch (res) {
case END_OF_FILE:
//Store last line
if (StoreLine(line, lineLen, &offset, &prevLength, &d->LastBlock)) {
nbLines++;
//Free memory
if (!DocFree(pszBufferDoc))
InternalErrorBox(SYS_Free_Memory);
//Restore cursor
SetCursor(hSaveCursor);
CloseHandle(hFileDoc);
d->NbLines = nbLines;
return TRUE;
} else
goto abort;
case ERR_File_Read:
case ERR_Not_A_Text_File:
ErrorBox(res, (LPSTR)d->szFileName);
//Fall through
case END_ABORT:
{
LPBLOCKDEF pB;
abort:
while (TRUE) {
pB = (d->LastBlock)->PrevBlock;
if (!DocFree((LPSTR)d->LastBlock))
InternalErrorBox(SYS_Free_Memory);
d->LastBlock = pB;
if (pB == NULL)
break;
}
SetCursor(hSaveCursor);
break;
}
default:
Assert(FALSE);
break;
}
//Restore cursor
SetCursor(hSaveCursor);
if (!DocFree(pszBufferDoc))
InternalErrorBox(SYS_Free_Memory);
error1: {
CloseHandle(hFileDoc);
}
return FALSE;
} /* LoadFile() */
