void PDC_gotoyx(int row, int col)
{
extern int PDC_blink_state;
PDC_LOG(("PDC_gotoyx() - called: row %d col %d from row %d col %d\n",
row, col, SP->cursrow, SP->curscol));
/* clear the old cursor, if it's on-screen: */
if( SP->cursrow >= 0 && SP->curscol >= 0 &&
SP->cursrow < SP->lines && SP->curscol < SP->cols)
{
const int temp_visibility = SP->visibility;
SP->visibility = 0;
PDC_transform_line( SP->cursrow, SP->curscol, 1,
curscr->_y[SP->cursrow] + SP->curscol);
SP->visibility = temp_visibility;
}
/* ...then draw the new (assuming it's actually visible). */
/* This used to require some logic. Now the redraw_cursor() */
/* function figures out what cursor should be drawn, if any. */
PDC_blink_state = 1;
if( SP->visibility)
{
extern HWND PDC_hWnd;
HDC hdc = GetDC( PDC_hWnd) ;
SP->curscol = col;
SP->cursrow = row;
redraw_cursor( hdc);
ReleaseDC( PDC_hWnd, hdc) ;
}
}
void PDC_blink_text(void)
{
int i, j, k;
if (!(SP->termattrs & A_BLINK))
blinked_off = FALSE;
else
blinked_off = !blinked_off;
for (i = 0; i < SP->lines; i++)
{
const chtype *srcp = curscr->_y[i];
for (j = 0; j < SP->cols; j++)
if (srcp[j] & A_BLINK)
{
k = j;
while (k < SP->cols && (srcp[k] & A_BLINK))
k++;
PDC_transform_line(i, j, k - j, srcp + j);
j = k;
}
}
PDC_gotoyx(SP->cursrow, SP->curscol);
pdc_last_blink = GetTickCount();
}
void PDC_gotoyx(int row, int col)
{
SDL_Rect src, dest;
chtype ch;
int oldrow, oldcol;
PDC_LOG(("PDC_gotoyx() - called: row %d col %d from row %d col %d\n",
row, col, SP->cursrow, SP->curscol));
if (SP->mono)
return;
oldrow = SP->cursrow;
oldcol = SP->curscol;
/* clear the old cursor */
PDC_transform_line(oldrow, oldcol, 1, curscr->_y[oldrow] + oldcol);
if (!SP->visibility)
return;
/* draw a new cursor by overprinting the existing character in
reverse, either the full cell (when visibility == 2) or the
lowest quarter of it (when visibility == 1) */
ch = curscr->_y[row][col] ^ A_REVERSE;
_set_attr(ch);
#ifdef CHTYPE_LONG
if (ch & A_ALTCHARSET && !(ch & 0xff80))
ch = acs_map[ch & 0x7f];
#endif
src.h = (SP->visibility == 1) ? pdc_fheight >> 2 : pdc_fheight;
src.w = pdc_fwidth;
dest.y = (row + 1) * pdc_fheight - src.h + pdc_yoffset;
dest.x = col * pdc_fwidth + pdc_xoffset;
src.x = (ch & 0xff) % 32 * pdc_fwidth;
src.y = (ch & 0xff) / 32 * pdc_fheight + (pdc_fheight - src.h);
SDL_BlitSurface(pdc_font, &src, pdc_screen, &dest);
if (oldrow != row || oldcol != col)
{
if (rectcount == MAXRECT)
PDC_update_rects();
uprect[rectcount++] = dest;
}
}
int doupdate(void)
{
int y;
bool clearall;
PDC_LOG(("doupdate() - called\n"));
if (!curscr)
return ERR;
if (isendwin()) /* coming back after endwin() called */
{
reset_prog_mode();
clearall = TRUE;
SP->alive = TRUE; /* so isendwin() result is correct */
}
else
clearall = curscr->_clear;
for (y = 0; y < SP->lines; y++)
{
PDC_LOG(("doupdate() - Transforming line %d of %d: %s\n",
y, SP->lines, (curscr->_firstch[y] != _NO_CHANGE) ?
"Yes" : "No"));
if (clearall || curscr->_firstch[y] != _NO_CHANGE)
{
int first, last;
chtype *src = curscr->_y[y];
chtype *dest = pdc_lastscr->_y[y];
if (clearall)
{
first = 0;
last = COLS - 1;
}
else
{
first = curscr->_firstch[y];
last = curscr->_lastch[y];
}
while (first <= last)
{
int len = 0;
/* build up a run of changed cells; if two runs are
separated by a single unchanged cell, ignore the
break */
if (clearall)
len = last - first + 1;
else
while (first + len <= last &&
(src[first + len] != dest[first + len] ||
(len && first + len < last &&
src[first + len + 1] != dest[first + len + 1])
)
)
len++;
/* update the screen, and pdc_lastscr */
if (len)
{
PDC_transform_line(y, first, len, src + first);
memcpy(dest + first, src + first, len * sizeof(chtype));
first += len;
}
/* skip over runs of unchanged cells */
while (first <= last && src[first] == dest[first])
first++;
}
curscr->_firstch[y] = _NO_CHANGE;
curscr->_lastch[y] = _NO_CHANGE;
}
}
curscr->_clear = FALSE;
if (SP->visibility)
PDC_gotoyx(curscr->_cury, curscr->_curx);
SP->cursrow = curscr->_cury;
SP->curscol = curscr->_curx;
return OK;
}
