slang/slsmg.c

   1 /* SLang Screen management routines */
   2 /* Copyright (c) 1992, 1995 John E. Davis
   3  * All rights reserved.
   4  *
   5  * You may distribute under the terms of either the GNU General Public
   6  * License or the Perl Artistic License.
   7  */
   8
   9 #include "config.h"
  10
  11 #include <stdio.h>
  12 #include <string.h>
  13
  14 #include "slang.h"
  15 #include "_slang.h"
  16
  17 typedef struct Screen_Type
  18   {
  19      int n;                    /* number of chars written last time */
  20      int flags;                /* line untouched, etc... */
  21      unsigned short *old, *neew;
  22 #ifndef pc_system
  23      unsigned long old_hash, new_hash;
  24 #endif
  25   }
  26 Screen_Type;
  27
  28 #define TOUCHED 0x1
  29 #define TRASHED 0x2
  30
  31 #ifndef pc_system
  32 #define MAX_SCREEN_SIZE 120
  33 #else
  34 #define MAX_SCREEN_SIZE 75
  35 #endif
  36
  37 Screen_Type SL_Screen[MAX_SCREEN_SIZE];
  38 static int Start_Col, Start_Row;
  39 static int Screen_Cols, Screen_Rows;
  40 static int This_Row, This_Col;
  41 static int This_Color;                 /* only the first 8 bits of this
  42                                         * are used.  The highest bit is used
  43                                         * to indicate an alternate character
  44                                         * set.  This leaves 127 userdefineable
  45                                         * color combination.
  46                                         */
  47
  48 #ifndef pc_system
  49 #define ALT_CHAR_FLAG 0x80
  50 #else
  51 #define ALT_CHAR_FLAG 0x00
  52 #endif
  53
  54 int SLsmg_Newline_Moves = 0;
  55 int SLsmg_Backspace_Moves = 0;
  56
  57 static void blank_line (unsigned short *p, int n, unsigned char ch)
  58 {
  59    register unsigned short *pmax = p + n;
  60    register unsigned short color_ch;
  61
  62    color_ch = (This_Color << 8) | (unsigned short) ch;
  63
  64    while (p < pmax)
  65      {
  66         *p++ = color_ch;
  67      }
  68 }
  69
  70
  71 static void clear_region (int row, int n)
  72 {
  73    int i;
  74    int imax = row + n;
  75
  76    if (imax > Screen_Rows) imax = Screen_Rows;
  77    for (i = row; i < imax; i++)
  78      {
  79         if (i >= 0)
  80           {
  81              blank_line (SL_Screen[i].neew, Screen_Cols, ' ');
  82              SL_Screen[i].flags |= TOUCHED;
  83           }
  84      }
  85 }
  86
  87 void SLsmg_erase_eol (void)
  88 {
  89    int r, c;
  90
  91    c = This_Col - Start_Col;
  92    r = This_Row - Start_Row;
  93
  94    if ((r < 0) || (r >= Screen_Rows)) return;
  95    if (c < 0) c = 0; else if (c >= Screen_Cols) return;
  96    blank_line (SL_Screen[This_Row].neew + c , Screen_Cols - c, ' ');
  97    SL_Screen[This_Row].flags |= TOUCHED;
  98 }
  99
 100 static void scroll_up (void)
 101 {
 102    unsigned int i, imax;
 103    unsigned short *neew;
 104
 105    neew = SL_Screen[0].neew;
 106    imax = Screen_Rows - 1;
 107    for (i = 0; i < imax; i++)
 108      {
 109         SL_Screen[i].neew = SL_Screen[i + 1].neew;
 110         SL_Screen[i].flags |= TOUCHED;
 111      }
 112    SL_Screen[i].neew = neew;
 113    SL_Screen[i].flags |= TOUCHED;
 114    blank_line (neew, Screen_Cols, ' ');
 115    This_Row--;
 116 }
 117
 118
 119
 120
 121 void SLsmg_gotorc (int r, int c)
 122 {
 123    This_Row = r;
 124    This_Col = c;
 125 }
 126
 127 int SLsmg_get_row (void)
 128 {
 129    return This_Row;
 130 }
 131
 132 int SLsmg_get_column (void)
 133 {
 134    return This_Col;
 135 }
 136
 137 void SLsmg_erase_eos (void)
 138 {
 139    SLsmg_erase_eol ();
 140    clear_region (This_Row + 1, Screen_Rows);
 141 }
 142
 143 static int This_Alt_Char;
 144
 145 #ifndef pc_system
 146 void SLsmg_set_char_set (int i)
 147 {
 148    if (SLtt_Use_Blink_For_ACS) return; /* alt chars not used and the alt bit
 149                                         * is used to indicate a blink.
 150                                         */
 151    if (i) This_Alt_Char = ALT_CHAR_FLAG;
 152    else This_Alt_Char = 0;
 153
 154    This_Color &= 0x7F;
 155    This_Color |= This_Alt_Char;
 156 }
 157 #endif
 158
 159 void SLsmg_set_color (int color)
 160 {
 161    if (color < 0) return;
 162    This_Color = color | This_Alt_Char;
 163 }
 164
 165
 166 void SLsmg_reverse_video (void)
 167 {
 168    SLsmg_set_color (1);
 169 }
 170
 171
 172 void SLsmg_normal_video (void)
 173 {
 174    This_Color = This_Alt_Char;         /* reset video but NOT char set. */
 175 }
 176
 177
 178 static int point_visible (int col_too)
 179 {
 180    return ((This_Row >= Start_Row) && (This_Row < Start_Row + Screen_Rows)
 181            && ((col_too == 0)
 182                || ((This_Col >= Start_Col)
 183                    && (This_Col < Start_Col + Screen_Cols))));
 184 }
 185
 186 void SLsmg_printf (char *fmt, ...)
 187 {
 188    char p[1000];
 189    va_list ap;
 190
 191    va_start(ap, fmt);
 192    (void) g_vsnprintf(p, sizeof (p), fmt, ap);
 193    va_end(ap);
 194
 195    SLsmg_write_string (p);
 196 }
 197
 198 void SLsmg_write_string (char *str)
 199 {
 200    SLsmg_write_nchars (str, strlen (str));
 201 }
 202
 203 void SLsmg_write_nstring (char *str, int n)
 204 {
 205    int width;
 206    char blank = ' ';
 207    if (str == NULL) width = 0;
 208    else
 209      {
 210         width = strlen (str);
 211         if (width > n) width = n;
 212         SLsmg_write_nchars (str, width);
 213      }
 214    while (width++ < n) SLsmg_write_nchars (&blank, 1);
 215 }
 216
 217 void SLsmg_write_wrapped_string (char *s, int r, int c, int dr, int dc, int fill)
 218 {
 219    register char ch, *p;
 220    int maxc = dc;
 221
 222    if ((dr == 0) || (dc == 0)) return;
 223    p = s;
 224    dc = 0;
 225    while (1)
 226      {
 227         ch = *p++;
 228         if ((ch == 0) || (ch == '\n'))
 229           {
 230              int diff;
 231
 232              diff = maxc - dc;
 233
 234              SLsmg_gotorc (r, c);
 235              SLsmg_write_nchars (s, dc);
 236              if (fill && (diff > 0))
 237                {
 238                   while (diff--) SLsmg_write_char (' ');
 239                }
 240              if ((ch == 0) || (dr == 1)) break;
 241
 242              r++;
 243              dc = 0;
 244              dr--;
 245              s = p;
 246           }
 247         else if (dc == maxc)
 248           {
 249              SLsmg_gotorc (r, c);
 250              SLsmg_write_nchars (s, dc + 1);
 251              if (dr == 1) break;
 252
 253              r++;
 254              dc = 0;
 255              dr--;
 256              s = p;
 257           }
 258         else dc++;
 259      }
 260 }
 261
 262
 263
 264 int SLsmg_Tab_Width = 8;
 265
 266 /* Minimum value for which eight bit char is displayed as is. */
 267
 268 #ifndef pc_system
 269 int SLsmg_Display_Eight_Bit = 160;
 270 static unsigned char Alt_Char_Set[129];/* 129th is used as a flag */
 271 #else
 272 int SLsmg_Display_Eight_Bit = 128;
 273 #endif
 274
 275 void SLsmg_write_nchars (char *str, int n)
 276 {
 277    register unsigned short *p, old, neew, color;
 278    unsigned char ch;
 279    unsigned int flags;
 280    int len, start_len, max_len;
 281    char *str_max;
 282    int newline_flag;
 283 #ifndef pc_system
 284    int alt_char_set_flag;
 285
 286    alt_char_set_flag = ((SLtt_Use_Blink_For_ACS == 0)
 287                         && (This_Color & ALT_CHAR_FLAG));
 288 #endif
 289
 290    str_max = str + n;
 291    color = This_Color << 8;
 292
 293    top:                                /* get here only on newline */
 294
 295    newline_flag = 0;
 296    start_len = Start_Col;
 297
 298    if (point_visible (0) == 0) return;
 299
 300    len = This_Col;
 301    max_len = start_len + Screen_Cols;
 302
 303    p = SL_Screen[This_Row].neew;
 304    if (len > start_len) p += (len - start_len);
 305
 306    flags = SL_Screen[This_Row].flags;
 307    while ((len < max_len) && (str < str_max))
 308      {
 309         ch = (unsigned char) *str++;
 310
 311 #ifndef pc_system
 312         if (alt_char_set_flag)
 313           ch = Alt_Char_Set [ch & 0x7F];
 314 #endif
 315         if (((ch >= ' ') && (ch < 127))
 316             || (ch >= (unsigned char) SLsmg_Display_Eight_Bit)
 317 #ifndef pc_system
 318             || alt_char_set_flag
 319 #endif
 320             )
 321           {
 322              len += 1;
 323              if (len > start_len)
 324                {
 325                   old = *p;
 326                   neew = color | (unsigned short) ch;
 327                   if (old != neew)
 328                     {
 329                        flags |= TOUCHED;
 330                        *p = neew;
 331                     }
 332                   p++;
 333                }
 334           }
 335
 336         else if ((ch == '\t') && (SLsmg_Tab_Width > 0))
 337           {
 338              n = len;
 339              n += SLsmg_Tab_Width;
 340              n = SLsmg_Tab_Width - (n % SLsmg_Tab_Width);
 341              if (len + n > max_len) n = max_len - len;
 342              neew = color | (unsigned short) ' ';
 343              while (n--)
 344                {
 345                   len += 1;
 346                   if (len > start_len)
 347                     {
 348                        if (*p != neew)
 349                          {
 350                             flags |= TOUCHED;
 351                             *p = neew;
 352                          }
 353                        p++;
 354                     }
 355                }
 356           }
 357         else if (ch == '\n')
 358           {
 359              newline_flag = 1;
 360              break;
 361           }
 362         else if ((ch == 0x8) && SLsmg_Backspace_Moves)
 363           {
 364              if (len != 0) len--;
 365           }
 366         else
 367           {
 368              if (ch & 0x80)
 369                {
 370                   neew = color | (unsigned short) '~';
 371                   len += 1;
 372                   if (len > start_len)
 373                     {
 374                        if (*p != neew)
 375                          {
 376                             *p = neew;
 377                             flags |= TOUCHED;
 378                          }
 379                        p++;
 380                        if (len == max_len) break;
 381                        ch &= 0x7F;
 382                     }
 383                }
 384
 385              len += 1;
 386              if (len > start_len)
 387                {
 388                   neew = color | (unsigned short) '^';
 389                   if (*p != neew)
 390                     {
 391                        *p = neew;
 392                        flags |= TOUCHED;
 393                     }
 394                   p++;
 395                   if (len == max_len) break;
 396                }
 397
 398              if (ch == 127) ch = '?'; else ch = ch + '@';
 399              len++;
 400              if (len > start_len)
 401                {
 402                   neew = color | (unsigned short) ch;
 403                   if (*p != neew)
 404                     {
 405                        *p = neew;
 406                        flags |= TOUCHED;
 407                     }
 408                   p++;
 409                }
 410           }
 411      }
 412
 413    SL_Screen[This_Row].flags = flags;
 414    This_Col = len;
 415
 416    if (SLsmg_Newline_Moves == 0)
 417      return;
 418
 419    if (newline_flag == 0)
 420      {
 421         while (str < str_max)
 422           {
 423              if (*str == '\n') break;
 424              str++;
 425           }
 426         if (str == str_max) return;
 427         str++;
 428      }
 429
 430    This_Row++;
 431    This_Col = 0;
 432    if (This_Row == Start_Row + Screen_Rows)
 433      {
 434         if (SLsmg_Newline_Moves > 0) scroll_up ();
 435      }
 436    goto top;
 437 }
 438
 439
 440 void SLsmg_write_char (char ch)
 441 {
 442    SLsmg_write_nchars (&ch, 1);
 443 }
 444
 445 static int Cls_Flag;
 446
 447
 448 void SLsmg_cls (void)
 449 {
 450    This_Color = 0;
 451    clear_region (0, Screen_Rows);
 452    This_Color = This_Alt_Char;
 453    Cls_Flag = 1;
 454 }
 455 #if 0
 456 static void do_copy (unsigned short *a, unsigned short *b)
 457 {
 458    unsigned short *amax = a + Screen_Cols;
 459
 460    while (a < amax) *a++ = *b++;
 461 }
 462 #endif
 463
 464 #ifndef pc_system
 465 int SLsmg_Scroll_Hash_Border = 0;
 466 static unsigned long compute_hash (unsigned short *s, int n)
 467 {
 468    register unsigned long h = 0, g;
 469    register unsigned long sum = 0;
 470    register unsigned short *smax, ch;
 471    int is_blank = 2;
 472
 473    s += SLsmg_Scroll_Hash_Border;
 474    smax = s + (n - SLsmg_Scroll_Hash_Border);
 475    while (s < smax)
 476      {
 477         ch = *s++;
 478         if (is_blank && ((ch & 0xFF) != 32)) is_blank--;
 479
 480         sum += ch;
 481
 482         h = sum + (h << 3);
 483         if ((g = h & 0xE0000000UL) != 0)
 484           {
 485              h = h ^ (g >> 24);
 486              h = h ^ g;
 487           }
 488      }
 489    if (is_blank) return 0;
 490    return h;
 491 }
 492
 493 static unsigned long Blank_Hash;
 494
 495 static void try_scroll (void)
 496 {
 497    int i, j, di, r1, r2, rmin, rmax;
 498    unsigned long hash;
 499    int color, did_scroll = 0;
 500    unsigned short *tmp;
 501    int ignore;
 502
 503    /* find region limits. */
 504
 505    for (rmax = Screen_Rows - 1; rmax > 0; rmax--)
 506      {
 507         if (SL_Screen[rmax].new_hash != SL_Screen[rmax].old_hash)
 508           {
 509              r1 = rmax - 1;
 510              if ((r1 == 0)
 511                  || (SL_Screen[r1].new_hash != SL_Screen[r1].old_hash))
 512                break;
 513
 514              rmax = r1;
 515           }
 516      }
 517
 518    for (rmin = 0; rmin < rmax; rmin++)
 519      {
 520         if (SL_Screen[rmin].new_hash != SL_Screen[rmin].old_hash)
 521           {
 522              r1 = rmin + 1;
 523              if ((r1 == rmax)
 524                  || (SL_Screen[r1].new_hash != SL_Screen[r1].old_hash))
 525                break;
 526
 527              rmin = r1;
 528           }
 529      }
 530
 531
 532    for (i = rmax; i > rmin; i--)
 533      {
 534         hash = SL_Screen[i].new_hash;
 535         if (hash == Blank_Hash) continue;
 536
 537         if ((hash == SL_Screen[i].old_hash)
 538             || ((i + 1 < Screen_Rows) && (hash == SL_Screen[i + 1].old_hash))
 539             || ((i - 1 > rmin) && (SL_Screen[i].old_hash == SL_Screen[i - 1].new_hash)))
 540           continue;
 541
 542         for (j = i - 1; j >= rmin; j--)
 543           {
 544              if (hash == SL_Screen[j].old_hash) break;
 545           }
 546         if (j < rmin) continue;
 547
 548         r2 = i;                        /* end scroll region */
 549
 550         di = i - j;
 551         j--;
 552         ignore = 0;
 553         while ((j >= rmin) && (SL_Screen[j].old_hash == SL_Screen[j + di].new_hash))
 554           {
 555              if (SL_Screen[j].old_hash == Blank_Hash) ignore++;
 556              j--;
 557           }
 558         r1 = j + 1;
 559
 560         /* If this scroll only scrolls this line into place, don't do it.
 561          */
 562         if ((di > 1) && (r1 + di + ignore == r2)) continue;
 563
 564         /* If there is anything in the scrolling region that is ok, abort the
 565          * scroll.
 566          */
 567
 568         for (j = r1; j <= r2; j++)
 569           {
 570              if ((SL_Screen[j].old_hash != Blank_Hash)
 571                  && (SL_Screen[j].old_hash == SL_Screen[j].new_hash))
 572                {
 573                   /* See if the scroll is happens to scroll this one into place. */
 574                   if ((j + di > r2) || (SL_Screen[j].old_hash != SL_Screen[j + di].new_hash))
 575                     break;
 576                }
 577           }
 578         if (j <= r2) continue;
 579
 580         color = This_Color;  This_Color = 0;
 581         did_scroll = 1;
 582         SLtt_normal_video ();
 583         SLtt_set_scroll_region (r1, r2);
 584         SLtt_goto_rc (0, 0);
 585         SLtt_reverse_index (di);
 586         SLtt_reset_scroll_region ();
 587         /* Now we have a hole in the screen.  Make the virtual screen look
 588          * like it.
 589          */
 590         for (j = r1; j <= r2; j++) SL_Screen[j].flags = TOUCHED;
 591
 592         while (di--)
 593           {
 594              tmp = SL_Screen[r2].old;
 595              for (j = r2; j > r1; j--)
 596                {
 597                   SL_Screen[j].old = SL_Screen[j - 1].old;
 598                   SL_Screen[j].old_hash = SL_Screen[j - 1].old_hash;
 599                }
 600              SL_Screen[r1].old = tmp;
 601              blank_line (SL_Screen[r1].old, Screen_Cols, ' ');
 602              SL_Screen[r1].old_hash = Blank_Hash;
 603              r1++;
 604           }
 605         This_Color = color;
 606      }
 607    if (did_scroll) return;
 608
 609    /* Try other direction */
 610
 611    for (i = rmin; i < rmax; i++)
 612      {
 613         hash = SL_Screen[i].new_hash;
 614         if (hash == Blank_Hash) continue;
 615         if (hash == SL_Screen[i].old_hash) continue;
 616
 617         /* find a match further down screen */
 618         for (j = i + 1; j <= rmax; j++)
 619           {
 620              if (hash == SL_Screen[j].old_hash) break;
 621           }
 622         if (j > rmax) continue;
 623
 624         r1 = i;                        /* beg scroll region */
 625         di = j - i;                    /* number of lines to scroll */
 626         j++;                           /* since we know this is a match */
 627
 628         /* find end of scroll region */
 629         ignore = 0;
 630         while ((j <= rmax) && (SL_Screen[j].old_hash == SL_Screen[j - di].new_hash))
 631           {
 632              if (SL_Screen[j].old_hash == Blank_Hash) ignore++;
 633              j++;
 634           }
 635         r2 = j - 1;                    /* end of scroll region */
 636
 637         /* If this scroll only scrolls this line into place, don't do it.
 638          */
 639         if ((di > 1) && (r1 + di + ignore == r2)) continue;
 640
 641         /* If there is anything in the scrolling region that is ok, abort the
 642          * scroll.
 643          */
 644
 645         for (j = r1; j <= r2; j++)
 646           {
 647              if ((SL_Screen[j].old_hash != Blank_Hash)
 648                  && (SL_Screen[j].old_hash == SL_Screen[j].new_hash))
 649                {
 650                   if ((j - di < r1) || (SL_Screen[j].old_hash != SL_Screen[j - di].new_hash))
 651                     break;
 652                }
 653
 654           }
 655         if (j <= r2) continue;
 656
 657         color = This_Color;  This_Color = 0;
 658         SLtt_normal_video ();
 659         SLtt_set_scroll_region (r1, r2);
 660         SLtt_goto_rc (0, 0);           /* relative to scroll region */
 661         SLtt_delete_nlines (di);
 662         SLtt_reset_scroll_region ();
 663         /* Now we have a hole in the screen.  Make the virtual screen look
 664          * like it.
 665          */
 666         for (j = r1; j <= r2; j++) SL_Screen[j].flags = TOUCHED;
 667
 668         while (di--)
 669           {
 670              tmp = SL_Screen[r1].old;
 671              for (j = r1; j < r2; j++)
 672                {
 673                   SL_Screen[j].old = SL_Screen[j + 1].old;
 674                   SL_Screen[j].old_hash = SL_Screen[j + 1].old_hash;
 675                }
 676              SL_Screen[r2].old = tmp;
 677              blank_line (SL_Screen[r2].old, Screen_Cols, ' ');
 678              SL_Screen[r2].old_hash = Blank_Hash;
 679              r2--;
 680           }
 681         This_Color = color;
 682      }
 683 }
 684
 685 #endif   /* NOT pc_system */
 686
 687
 688
 689 static int Smg_Inited;
 690
 691 void SLsmg_refresh (void)
 692 {
 693    int i;
 694
 695    if (Smg_Inited == 0) return;
 696 #ifndef pc_system
 697    for (i = 0; i < Screen_Rows; i++)
 698      {
 699         if (SL_Screen[i].flags == 0) continue;
 700         SL_Screen[i].new_hash = compute_hash (SL_Screen[i].neew, Screen_Cols);
 701      }
 702 #endif
 703
 704    if (Cls_Flag)
 705      {
 706         SLtt_normal_video ();  SLtt_cls ();
 707      }
 708 #ifndef pc_system
 709    else if (SLtt_Term_Cannot_Scroll == 0) try_scroll ();
 710 #endif
 711
 712    for (i = 0; i < Screen_Rows; i++)
 713      {
 714         int trashed;
 715
 716         if (SL_Screen[i].flags == 0) continue;
 717
 718         if (SL_Screen[i].flags & TRASHED)
 719           {
 720              SLtt_goto_rc (i, -1); /* Force cursor to move */
 721              SLtt_goto_rc (i, 0);
 722              if (Cls_Flag == 0) SLtt_del_eol ();
 723              trashed = 1;
 724           }
 725         else trashed = 0;
 726
 727         if (Cls_Flag || trashed)
 728           {
 729              int color = This_Color;
 730              This_Color = 0;
 731              blank_line (SL_Screen[i].old, Screen_Cols, ' ');
 732              This_Color = color;
 733           }
 734
 735         SL_Screen[i].old[Screen_Cols] = 0;
 736         SL_Screen[i].neew[Screen_Cols] = 0;
 737
 738         SLtt_smart_puts (SL_Screen[i].neew, SL_Screen[i].old, Screen_Cols, i);
 739
 740         SLMEMCPY ((char *) SL_Screen[i].old, (char *) SL_Screen[i].neew,
 741                   Screen_Cols * sizeof (short));
 742
 743         SL_Screen[i].flags = 0;
 744 #ifndef pc_system
 745         SL_Screen[i].old_hash = SL_Screen[i].new_hash;
 746 #endif
 747      }
 748
 749    if (point_visible (1)) SLtt_goto_rc (This_Row - Start_Row, This_Col - Start_Col);
 750    SLtt_flush_output ();
 751    Cls_Flag = 0;
 752 }
 753
 754 static int compute_clip (int row, int n, int box_start, int box_end,
 755                          int *rmin, int *rmax)
 756 {
 757    int row_max;
 758
 759    if (n < 0) return 0;
 760    if (row >= box_end) return 0;
 761    row_max = row + n;
 762    if (row_max <= box_start) return 0;
 763
 764    if (row < box_start) row = box_start;
 765    if (row_max >= box_end) row_max = box_end;
 766    *rmin = row;
 767    *rmax = row_max;
 768    return 1;
 769 }
 770
 771 void SLsmg_touch_lines (int row, int n)
 772 {
 773    int i;
 774    int r1, r2;
 775
 776    if (0 == compute_clip (row, n, Start_Row, Start_Row + Screen_Rows, &r1, &r2))
 777      return;
 778
 779    r1 -= Start_Row;
 780    r2 -= Start_Row;
 781    for (i = r1; i < r2; i++)
 782      {
 783         SL_Screen[i].flags |= TRASHED;
 784      }
 785 }
 786
 787 #ifndef pc_system
 788 static char Fake_Alt_Char_Pairs [] = "a:j+k+l+m+q-t+u+v+w+x|";
 789
 790 static void init_alt_char_set (void)
 791 {
 792    int i;
 793    unsigned char *p, *pmax, ch;
 794
 795    if (Alt_Char_Set[128] == 128) return;
 796
 797    i = 32;
 798    memset ((char *)Alt_Char_Set, ' ', i);
 799    while (i <= 128)
 800      {
 801         Alt_Char_Set [i] = i;
 802         i++;
 803      }
 804
 805    /* Map to VT100 */
 806    if (SLtt_Has_Alt_Charset)
 807      {
 808         p = (unsigned char *) SLtt_Graphics_Char_Pairs;
 809         if (p == NULL) return;
 810      }
 811    else p = (unsigned char *) Fake_Alt_Char_Pairs;
 812    pmax = p + strlen ((char *) p);
 813
 814    /* Some systems have messed up entries for this */
 815    while (p < pmax)
 816      {
 817         ch = *p++;
 818         ch &= 0x7F;                    /* should be unnecessary */
 819         Alt_Char_Set [ch] = *p;
 820         p++;
 821      }
 822 }
 823 #endif
 824
 825 #ifndef pc_system
 826 # define BLOCK_SIGNALS SLsig_block_signals ();
 827 # define UNBLOCK_SIGNALS SLsig_unblock_signals ();
 828 #else
 829 # define BLOCK_SIGNALS
 830 # define UNBLOCK_SIGNALS
 831 #endif
 832
 833 static int Smg_Suspended;
 834 void SLsmg_suspend_smg (void)
 835 {
 836    BLOCK_SIGNALS
 837
 838    if (Smg_Suspended == 0)
 839      {
 840         SLtt_reset_video ();
 841         Smg_Suspended = 1;
 842      }
 843
 844    UNBLOCK_SIGNALS
 845 }
 846
 847 void SLsmg_resume_smg (void)
 848 {
 849    int i;
 850    BLOCK_SIGNALS
 851
 852    if (Smg_Suspended == 0)
 853      {
 854         UNBLOCK_SIGNALS
 855         return;
 856      }
 857
 858    Smg_Suspended = 0;
 859    SLtt_init_video ();
 860    Cls_Flag = 1;
 861    for (i = 0; i < Screen_Rows; i++)
 862      SL_Screen[i].flags |= TRASHED;
 863    SLsmg_refresh ();
 864
 865    UNBLOCK_SIGNALS
 866 }
 867
 868 int SLsmg_init_smg (void)
 869 {
 870    int i, len;
 871    unsigned short *old, *neew;
 872    BLOCK_SIGNALS
 873
 874    if (Smg_Inited) SLsmg_reset_smg ();
 875    SLtt_init_video ();
 876    Screen_Cols = SLtt_Screen_Cols;
 877    Screen_Rows = SLtt_Screen_Rows;
 878    This_Col = This_Row = Start_Col = Start_Row = 0;
 879
 880    This_Color = 0;
 881    This_Alt_Char = 0;
 882    Cls_Flag = 1;
 883 #ifndef pc_system
 884    init_alt_char_set ();
 885 #endif
 886    len = Screen_Cols + 3;
 887    for (i = 0; i < Screen_Rows; i++)
 888      {
 889         if ((NULL == (old = (unsigned short *) SLMALLOC (sizeof(short) * len)))
 890             || ((NULL == (neew = (unsigned short *) SLMALLOC (sizeof(short) * len)))))
 891           {
 892              SLang_Error = SL_MALLOC_ERROR;
 893              UNBLOCK_SIGNALS
 894              return 0;
 895           }
 896         blank_line (old, len, ' ');
 897         blank_line (neew, len, ' ');
 898         SL_Screen[i].old = old;
 899         SL_Screen[i].neew = neew;
 900         SL_Screen[i].flags = 0;
 901 #ifndef pc_system
 902         Blank_Hash = compute_hash (old, Screen_Cols);
 903         SL_Screen[i].new_hash = SL_Screen[i].old_hash =  Blank_Hash;
 904 #endif
 905      }
 906    Smg_Inited = 1;
 907    UNBLOCK_SIGNALS
 908    return 1;
 909 }
 910
 911
 912 void SLsmg_reset_smg (void)
 913 {
 914    int i;
 915    BLOCK_SIGNALS
 916
 917    if (Smg_Inited == 0)
 918      {
 919         UNBLOCK_SIGNALS
 920         return;
 921      }
 922    for (i = 0; i < Screen_Rows; i++)
 923      {
 924         if (SL_Screen[i].old != NULL) SLFREE (SL_Screen[i].old);
 925         if (SL_Screen[i].neew != NULL) SLFREE (SL_Screen[i].neew);
 926         SL_Screen[i].old = SL_Screen[i].neew = NULL;
 927      }
 928    SLtt_reset_video ();
 929    This_Alt_Char = This_Color = 0;
 930    Smg_Inited = 0;
 931
 932    UNBLOCK_SIGNALS
 933 }
 934
 935
 936 unsigned short SLsmg_char_at (void)
 937 {
 938    if (point_visible (1))
 939      {
 940         return SL_Screen[This_Row - Start_Row].neew[This_Col - Start_Col];
 941      }
 942    return 0;
 943 }
 944
 945
 946 void SLsmg_vprintf (char *fmt, va_list ap)
 947 {
 948    char p[1000];
 949
 950    (void) g_vsnprintf(p, sizeof (p), fmt, ap);
 951
 952    SLsmg_write_string (p);
 953 }
 954
 955 void SLsmg_set_screen_start (int *r, int *c)
 956 {
 957    int or = Start_Row, oc = Start_Col;
 958
 959    if (c == NULL) Start_Col = 0;
 960    else
 961      {
 962         Start_Col = *c;
 963         *c = oc;
 964      }
 965    if (r == NULL) Start_Row = 0;
 966    else
 967      {
 968         Start_Row = *r;
 969         *r = or;
 970      }
 971 }
 972
 973 void SLsmg_draw_object (int r, int c, unsigned char object)
 974 {
 975    This_Row = r;  This_Col = c;
 976
 977    if (point_visible (1))
 978      {
 979         int color = This_Color;
 980         This_Color |= ALT_CHAR_FLAG;
 981         SLsmg_write_char (object);
 982         This_Color = color;
 983      }
 984
 985    This_Col = c + 1;
 986 }
 987
 988 void SLsmg_draw_hline (int n)
 989 {
 990    static unsigned char hbuf[16];
 991    int count;
 992    int cmin, cmax;
 993    int final_col = This_Col + n;
 994    int save_color;
 995
 996    if ((This_Row < Start_Row) || (This_Row >= Start_Row + Screen_Rows)
 997        || (0 == compute_clip (This_Col, n, Start_Col, Start_Col + Screen_Cols,
 998                               &cmin, &cmax)))
 999      {
1000         This_Col = final_col;
1001         return;
1002      }
1003
1004    if (hbuf[0] == 0)
1005      {
1006         SLMEMSET ((char *) hbuf, SLSMG_HLINE_CHAR, 16);
1007      }
1008
1009    n = cmax - cmin;
1010    count = n / 16;
1011
1012    save_color = This_Color;
1013    This_Color |= ALT_CHAR_FLAG;
1014    This_Col = cmin;
1015
1016    SLsmg_write_nchars ((char *) hbuf, n % 16);
1017    while (count-- > 0)
1018      {
1019         SLsmg_write_nchars ((char *) hbuf, 16);
1020      }
1021
1022    This_Color = save_color;
1023    This_Col = final_col;
1024 }
1025
1026 void SLsmg_draw_vline (int n)
1027 {
1028    unsigned char ch = SLSMG_VLINE_CHAR;
1029    int c = This_Col, rmin, rmax;
1030    int final_row = This_Row + n;
1031    int save_color;
1032
1033    if (((c < Start_Col) || (c >= Start_Col + Screen_Cols)) ||
1034        (0 == compute_clip (This_Row, n, Start_Row, Start_Row + Screen_Rows,
1035                           &rmin, &rmax)))
1036      {
1037         This_Row = final_row;
1038         return;
1039      }
1040
1041    save_color = This_Color;
1042    This_Color |= ALT_CHAR_FLAG;
1043
1044    for (This_Row = rmin; This_Row < rmax; This_Row++)
1045      {
1046         This_Col = c;
1047         SLsmg_write_nchars ((char *) &ch, 1);
1048      }
1049
1050    This_Col = c;  This_Row = final_row;
1051    This_Color = save_color;
1052 }
1053
1054 void SLsmg_draw_box (int r, int c, int dr, int dc)
1055 {
1056    if (!dr || !dc) return;
1057    This_Row = r;  This_Col = c;
1058    dr--; dc--;
1059    SLsmg_draw_hline (dc);
1060    SLsmg_draw_vline (dr);
1061    This_Row = r;  This_Col = c;
1062    SLsmg_draw_vline (dr);
1063    SLsmg_draw_hline (dc);
1064    SLsmg_draw_object (r, c, SLSMG_ULCORN_CHAR);
1065    SLsmg_draw_object (r, c + dc, SLSMG_URCORN_CHAR);
1066    SLsmg_draw_object (r + dr, c, SLSMG_LLCORN_CHAR);
1067    SLsmg_draw_object (r + dr, c + dc, SLSMG_LRCORN_CHAR);
1068    This_Row = r; This_Col = c;
1069 }
1070
1071 void SLsmg_fill_region (int r, int c, int dr, int dc, unsigned char ch)
1072 {
1073    static unsigned char hbuf[16];
1074    int count;
1075    int dcmax, rmax;
1076
1077
1078    if ((dc < 0) || (dr < 0)) return;
1079
1080    SLsmg_gotorc (r, c);
1081    r = This_Row; c = This_Col;
1082
1083    dcmax = Screen_Cols - This_Col;
1084    if (dc > dcmax) dc = dcmax;
1085
1086    rmax = This_Row + dr;
1087    if (rmax > Screen_Rows) rmax = Screen_Rows;
1088
1089 #if 0
1090    ch = Alt_Char_Set[ch];
1091 #endif
1092    if (ch != hbuf[0]) SLMEMSET ((char *) hbuf, (char) ch, 16);
1093
1094    for (This_Row = r; This_Row < rmax; This_Row++)
1095      {
1096         This_Col = c;
1097         count = dc / 16;
1098         SLsmg_write_nchars ((char *) hbuf, dc % 16);
1099         while (count-- > 0)
1100           {
1101              SLsmg_write_nchars ((char *) hbuf, 16);
1102           }
1103      }
1104
1105    This_Row = r;
1106 }
1107
1108 void SLsmg_forward (int n)
1109 {
1110    This_Col += n;
1111 }
1112
1113 void SLsmg_write_color_chars (unsigned short *s, unsigned int len)
1114 {
1115    unsigned short *smax, sh;
1116    char buf[32], *b, *bmax;
1117    int color, save_color;
1118
1119    smax = s + len;
1120    b = buf;
1121    bmax = b + sizeof (buf);
1122
1123    save_color = This_Color;
1124
1125    while (s < smax)
1126      {
1127         sh = *s++;
1128
1129         color = sh >> 8;
1130         if ((color != This_Color) || (b == bmax))
1131           {
1132              if (b != buf)
1133                {
1134                   SLsmg_write_nchars (buf, (int) (b - buf));
1135                   b = buf;
1136                }
1137              This_Color = color;
1138           }
1139         *b++ = (char) (sh & 0xFF);
1140      }
1141
1142    if (b != buf)
1143      SLsmg_write_nchars (buf, (int) (b - buf));
1144
1145    This_Color = save_color;
1146 }
1147
1148 unsigned int SLsmg_read_raw (unsigned short *buf, unsigned int len)
1149 {
1150    unsigned int r, c;
1151
1152    if (0 == point_visible (1)) return 0;
1153
1154    r = (unsigned int) (This_Row - Start_Row);
1155    c = (unsigned int) (This_Col - Start_Col);
1156
1157    if (c + len > (unsigned int) Screen_Cols)
1158      len = (unsigned int) Screen_Cols - c;
1159
1160    memcpy ((char *) buf, (char *) (SL_Screen[r].neew + c), len * sizeof (short));
1161    return len;
1162 }
1163
1164 unsigned int SLsmg_write_raw (unsigned short *buf, unsigned int len)
1165 {
1166    unsigned int r, c;
1167    unsigned short *dest;
1168
1169    if (0 == point_visible (1)) return 0;
1170
1171    r = (unsigned int) (This_Row - Start_Row);
1172    c = (unsigned int) (This_Col - Start_Col);
1173
1174    if (c + len > (unsigned int) Screen_Cols)
1175      len = (unsigned int) Screen_Cols - c;
1176
1177    dest = SL_Screen[r].neew + c;
1178
1179    if (0 != memcmp ((char *) dest, (char *) buf, len * sizeof (short)))
1180      {
1181         memcpy ((char *) dest, (char *) buf, len * sizeof (short));
1182         SL_Screen[r].flags |= TOUCHED;
1183      }
1184    return len;
1185 }