/* SLang Screen management routines */
/* Copyright (c) 1992, 1995 John E. Davis
* All rights reserved.
- *
+ *
* You may distribute under the terms of either the GNU General Public
* License or the Perl Artistic License.
*/
register unsigned short color_ch;
color_ch = (This_Color << 8) | (unsigned short) ch;
-
+
while (p < pmax)
{
*p++ = color_ch;
{
int i;
int imax = row + n;
-
+
if (imax > Screen_Rows) imax = Screen_Rows;
for (i = row; i < imax; i++)
{
void SLsmg_erase_eol (void)
{
int r, c;
-
+
c = This_Col - Start_Col;
r = This_Row - Start_Row;
-
+
if ((r < 0) || (r >= Screen_Rows)) return;
if (c < 0) c = 0; else if (c >= Screen_Cols) return;
blank_line (SL_Screen[This_Row].neew + c , Screen_Cols - c, ' ');
This_Row--;
}
-
+
void SLsmg_gotorc (int r, int c)
*/
if (i) This_Alt_Char = ALT_CHAR_FLAG;
else This_Alt_Char = 0;
-
+
This_Color &= 0x7F;
This_Color |= This_Alt_Char;
}
{
return ((This_Row >= Start_Row) && (This_Row < Start_Row + Screen_Rows)
&& ((col_too == 0)
- || ((This_Col >= Start_Col)
+ || ((This_Col >= Start_Col)
&& (This_Col < Start_Col + Screen_Cols))));
}
-
+
void SLsmg_printf (char *fmt, ...)
{
char p[1000];
va_start(ap, fmt);
(void) vsprintf(p, fmt, ap);
va_end(ap);
-
+
SLsmg_write_string (p);
}
int width;
char blank = ' ';
if (str == NULL) width = 0;
- else
+ else
{
width = strlen (str);
if (width > n) width = n;
{
register char ch, *p;
int maxc = dc;
-
+
if ((dr == 0) || (dc == 0)) return;
p = s;
dc = 0;
if ((ch == 0) || (ch == '\n'))
{
int diff;
-
+
diff = maxc - dc;
-
+
SLsmg_gotorc (r, c);
SLsmg_write_nchars (s, dc);
if (fill && (diff > 0))
while (diff--) SLsmg_write_char (' ');
}
if ((ch == 0) || (dr == 1)) break;
-
+
r++;
dc = 0;
dr--;
}
}
-
+
int SLsmg_Tab_Width = 8;
int newline_flag;
#ifndef pc_system
int alt_char_set_flag;
-
- alt_char_set_flag = ((SLtt_Use_Blink_For_ACS == 0)
+
+ alt_char_set_flag = ((SLtt_Use_Blink_For_ACS == 0)
&& (This_Color & ALT_CHAR_FLAG));
#endif
str_max = str + n;
color = This_Color << 8;
-
+
top: /* get here only on newline */
-
+
newline_flag = 0;
start_len = Start_Col;
-
+
if (point_visible (0) == 0) return;
-
+
len = This_Col;
max_len = start_len + Screen_Cols;
p = SL_Screen[This_Row].neew;
if (len > start_len) p += (len - start_len);
-
+
flags = SL_Screen[This_Row].flags;
while ((len < max_len) && (str < str_max))
- {
+ {
ch = (unsigned char) *str++;
#ifndef pc_system
p++;
}
}
-
+
else if ((ch == '\t') && (SLsmg_Tab_Width > 0))
{
n = len;
len += 1;
if (len > start_len)
{
- if (*p != neew)
+ if (*p != neew)
{
flags |= TOUCHED;
*p = neew;
ch &= 0x7F;
}
}
-
+
len += 1;
if (len > start_len)
{
p++;
if (len == max_len) break;
}
-
+
if (ch == 127) ch = '?'; else ch = ch + '@';
len++;
if (len > start_len)
}
}
}
-
+
SL_Screen[This_Row].flags = flags;
This_Col = len;
-
+
if (SLsmg_Newline_Moves == 0)
return;
-
+
if (newline_flag == 0)
{
while (str < str_max)
if (str == str_max) return;
str++;
}
-
+
This_Row++;
This_Col = 0;
if (This_Row == Start_Row + Screen_Rows)
static void do_copy (unsigned short *a, unsigned short *b)
{
unsigned short *amax = a + Screen_Cols;
-
+
while (a < amax) *a++ = *b++;
}
#endif
register unsigned long sum = 0;
register unsigned short *smax, ch;
int is_blank = 2;
-
+
s += SLsmg_Scroll_Hash_Border;
smax = s + (n - SLsmg_Scroll_Hash_Border);
- while (s < smax)
+ while (s < smax)
{
ch = *s++;
if (is_blank && ((ch & 0xFF) != 32)) is_blank--;
-
+
sum += ch;
-
+
h = sum + (h << 3);
if ((g = h & 0xE0000000UL) != 0)
{
int color, did_scroll = 0;
unsigned short *tmp;
int ignore;
-
+
/* find region limits. */
-
+
for (rmax = Screen_Rows - 1; rmax > 0; rmax--)
{
if (SL_Screen[rmax].new_hash != SL_Screen[rmax].old_hash)
if ((r1 == 0)
|| (SL_Screen[r1].new_hash != SL_Screen[r1].old_hash))
break;
-
+
rmax = r1;
}
}
-
+
for (rmin = 0; rmin < rmax; rmin++)
{
if (SL_Screen[rmin].new_hash != SL_Screen[rmin].old_hash)
if ((r1 == rmax)
|| (SL_Screen[r1].new_hash != SL_Screen[r1].old_hash))
break;
-
+
rmin = r1;
}
}
-
+
for (i = rmax; i > rmin; i--)
{
hash = SL_Screen[i].new_hash;
if (hash == Blank_Hash) continue;
-
- if ((hash == SL_Screen[i].old_hash)
+
+ if ((hash == SL_Screen[i].old_hash)
|| ((i + 1 < Screen_Rows) && (hash == SL_Screen[i + 1].old_hash))
|| ((i - 1 > rmin) && (SL_Screen[i].old_hash == SL_Screen[i - 1].new_hash)))
continue;
-
+
for (j = i - 1; j >= rmin; j--)
{
if (hash == SL_Screen[j].old_hash) break;
}
if (j < rmin) continue;
-
+
r2 = i; /* end scroll region */
-
+
di = i - j;
j--;
ignore = 0;
j--;
}
r1 = j + 1;
-
+
/* If this scroll only scrolls this line into place, don't do it.
*/
if ((di > 1) && (r1 + di + ignore == r2)) continue;
-
- /* If there is anything in the scrolling region that is ok, abort the
+
+ /* If there is anything in the scrolling region that is ok, abort the
* scroll.
*/
}
}
if (j <= r2) continue;
-
+
color = This_Color; This_Color = 0;
did_scroll = 1;
SLtt_normal_video ();
SLtt_goto_rc (0, 0);
SLtt_reverse_index (di);
SLtt_reset_scroll_region ();
- /* Now we have a hole in the screen. Make the virtual screen look
+ /* Now we have a hole in the screen. Make the virtual screen look
* like it.
*/
for (j = r1; j <= r2; j++) SL_Screen[j].flags = TOUCHED;
-
+
while (di--)
{
tmp = SL_Screen[r2].old;
This_Color = color;
}
if (did_scroll) return;
-
+
/* Try other direction */
for (i = rmin; i < rmax; i++)
hash = SL_Screen[i].new_hash;
if (hash == Blank_Hash) continue;
if (hash == SL_Screen[i].old_hash) continue;
-
+
/* find a match further down screen */
for (j = i + 1; j <= rmax; j++)
{
if (hash == SL_Screen[j].old_hash) break;
}
if (j > rmax) continue;
-
+
r1 = i; /* beg scroll region */
di = j - i; /* number of lines to scroll */
j++; /* since we know this is a match */
-
+
/* find end of scroll region */
ignore = 0;
while ((j <= rmax) && (SL_Screen[j].old_hash == SL_Screen[j - di].new_hash))
j++;
}
r2 = j - 1; /* end of scroll region */
-
+
/* If this scroll only scrolls this line into place, don't do it.
*/
if ((di > 1) && (r1 + di + ignore == r2)) continue;
- /* If there is anything in the scrolling region that is ok, abort the
+ /* If there is anything in the scrolling region that is ok, abort the
* scroll.
*/
-
+
for (j = r1; j <= r2; j++)
{
if ((SL_Screen[j].old_hash != Blank_Hash)
if ((j - di < r1) || (SL_Screen[j].old_hash != SL_Screen[j - di].new_hash))
break;
}
-
+
}
if (j <= r2) continue;
-
+
color = This_Color; This_Color = 0;
SLtt_normal_video ();
SLtt_set_scroll_region (r1, r2);
SLtt_goto_rc (0, 0); /* relative to scroll region */
SLtt_delete_nlines (di);
SLtt_reset_scroll_region ();
- /* Now we have a hole in the screen. Make the virtual screen look
+ /* Now we have a hole in the screen. Make the virtual screen look
* like it.
*/
for (j = r1; j <= r2; j++) SL_Screen[j].flags = TOUCHED;
-
+
while (di--)
{
tmp = SL_Screen[r1].old;
}
#endif /* NOT pc_system */
-
-
-
+
+
+
static int Smg_Inited;
void SLsmg_refresh (void)
{
int i;
-
+
if (Smg_Inited == 0) return;
#ifndef pc_system
for (i = 0; i < Screen_Rows; i++)
SL_Screen[i].new_hash = compute_hash (SL_Screen[i].neew, Screen_Cols);
}
#endif
-
- if (Cls_Flag)
+
+ if (Cls_Flag)
{
SLtt_normal_video (); SLtt_cls ();
}
for (i = 0; i < Screen_Rows; i++)
{
int trashed;
-
+
if (SL_Screen[i].flags == 0) continue;
-
+
if (SL_Screen[i].flags & TRASHED)
{
SLtt_goto_rc (i, -1); /* Force cursor to move */
trashed = 1;
}
else trashed = 0;
-
- if (Cls_Flag || trashed)
+
+ if (Cls_Flag || trashed)
{
int color = This_Color;
This_Color = 0;
blank_line (SL_Screen[i].old, Screen_Cols, ' ');
This_Color = color;
}
-
+
SL_Screen[i].old[Screen_Cols] = 0;
SL_Screen[i].neew[Screen_Cols] = 0;
-
+
SLtt_smart_puts (SL_Screen[i].neew, SL_Screen[i].old, Screen_Cols, i);
- SLMEMCPY ((char *) SL_Screen[i].old, (char *) SL_Screen[i].neew,
+ SLMEMCPY ((char *) SL_Screen[i].old, (char *) SL_Screen[i].neew,
Screen_Cols * sizeof (short));
SL_Screen[i].flags = 0;
SL_Screen[i].old_hash = SL_Screen[i].new_hash;
#endif
}
-
+
if (point_visible (1)) SLtt_goto_rc (This_Row - Start_Row, This_Col - Start_Col);
SLtt_flush_output ();
Cls_Flag = 0;
int *rmin, int *rmax)
{
int row_max;
-
+
if (n < 0) return 0;
if (row >= box_end) return 0;
row_max = row + n;
if (row_max <= box_start) return 0;
-
+
if (row < box_start) row = box_start;
if (row_max >= box_end) row_max = box_end;
*rmin = row;
{
int i;
int r1, r2;
-
+
if (0 == compute_clip (row, n, Start_Row, Start_Row + Screen_Rows, &r1, &r2))
return;
-
+
r1 -= Start_Row;
r2 -= Start_Row;
for (i = r1; i < r2; i++)
{
int i;
unsigned char *p, *pmax, ch;
-
+
if (Alt_Char_Set[128] == 128) return;
i = 32;
memset ((char *)Alt_Char_Set, ' ', i);
- while (i <= 128)
+ while (i <= 128)
{
Alt_Char_Set [i] = i;
i++;
}
-
+
/* Map to VT100 */
if (SLtt_Has_Alt_Charset)
{
}
else p = (unsigned char *) Fake_Alt_Char_Pairs;
pmax = p + strlen ((char *) p);
-
+
/* Some systems have messed up entries for this */
while (p < pmax)
{
SLtt_reset_video ();
Smg_Suspended = 1;
}
-
+
UNBLOCK_SIGNALS
}
int i;
BLOCK_SIGNALS
- if (Smg_Suspended == 0)
+ if (Smg_Suspended == 0)
{
UNBLOCK_SIGNALS
return;
}
-
+
Smg_Suspended = 0;
SLtt_init_video ();
Cls_Flag = 1;
for (i = 0; i < Screen_Rows; i++)
SL_Screen[i].flags |= TRASHED;
SLsmg_refresh ();
-
+
UNBLOCK_SIGNALS
}
int i, len;
unsigned short *old, *neew;
BLOCK_SIGNALS
-
+
if (Smg_Inited) SLsmg_reset_smg ();
SLtt_init_video ();
Screen_Cols = SLtt_Screen_Cols;
{
int i;
BLOCK_SIGNALS
-
- if (Smg_Inited == 0)
+
+ if (Smg_Inited == 0)
{
UNBLOCK_SIGNALS
return;
SLtt_reset_video ();
This_Alt_Char = This_Color = 0;
Smg_Inited = 0;
-
+
UNBLOCK_SIGNALS
}
void SLsmg_vprintf (char *fmt, va_list ap)
{
char p[1000];
-
+
(void) vsprintf(p, fmt, ap);
-
+
SLsmg_write_string (p);
}
void SLsmg_set_screen_start (int *r, int *c)
{
int or = Start_Row, oc = Start_Col;
-
+
if (c == NULL) Start_Col = 0;
else
{
void SLsmg_draw_object (int r, int c, unsigned char object)
{
This_Row = r; This_Col = c;
-
+
if (point_visible (1))
{
int color = This_Color;
int cmin, cmax;
int final_col = This_Col + n;
int save_color;
-
- if ((This_Row < Start_Row) || (This_Row >= Start_Row + Screen_Rows)
+
+ if ((This_Row < Start_Row) || (This_Row >= Start_Row + Screen_Rows)
|| (0 == compute_clip (This_Col, n, Start_Col, Start_Col + Screen_Cols,
&cmin, &cmax)))
{
This_Col = final_col;
return;
}
-
+
if (hbuf[0] == 0)
{
SLMEMSET ((char *) hbuf, SLSMG_HLINE_CHAR, 16);
}
-
+
n = cmax - cmin;
count = n / 16;
-
+
save_color = This_Color;
This_Color |= ALT_CHAR_FLAG;
This_Col = cmin;
-
+
SLsmg_write_nchars ((char *) hbuf, n % 16);
while (count-- > 0)
{
SLsmg_write_nchars ((char *) hbuf, 16);
}
-
+
This_Color = save_color;
This_Col = final_col;
}
int c = This_Col, rmin, rmax;
int final_row = This_Row + n;
int save_color;
-
+
if (((c < Start_Col) || (c >= Start_Col + Screen_Cols)) ||
(0 == compute_clip (This_Row, n, Start_Row, Start_Row + Screen_Rows,
&rmin, &rmax)))
This_Row = final_row;
return;
}
-
+
save_color = This_Color;
This_Color |= ALT_CHAR_FLAG;
-
+
for (This_Row = rmin; This_Row < rmax; This_Row++)
{
This_Col = c;
SLsmg_write_nchars ((char *) &ch, 1);
}
-
+
This_Col = c; This_Row = final_row;
This_Color = save_color;
}
void SLsmg_draw_box (int r, int c, int dr, int dc)
{
- if (!dr || !dc) return;
+ if (!dr || !dc) return;
This_Row = r; This_Col = c;
dr--; dc--;
- SLsmg_draw_hline (dc);
+ SLsmg_draw_hline (dc);
SLsmg_draw_vline (dr);
This_Row = r; This_Col = c;
SLsmg_draw_vline (dr);
- SLsmg_draw_hline (dc);
+ SLsmg_draw_hline (dc);
SLsmg_draw_object (r, c, SLSMG_ULCORN_CHAR);
SLsmg_draw_object (r, c + dc, SLSMG_URCORN_CHAR);
SLsmg_draw_object (r + dr, c, SLSMG_LLCORN_CHAR);
SLsmg_draw_object (r + dr, c + dc, SLSMG_LRCORN_CHAR);
This_Row = r; This_Col = c;
}
-
+
void SLsmg_fill_region (int r, int c, int dr, int dc, unsigned char ch)
{
static unsigned char hbuf[16];
int count;
int dcmax, rmax;
-
-
+
+
if ((dc < 0) || (dr < 0)) return;
-
+
SLsmg_gotorc (r, c);
r = This_Row; c = This_Col;
-
+
dcmax = Screen_Cols - This_Col;
if (dc > dcmax) dc = dcmax;
-
+
rmax = This_Row + dr;
if (rmax > Screen_Rows) rmax = Screen_Rows;
ch = Alt_Char_Set[ch];
#endif
if (ch != hbuf[0]) SLMEMSET ((char *) hbuf, (char) ch, 16);
-
+
for (This_Row = r; This_Row < rmax; This_Row++)
{
This_Col = c;
SLsmg_write_nchars ((char *) hbuf, 16);
}
}
-
+
This_Row = r;
}
unsigned short *smax, sh;
char buf[32], *b, *bmax;
int color, save_color;
-
+
smax = s + len;
b = buf;
bmax = b + sizeof (buf);
-
+
save_color = This_Color;
while (s < smax)
{
sh = *s++;
-
+
color = sh >> 8;
if ((color != This_Color) || (b == bmax))
{
- if (b != buf)
+ if (b != buf)
{
SLsmg_write_nchars (buf, (int) (b - buf));
b = buf;
}
*b++ = (char) (sh & 0xFF);
}
-
+
if (b != buf)
SLsmg_write_nchars (buf, (int) (b - buf));
-
+
This_Color = save_color;
}
unsigned int r, c;
if (0 == point_visible (1)) return 0;
-
+
r = (unsigned int) (This_Row - Start_Row);
c = (unsigned int) (This_Col - Start_Col);
-
+
if (c + len > (unsigned int) Screen_Cols)
len = (unsigned int) Screen_Cols - c;
-
+
memcpy ((char *) buf, (char *) (SL_Screen[r].neew + c), len * sizeof (short));
return len;
}
{
unsigned int r, c;
unsigned short *dest;
-
+
if (0 == point_visible (1)) return 0;
-
+
r = (unsigned int) (This_Row - Start_Row);
c = (unsigned int) (This_Col - Start_Col);
-
+
if (c + len > (unsigned int) Screen_Cols)
len = (unsigned int) Screen_Cols - c;
-
+
dest = SL_Screen[r].neew + c;
-
+
if (0 != memcmp ((char *) dest, (char *) buf, len * sizeof (short)))
- {
+ {
memcpy ((char *) dest, (char *) buf, len * sizeof (short));
SL_Screen[r].flags |= TOUCHED;
}
projects / reactos.git / blobdiff