/* -*- mode: C; mode: fold -*- */ /* Copyright (c) 1992, 1997, 2001, 2002 John E. Davis * This file is part of the S-Lang library. * * You may distribute under the terms of either the GNU General Public * License or the Perl Artistic License. */ /* This file is best edited with a folding editor */ #include "slinclud.h" #if !defined(__WIN32__) && !defined(__IBMC__) # include #endif #include "slang.h" #include "_slang.h" int SLtt_Term_Cannot_Insert; int SLtt_Term_Cannot_Scroll; int SLtt_Ignore_Beep = 3; int SLtt_Use_Ansi_Colors; int SLtt_Has_Status_Line = 0; int SLtt_Screen_Rows = 25; int SLtt_Screen_Cols = 80; int SLtt_Msdos_Cheap_Video = 0; void (*_SLtt_color_changed_hook)(void); /* This definition will need changing when SLsmg_Char_Type changes. */ #define SLSMG_CHAR_TO_USHORT(x) ((unsigned short)(x)) /*{{{ ------------- static local variables ---------- */ static int Attribute_Byte; static int Scroll_r1 = 0, Scroll_r2 = 25; static int Cursor_Row = 1, Cursor_Col = 1; static int Current_Color; static int IsColor = 1; static int Blink_Killed = 1; /* high intensity background enabled */ #define JMAX_COLORS 256 #define JNORMAL_COLOR 0 #define JNO_COLOR -1 static unsigned char Color_Map [JMAX_COLORS] = { 0x7, 0x70, 0x70, 0x70, 0x70, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7 }; #define JMAX_COLOR_NAMES 16 static const char * const Color_Names [JMAX_COLOR_NAMES] = { "black", "blue", "green", "cyan", "red", "magenta", "brown", "lightgray", "gray", "brightblue", "brightgreen", "brightcyan", "brightred", "brightmagenta", "yellow", "white" }; static void fixup_colors (void); /*}}}*/ static void goto_rc_abs (int r, int c) { SLtt_goto_rc (r - Scroll_r1, c); } #if defined(__BORLANDC__) && defined(__MSDOS__) # define IBMPC_ASM_VIDEO 1 #endif #if defined(__WATCOMC__) && !defined(__NT__) && !defined(__os2__) # define WATCOM_VIDEO 1 #endif #if defined (__GO32__) # define GO32_VIDEO 1 #endif #if defined (__EMX__) /* EMX video does both DOS & OS/2 */ # define EMX_VIDEO 1 #else # if defined(__os2__) # define OS2_VIDEO 1 # endif #endif #if defined (__WIN32__) # define WIN32_VIDEO 1 #endif /* The functions in these folds contain somewhat video system specific code * that if merged together into single functions will become a confusing * mess. */ #ifdef IBMPC_ASM_VIDEO /*{{{*/ # include # include # include /* buffer to hold a line of character/attribute pairs */ #define MAXCOLS 256 static unsigned char Line_Buffer [MAXCOLS*2]; #define MK_SPACE_CHAR() (((Attribute_Byte) << 8) | 0x20) static unsigned char *Video_Base; # define MK_SCREEN_POINTER(row,col) ((unsigned short *)\ (Video_Base +\ 2 * (SLtt_Screen_Cols * (row)\ + (col)))) static int Video_Status_Port; # define MONO_STATUS 0x3BA # define CGA_STATUS 0x3DA # define CGA_SETMODE 0x3D8 # define SNOW_CHECK \ if (SLtt_Msdos_Cheap_Video)\ { while ((inp (CGA_STATUS) & 0x08)); while (!(inp (CGA_STATUS) & 0x08)); } void SLtt_write_string (char *str) { /* FIXME: Priority=medium * This should not go to stdout. */ fputs (str, stdout); } /* row is with respect to the scrolling region. */ void SLtt_goto_rc (int r, int c) { union REGS regs; r += Scroll_r1; if (r > SLtt_Screen_Rows - 1) r = SLtt_Screen_Rows - 1; if (c > SLtt_Screen_Cols - 1) c = SLtt_Screen_Cols - 1; Cursor_Row = r; Cursor_Col = c; regs.h.dh = r; regs.h.dl = c; regs.h.bh = 0; regs.h.ah = 2; int86 (0x10, ®s, ®s); } static void asm_video_getxy (void) { asm mov ah, 3 asm mov bh, 0 asm int 10h asm xor ax, ax asm mov al, dh asm mov Cursor_Row, ax asm xor ax, ax asm mov al, dl asm mov Cursor_Col, ax } void SLtt_begin_insert (void) { unsigned short *p; int n; asm_video_getxy (); n = SLtt_Screen_Cols - Cursor_Col; p = MK_SCREEN_POINTER (Cursor_Row, SLtt_Screen_Cols - 1); SNOW_CHECK; asm mov ax, ds asm mov bx, di asm mov dx, si asm mov cx, n asm les di, p asm lds si, p asm sub si, 2 asm std asm rep movsw asm mov ds, ax asm mov di, bx asm mov si, dx } void SLtt_end_insert (void) { } void SLtt_delete_char (void) { unsigned short *p; int n; asm_video_getxy (); n = SLtt_Screen_Cols - Cursor_Col - 1; p = MK_SCREEN_POINTER (Cursor_Row, Cursor_Col); SNOW_CHECK; asm mov ax, ds asm mov bx, si asm mov dx, di asm mov cx, n asm les di, p asm lds si, p asm add si, 2 asm cld asm rep movsw asm mov ds, ax asm mov si, bx asm mov di, dx } void SLtt_erase_line (void) { unsigned short w, *p; p = MK_SCREEN_POINTER (Cursor_Row, 0); Attribute_Byte = 0x07; w = MK_SPACE_CHAR (); SNOW_CHECK; asm mov dx, di asm mov ax, w asm mov cx, SLtt_Screen_Cols asm les di, p asm cld asm rep stosw asm mov di, dx Current_Color = JNO_COLOR; /* since we messed with attribute byte */ } void SLtt_delete_nlines (int nlines) { SLtt_normal_video (); /* This has the effect of pulling all lines below it up */ asm mov ax, nlines asm mov ah, 6 /* int 6h */ asm xor cx, cx asm mov ch, byte ptr Scroll_r1 asm mov dx, SLtt_Screen_Cols asm dec dx asm mov dh, byte ptr Scroll_r2 asm mov bh, byte ptr Attribute_Byte asm int 10h } void SLtt_reverse_index (int nlines) { SLtt_normal_video (); asm xor cx, cx asm mov ch, byte ptr Scroll_r1 asm mov dx, SLtt_Screen_Cols asm dec dx asm mov dh, byte ptr Scroll_r2 asm mov bh, byte ptr Attribute_Byte asm mov ah, 7 asm mov al, byte ptr nlines asm int 10h } static void asm_video_invert_region (int top_row, int bot_row) { register unsigned short ch, sh; register unsigned short *pmin = MK_SCREEN_POINTER (top_row, 0); register unsigned short *pmax = MK_SCREEN_POINTER (bot_row, 0); while (pmin < pmax) { sh = *pmin; ch = sh; ch = ch ^ 0xFF00; *pmin = (ch & 0xFF00) | (sh & 0x00FF); pmin++; } } void SLtt_del_eol (void) { unsigned short *p; unsigned short w; int n; n = SLtt_Screen_Cols - Cursor_Col; p = MK_SCREEN_POINTER (Cursor_Row, Cursor_Col); if (Current_Color != JNO_COLOR) SLtt_normal_video (); w = MK_SPACE_CHAR (); SNOW_CHECK; asm mov dx, di asm les di, p asm mov ax, w asm mov cx, n asm cld asm rep stosw asm mov di, dx } static unsigned short *asm_video_write (register unsigned char *pp, register unsigned char *p, register unsigned short *pos) { int n = (int) (p - pp); /* num of characters of PP to write */ asm push si asm push ds asm push di /* set up register for BOTH fast and slow */ asm mov bx, SLtt_Msdos_Cheap_Video /* These are the registers needed for both fast AND slow */ asm mov ah, byte ptr Attribute_Byte asm mov cx, n asm lds si, dword ptr pp asm les di, dword ptr pos asm cld asm cmp bx, 0 /* cheap video test */ asm je L_fast asm mov bx, ax asm mov dx, CGA_STATUS asm jg L_slow_blank /* slow video */ asm cli /* wait for retrace */ L_slow: asm in al, dx asm test al, 1 asm jnz L_slow L_slow1: asm in al, dx asm test al, 1 asm jz L_slow1 /* move a character out */ asm mov ah, bh asm lodsb asm stosw asm loop L_slow asm sti asm jmp done /* -------------- slow video, vertical retace and pump --------------*/ L_slow_blank: L_slow_blank_loop: asm in al, dx asm test al, 8 asm jnz L_slow_blank_loop L_slow_blank1: asm in al, dx asm test al, 8 asm jz L_slow_blank1 /* write line */ asm mov ah, bh L_slow_blank2: asm lodsb asm stosw asm loop L_slow_blank2 asm jmp done /*-------------- Fast video --------------*/ L_fast: asm lodsb asm stosw asm loop L_fast done: asm pop di asm pop ds asm pop si return (pos + n); } static void write_attributes (SLsmg_Char_Type *src, unsigned int count) { register unsigned char *p; register unsigned short pair; unsigned char ch, color; register unsigned short *pos; p = Line_Buffer; pos = MK_SCREEN_POINTER (Cursor_Row, 0); while (count--) { pair = SLSMG_CHAR_TO_USHORT(*src); /* character/color pair */ src++; ch = pair & 0xff; /* character value */ color = pair >> 8; /* color value */ if (color != Current_Color) /* need a new color */ { if (p != Line_Buffer) { pos = asm_video_write (Line_Buffer, p, pos); p = Line_Buffer; } SLtt_reverse_video (color); /* change color */ } *(p++) = ch; } pos = asm_video_write (Line_Buffer, p, pos); } void SLtt_cls (void) { SLtt_normal_video (); asm mov dx, SLtt_Screen_Cols asm dec dx asm mov ax, SLtt_Screen_Rows asm dec ax asm mov dh, al asm xor cx, cx asm xor ax, ax asm mov ah, 7 asm mov bh, byte ptr Attribute_Byte asm int 10h } void SLtt_putchar (char ch) { unsigned short p, *pp; if (Current_Color) SLtt_normal_video (); asm_video_getxy (); /* get current position */ switch (ch) { case 7: /* ^G - break */ SLtt_beep (); break; case 8: /* ^H - backspace */ goto_rc_abs (Cursor_Row, Cursor_Col - 1); break; case 13: /* ^M - carriage return */ goto_rc_abs (Cursor_Row, 0); break; default: /* write character to screen */ pp = MK_SCREEN_POINTER (Cursor_Row, Cursor_Col); p = (Attribute_Byte << 8) | (unsigned char) ch; SNOW_CHECK; *pp = p; goto_rc_abs (Cursor_Row, Cursor_Col + 1); } } void SLtt_get_screen_size (void) { int w, h; h = 0; /* Get BIOS's screenwidth, this works on ALL displays. */ w = *((int *)MK_FP(0x40, 0x4a)); /* Use Ralf Brown test for EGA or greater */ asm mov ah, 12h asm mov bl, 10h asm mov bh, 0xFF /* EGA or greater will change this */ asm int 10h asm cmp bh, 0xFF asm je L1 /* if EGA or compatible: Get BIOS's number of rows. */ h = *(char *)MK_FP(0x40, 0x84) + 1; /* scan_lines = *(int *) 0x485; */ L1: if (h <= 0) h = 25; SLtt_Screen_Rows = h; SLtt_Screen_Cols = w; } void SLtt_get_terminfo (void) { SLtt_get_screen_size (); } /*----------------------------------------------------------------------*\ * Function: int SLtt_init_video (void); \*----------------------------------------------------------------------*/ int SLtt_init_video (void) { unsigned char *p; #ifdef HAS_SAVE_SCREEN save_screen (); #endif Cursor_Row = Cursor_Col = 0; p = (unsigned char far *) 0x00400049L; if (*p == 7) { Video_Status_Port = MONO_STATUS; Video_Base = (unsigned char *) MK_FP (0xb000,0000); IsColor = 0; } else { Video_Status_Port = CGA_STATUS; Video_Base = (unsigned char *) MK_FP (0xb800,0000); IsColor = 1; } /* test for video adapter type. Of primary interest is whether there is * snow or not. Assume snow if the card is color and not EGA or greater. */ /* Use Ralf Brown test for EGA or greater */ asm mov ah, 0x12 asm mov bl, 0x10 asm mov bh, 0xFF asm int 10h asm cmp bh, 0xFF asm je L1 /* (V)EGA */ asm xor bx, bx asm mov SLtt_Msdos_Cheap_Video, bx asm mov ax, Attribute_Byte asm cmp ax, bx asm jne L2 asm mov ax, 0x17 asm mov Attribute_Byte, ax asm jmp L2 L1: /* Not (V)EGA */ asm mov ah, 0x0F asm int 10h asm cmp al, 7 asm je L3 asm mov ax, 1 asm mov SLtt_Msdos_Cheap_Video, ax L3: asm mov ax, Attribute_Byte asm cmp ax, 0 asm jne L2 asm mov ax, 0x07 asm mov Attribute_Byte, ax L2: /* toggle the blink bit so we can use hi intensity background */ if (IsColor && !SLtt_Msdos_Cheap_Video) { asm mov ax, 0x1003 asm mov bx, 0 asm int 0x10 Blink_Killed = 1; } SLtt_Use_Ansi_Colors = IsColor; SLtt_get_screen_size (); SLtt_reset_scroll_region (); fixup_colors (); return 0; } void SLtt_beep (void) { int audible; /* audible bell */ int special = 0; /* first row to invert */ int visual = 0; /* final row to invert */ if (!SLtt_Ignore_Beep) return; audible = (SLtt_Ignore_Beep & 1); if ( (SLtt_Ignore_Beep & 4) ) { special = SLtt_Screen_Rows - 1; visual = special--; /* only invert bottom status line */ } else if ( (SLtt_Ignore_Beep & 2) ) { visual = SLtt_Screen_Rows; } if (visual) asm_video_invert_region (special, visual); if (audible) sound (1500); delay (100); if (audible) nosound (); if (visual) asm_video_invert_region (special, visual); } #endif /* IBMPC_ASM_VIDEO */ /*}}}*/ #ifdef GO32_VIDEO /*{{{*/ # include # define HAS_SAVE_SCREEN 1 # ifdef HAS_SAVE_SCREEN static void *Saved_Screen_Buffer; static int Saved_Cursor_Row; static void save_screen (void) { int row, col; SLfree ((char *) Saved_Screen_Buffer); Saved_Screen_Buffer = NULL; Saved_Screen_Buffer = (short *) SLmalloc (sizeof (short) * ScreenCols () * ScreenRows ()); if (Saved_Screen_Buffer == NULL) return; ScreenRetrieve (Saved_Screen_Buffer); ScreenGetCursor (&row, &col); Saved_Cursor_Row = row; } static void restore_screen (void) { if (Saved_Screen_Buffer == NULL) return; ScreenUpdate (Saved_Screen_Buffer); goto_rc_abs (Saved_Cursor_Row, 0); } #endif /* HAS_SAVE_SCREEN */ void SLtt_write_string (char *str) { while (Cursor_Col < SLtt_Screen_Cols) { char ch = *str++; if (ch == 0) break; ScreenPutChar (ch, Attribute_Byte, Cursor_Col, Cursor_Row); Cursor_Col++; } goto_rc_abs (Cursor_Row, Cursor_Col); } void SLtt_goto_rc (int row, int col) { row += Scroll_r1; if (row > SLtt_Screen_Rows) row = SLtt_Screen_Rows; if (col > SLtt_Screen_Cols) col = SLtt_Screen_Cols; ScreenSetCursor (row, col); Cursor_Row = row; Cursor_Col = col; } static void go32_video_getxy (void) { ScreenGetCursor (&Cursor_Row, &Cursor_Col); } static void go32_video_deleol (int x) { while (x < SLtt_Screen_Cols) ScreenPutChar (32, Attribute_Byte, x++, Cursor_Row); } void SLtt_begin_insert (void) { } void SLtt_end_insert (void) { } void SLtt_delete_char (void) { } void SLtt_erase_line (void) { Attribute_Byte = 0x07; go32_video_deleol (0); Current_Color = JNO_COLOR; /* since we messed with attribute byte */ } void SLtt_delete_nlines (int nlines) { union REGS r; SLtt_normal_video (); r.x.ax = nlines; r.x.cx = 0; r.h.ah = 6; r.h.ch = Scroll_r1; r.h.dl = SLtt_Screen_Cols - 1; r.h.dh = Scroll_r2; r.h.bh = Attribute_Byte; int86 (0x10, &r, &r); } void SLtt_reverse_index (int nlines) { union REGS r; SLtt_normal_video (); r.h.al = nlines; r.x.cx = 0; r.h.ah = 7; r.h.ch = Scroll_r1; r.h.dl = SLtt_Screen_Cols - 1; r.h.dh = Scroll_r2; r.h.bh = Attribute_Byte; int86 (0x10, &r, &r); } static void go32_video_invert_region (int top_row, int bot_row) { unsigned char buf [2 * 180 * 80]; /* 180 cols x 80 rows */ unsigned char *b, *bmax; b = buf + 1 + 2 * SLtt_Screen_Cols * top_row; bmax = buf + 1 + 2 * SLtt_Screen_Cols * bot_row; ScreenRetrieve (buf); while (b < bmax) { *b ^= 0xFF; b += 2; } ScreenUpdate (buf); } void SLtt_beep (void) { int audible; /* audible bell */ int special = 0; /* first row to invert */ int visual = 0; /* final row to invert */ if (!SLtt_Ignore_Beep) return; audible = (SLtt_Ignore_Beep & 1); if ( (SLtt_Ignore_Beep & 4) ) { special = SLtt_Screen_Rows - 1; visual = special--; /* only invert bottom status line */ } else if ( (SLtt_Ignore_Beep & 2) ) { visual = SLtt_Screen_Rows; } if (visual) go32_video_invert_region (special, visual); if (audible) sound (1500); delay (100); if (audible) nosound (); if (visual) go32_video_invert_region (special, visual); } void SLtt_del_eol (void) { if (Current_Color != JNO_COLOR) SLtt_normal_video (); go32_video_deleol (Cursor_Col); } static void write_attributes (SLsmg_Char_Type *src, unsigned int count) { register unsigned short pair; unsigned int n; /* write into a character/attribute pair */ n = Cursor_Col; while (count) { pair = SLSMG_CHAR_TO_USHORT(*src);/* character/color pair */ src++; SLtt_reverse_video (pair >> 8); /* color change */ ScreenPutChar ((int)pair & 0xFF, Attribute_Byte, n, Cursor_Row); n++; count--; } } /*----------------------------------------------------------------------*\ * Function: void SLtt_cls (void); \*----------------------------------------------------------------------*/ void SLtt_cls (void) { SLtt_normal_video (); SLtt_reset_scroll_region (); SLtt_goto_rc (0, 0); SLtt_delete_nlines (SLtt_Screen_Rows); } void SLtt_putchar (char ch) { if (Current_Color) SLtt_normal_video (); go32_video_getxy (); /* get current position */ switch (ch) { case 7: /* ^G - break */ SLtt_beep (); break; case 8: /* ^H - backspace */ goto_rc_abs (Cursor_Row, Cursor_Col - 1); break; case 13: /* ^M - carriage return */ goto_rc_abs (Cursor_Row, 0); break; default: /* write character to screen */ ScreenPutChar ((int) ch, Attribute_Byte, Cursor_Col, Cursor_Row); goto_rc_abs (Cursor_Row, Cursor_Col + 1); } } void SLtt_get_screen_size (void) { SLtt_Screen_Rows = ScreenRows (); SLtt_Screen_Cols = ScreenCols (); } void SLtt_get_terminfo (void) { SLtt_get_screen_size (); } int SLtt_init_video (void) { #ifdef HAS_SAVE_SCREEN save_screen (); #endif if (!Attribute_Byte) Attribute_Byte = 0x17; IsColor = 1; /* is it really? */ if (IsColor) { union REGS r; r.x.ax = 0x1003; r.x.bx = 0; int86 (0x10, &r, &r); Blink_Killed = 1; } Cursor_Row = Cursor_Col = 0; SLtt_Term_Cannot_Insert = 1; SLtt_reset_scroll_region (); SLtt_Use_Ansi_Colors = IsColor; fixup_colors (); return 0; } #endif /* GO32_VIDEO */ /*}}}*/ #ifdef EMX_VIDEO /*{{{*/ # define INCL_VIO # define INCL_DOSPROCESS # include # include # include static VIOMODEINFO vioModeInfo; /* buffer to hold a line of character/attribute pairs */ #define MAXCOLS 256 static unsigned char Line_Buffer [MAXCOLS*2]; /* this is how to make a space character */ #define MK_SPACE_CHAR() (((Attribute_Byte) << 8) | 0x20) void SLtt_write_string (char *str) { /* FIXME: Priority=medium * This should not go to stdout. */ fputs (str, stdout); } void SLtt_goto_rc (int row, int col) { row += Scroll_r1; if (row > SLtt_Screen_Rows) row = SLtt_Screen_Rows; if (col > SLtt_Screen_Cols) col = SLtt_Screen_Cols; v_gotoxy (col, row); Cursor_Row = row; Cursor_Col = col; } static void emx_video_getxy (void) { v_getxy (&Cursor_Col, &Cursor_Row); } static void emx_video_deleol (int x) { unsigned char *p, *pmax; int count = SLtt_Screen_Cols - x; int w = MK_SPACE_CHAR (); p = Line_Buffer; pmax = p + 2 * count; while (p < pmax) { *p++ = (unsigned char) w; *p++ = (unsigned char) (w >> 8); } v_putline (Line_Buffer, x, Cursor_Row, count); } void SLtt_begin_insert (void) { int n; emx_video_getxy (); n = SLtt_Screen_Cols - Cursor_Col; v_getline (Line_Buffer, Cursor_Col, Cursor_Row, n); v_putline (Line_Buffer, Cursor_Col+1, Cursor_Row, n - 1); } void SLtt_end_insert (void) { } void SLtt_delete_char (void) { int n; emx_video_getxy (); n = SLtt_Screen_Cols - Cursor_Col - 1; v_getline (Line_Buffer, Cursor_Col+1, Cursor_Row, n); v_putline (Line_Buffer, Cursor_Col, Cursor_Row, n); } void SLtt_erase_line (void) { Attribute_Byte = 0x07; emx_video_deleol (0); Current_Color = JNO_COLOR; /* since we messed with attribute byte */ } void SLtt_delete_nlines (int nlines) { SLtt_normal_video (); v_attrib (Attribute_Byte); v_scroll (0, Scroll_r1, SLtt_Screen_Cols-1, Scroll_r2, nlines, V_SCROLL_UP); } void SLtt_reverse_index (int nlines) { SLtt_normal_video (); v_attrib (Attribute_Byte); v_scroll (0, Scroll_r1, SLtt_Screen_Cols-1, Scroll_r2, nlines, V_SCROLL_DOWN); } static void emx_video_invert_region (int top_row, int bot_row) { int row, col; for (row = top_row; row < bot_row; row++) { v_getline (Line_Buffer, 0, row, SLtt_Screen_Cols); for (col = 1; col < SLtt_Screen_Cols * 2; col += 2) Line_Buffer [col] ^= 0xff; v_putline (Line_Buffer, 0, row, SLtt_Screen_Cols); } } void SLtt_beep (void) { int audible; /* audible bell */ int special = 0; /* first row to invert */ int visual = 0; /* final row to invert */ if (!SLtt_Ignore_Beep) return; audible = (SLtt_Ignore_Beep & 1); if ( (SLtt_Ignore_Beep & 4) ) { special = SLtt_Screen_Rows - 1; visual = special--; /* only invert bottom status line */ } else if ( (SLtt_Ignore_Beep & 2) ) { visual = SLtt_Screen_Rows; } if (visual) emx_video_invert_region (special, visual); if (audible) /*sound (1500)*/; _sleep2 (100); if (audible) /* nosound () */; if (visual) emx_video_invert_region (special, visual); } void SLtt_del_eol (void) { if (Current_Color != JNO_COLOR) SLtt_normal_video (); emx_video_deleol (Cursor_Col); } static void write_attributes (SLsmg_Char_Type *src, unsigned int count) { register unsigned char *p = Line_Buffer; register unsigned short pair; int n = count; /* write into a character/attribute pair */ while (n-- > 0) { pair = SLSMG_CHAR_TO_USHORT(*src);/* character/color pair */ src++; SLtt_reverse_video (pair >> 8); /* color change */ *(p++) = pair & 0xff; /* character byte */ *(p++) = Attribute_Byte; /* attribute byte */ } v_putline (Line_Buffer, Cursor_Col, Cursor_Row, count); } void SLtt_cls (void) { SLtt_normal_video (); SLtt_reset_scroll_region (); SLtt_goto_rc (0, 0); SLtt_delete_nlines (SLtt_Screen_Rows); } void SLtt_putchar (char ch) { if (Current_Color) SLtt_normal_video (); emx_video_getxy (); /* get current position */ switch (ch) { case 7: /* ^G - break */ SLtt_beep (); break; case 8: /* ^H - backspace */ goto_rc_abs (Cursor_Row, Cursor_Col - 1); break; case 13: /* ^M - carriage return */ goto_rc_abs (Cursor_Row, 0); break; default: /* write character to screen */ v_putn (ch, 1); goto_rc_abs (Cursor_Row, Cursor_Col + 1); } } void SLtt_get_terminfo (void) { SLtt_get_screen_size (); } void SLtt_get_screen_size (void) { vioModeInfo.cb = sizeof(vioModeInfo); VioGetMode (&vioModeInfo, 0); SLtt_Screen_Cols = vioModeInfo.col; SLtt_Screen_Rows = vioModeInfo.row; } int SLtt_init_video (void) { int OldCol, OldRow; PTIB ptib; PPIB ppib; USHORT args[3] = { 6, 2, 1 }; #ifdef HAS_SAVE_SCREEN save_screen (); #endif Cursor_Row = Cursor_Col = 0; v_init (); if ( v_hardware () != V_MONOCHROME ) IsColor = 1; else IsColor = 0; v_getxy(&OldCol,&OldRow); v_gotoxy (0, 0); if (IsColor) { if (_osmode == OS2_MODE) { # if 0 /* Enable high-intensity background colors */ VIOINTENSITY RequestBlock; RequestBlock.cb = sizeof (RequestBlock); RequestBlock.type = 2; RequestBlock.fs = 1; VioSetState (&RequestBlock, 0); /* nop if !fullscreen */ # endif } } DosGetInfoBlocks (&ptib, &ppib); if ((ppib->pib_ultype) == 2) /* VIO */ Blink_Killed = 1; else { /* Fullscreen */ if (VioSetState (args, 0) == 0) Blink_Killed = 1; else Blink_Killed = 0; } if (!Attribute_Byte) { /* find the attribute currently under the cursor */ v_getline (Line_Buffer, OldCol, OldRow, 1); Attribute_Byte = Line_Buffer[1]; SLtt_set_color (JNORMAL_COLOR, NULL, Color_Names[(Attribute_Byte) & 0xf], Color_Names[(Attribute_Byte) >> 4]); } v_attrib (Attribute_Byte); fixup_colors (); SLtt_get_screen_size (); SLtt_Use_Ansi_Colors = IsColor; SLtt_reset_scroll_region (); return 0; } #endif /* EMX_VIDEO */ /*}}}*/ #ifdef WIN32_VIDEO /*{{{*/ #include static HANDLE hStdout = INVALID_HANDLE_VALUE; #define MAXCOLS 256 static CHAR_INFO Line_Buffer [MAXCOLS]; void SLtt_write_string (char *str) { DWORD bytes; int n, c; if (str == NULL) return; n = (int) strlen (str); c = n + Cursor_Col; if (c >= SLtt_Screen_Cols) n = SLtt_Screen_Cols - Cursor_Col; if (n < 0) n = 0; (void) WriteConsole (hStdout, str, (unsigned int) n, &bytes, NULL); goto_rc_abs (Cursor_Row, Cursor_Col + n); } void SLtt_goto_rc (int row, int col) { COORD newPosition; row += Scroll_r1; if (row > SLtt_Screen_Rows) row = SLtt_Screen_Rows; if (col > SLtt_Screen_Cols) col = SLtt_Screen_Cols; newPosition.X = col; newPosition.Y = row; (void) SetConsoleCursorPosition(hStdout, newPosition); Cursor_Row = row; Cursor_Col = col; } static void win32_video_getxy (void) { CONSOLE_SCREEN_BUFFER_INFO screenInfo; if (TRUE == GetConsoleScreenBufferInfo(hStdout, &screenInfo)) { Cursor_Row = screenInfo.dwCursorPosition.Y; Cursor_Col = screenInfo.dwCursorPosition.X; } } static void win32_video_hscroll (int n) { SMALL_RECT rc; COORD c; CHAR_INFO ci; WORD w = 227; DWORD d; win32_video_getxy (); rc.Left = Cursor_Col; rc.Right = SLtt_Screen_Cols; rc.Top = rc.Bottom = Cursor_Row; c.Y = Cursor_Row; #if 1 c.X = SLtt_Screen_Cols - 1; ReadConsoleOutputAttribute(hStdout, &w, 1, c, &d); #else /* New region gets the current color */ w = Attribute_Byte; #endif c.X = Cursor_Col + n; ci.Char.AsciiChar = ' '; ci.Attributes = w; ScrollConsoleScreenBuffer(hStdout, &rc, &rc, c, &ci); } static void win32_video_deleol (int x) { DWORD d; COORD c; c.X = x; c.Y = Cursor_Row; x = SLtt_Screen_Cols - x; FillConsoleOutputCharacter(hStdout, ' ', x, c, &d); FillConsoleOutputAttribute(hStdout, (char)Attribute_Byte, x, c, &d); } static void win32_video_vscroll (int n) { SMALL_RECT rc, clip_rc; COORD c; CHAR_INFO ci; SLtt_normal_video(); /* ScrollConsoleScreenBuffer appears to have a bug when * Scroll_r1 == Scroll_r2. Sigh. */ if (Scroll_r2 == Scroll_r1) { SLtt_goto_rc (0, 0); win32_video_deleol (0); return; } rc.Left = clip_rc.Left = 0; rc.Right = clip_rc.Right = SLtt_Screen_Cols - 1; rc.Top = clip_rc.Top = Scroll_r1; rc.Bottom = clip_rc.Bottom = Scroll_r2; c.X = 0; c.Y = Scroll_r1 + n; ci.Char.AsciiChar = ' '; ci.Attributes = Attribute_Byte; ScrollConsoleScreenBuffer(hStdout, &rc, &clip_rc, c, &ci); } void SLtt_begin_insert (void) { win32_video_hscroll (1); } void SLtt_end_insert (void) { } void SLtt_delete_char (void) { win32_video_hscroll (-1); } void SLtt_erase_line (void) { Attribute_Byte = 0x7; win32_video_deleol (0); Current_Color = JNO_COLOR; } void SLtt_delete_nlines (int nlines) { win32_video_vscroll (-nlines); } void SLtt_reverse_index (int nlines) { win32_video_vscroll (nlines); } static void win32_invert_region (int top_row, int bot_row) { (void) top_row; (void) bot_row; } void SLtt_beep (void) { int audible; /* audible bell */ int special = 0; /* first row to invert */ int visual = 0; /* final row to invert */ if (!SLtt_Ignore_Beep) return; audible = (SLtt_Ignore_Beep & 1); if ( (SLtt_Ignore_Beep & 4) ) { special = SLtt_Screen_Rows - 1; visual = special--; /* only invert bottom status line */ } else if ( (SLtt_Ignore_Beep & 2) ) { visual = SLtt_Screen_Rows; } if (visual) win32_invert_region (special, visual); if (audible) Beep (1500, 100); else Sleep (100); if (visual) win32_invert_region (special, visual); } void SLtt_del_eol (void) { if (Current_Color != JNO_COLOR) SLtt_normal_video (); win32_video_deleol (Cursor_Col); } static void write_attributes (SLsmg_Char_Type *src, unsigned int count) { unsigned short pair; COORD coord, c; CHAR_INFO *p; unsigned int n; SMALL_RECT rc; /* write into a character/attribute pair */ n = count; p = Line_Buffer; while (n) { n--; pair = SLSMG_CHAR_TO_USHORT(*src);/* character/color pair */ src++; SLtt_reverse_video (pair >> 8); /* color change */ p->Char.AsciiChar = pair & 0xff; p->Attributes = Attribute_Byte; p++; } c.X = count; c.Y = 1; coord.X = coord.Y = 0; rc.Left = Cursor_Col; rc.Right = Cursor_Col + count - 1; rc.Top = rc.Bottom = Cursor_Row; WriteConsoleOutput(hStdout, Line_Buffer, c, coord, &rc); } void SLtt_cls (void) { DWORD bytes; COORD coord; char ch; SLtt_normal_video (); /* clear the WIN32 screen in one shot */ coord.X = 0; coord.Y = 0; ch = ' '; (void) FillConsoleOutputCharacter(hStdout, ch, SLtt_Screen_Cols * SLtt_Screen_Rows, coord, &bytes); /* now set screen to the current attribute */ ch = Attribute_Byte; (void) FillConsoleOutputAttribute(hStdout, ch, SLtt_Screen_Cols * SLtt_Screen_Rows, coord, &bytes); } void SLtt_putchar (char ch) { DWORD bytes; WORD attr; COORD c; if (Current_Color) SLtt_normal_video (); win32_video_getxy (); switch (ch) { case 7: /* ^G - break */ SLtt_beep (); break; case 8: /* ^H - backspace */ goto_rc_abs (Cursor_Row, Cursor_Col - 1); break; case 13: /* ^M - carriage return */ goto_rc_abs (Cursor_Row, 0); break; default: /* write character to screen */ c.X = Cursor_Col; c.Y = Cursor_Row; attr = Attribute_Byte; WriteConsoleOutputCharacter(hStdout, &ch, 1, c, &bytes); WriteConsoleOutputAttribute(hStdout, &attr, 1, c, &bytes); goto_rc_abs (Cursor_Row, Cursor_Col + 1); } } void SLtt_get_screen_size (void) { CONSOLE_SCREEN_BUFFER_INFO csbi; HANDLE h; h = hStdout; if (h == INVALID_HANDLE_VALUE) h = GetStdHandle (STD_OUTPUT_HANDLE); if ((h == INVALID_HANDLE_VALUE) || (FALSE == GetConsoleScreenBufferInfo(h, &csbi))) { SLang_exit_error ("Unable to determine the screen size"); return; } #if 0 SLtt_Screen_Rows = csbi.dwSize.Y; SLtt_Screen_Cols = csbi.dwSize.X; #else SLtt_Screen_Rows = (csbi.srWindow.Bottom - csbi.srWindow.Top) + 1; SLtt_Screen_Cols = (csbi.srWindow.Right - csbi.srWindow.Left) + 1; #endif } void SLtt_get_terminfo (void) { SLtt_get_screen_size (); } static int win32_resize (void) { SMALL_RECT windowRect; SLtt_get_screen_size (); windowRect.Left = 0; windowRect.Top = 0; windowRect.Right = SLtt_Screen_Cols - 1; windowRect.Bottom = SLtt_Screen_Rows - 1; if (FALSE == SetConsoleWindowInfo(hStdout, TRUE, &windowRect)) return -1; return 0; } static int win32_init (void) { SECURITY_ATTRIBUTES sec; memset ((char *) &sec, 0, sizeof(SECURITY_ATTRIBUTES)); sec.nLength = sizeof (SECURITY_ATTRIBUTES); sec.bInheritHandle = FALSE; hStdout = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, &sec, CONSOLE_TEXTMODE_BUFFER, 0); if (hStdout == INVALID_HANDLE_VALUE) return -1; if ((FALSE == SetConsoleActiveScreenBuffer(hStdout)) || (FALSE == SetConsoleMode(hStdout, 0)) || (-1 == win32_resize ())) { SLtt_reset_video (); return -1; } return 0; } int SLtt_init_video (void) { SLtt_reset_video (); if (-1 == win32_init ()) return -1; /* It is possible for SLtt_init_video to be called after suspension. * For all I know, the window size may have changed. So, resize it * now. */ Cursor_Row = Cursor_Col = 0; SLtt_Use_Ansi_Colors = IsColor = 1; Blink_Killed = 1; SLtt_reset_scroll_region (); goto_rc_abs (0, 0); fixup_colors (); return 0; } int SLtt_reset_video (void) { if (hStdout == INVALID_HANDLE_VALUE) return 0; SLtt_reset_scroll_region (); SLtt_goto_rc (SLtt_Screen_Rows - 1, 0); Attribute_Byte = 0x7; Current_Color = JNO_COLOR; SLtt_del_eol (); (void) CloseHandle (hStdout); hStdout = GetStdHandle (STD_OUTPUT_HANDLE); if (hStdout != INVALID_HANDLE_VALUE) (void) SetConsoleActiveScreenBuffer(hStdout); hStdout = INVALID_HANDLE_VALUE; return 0; } #endif /*}}}*/ #ifdef OS2_VIDEO /*{{{*/ # define INCL_BASE # define INCL_NOPM # define INCL_VIO # define INCL_KBD # define INCL_DOSPROCESS # include # ifndef __IBMC__ # include # endif /* this is how to make a space character */ #define MK_SPACE_CHAR() (((Attribute_Byte) << 8) | 0x20) /* buffer to hold a line of character/attribute pairs */ #define MAXCOLS 256 static unsigned char Line_Buffer [MAXCOLS*2]; void SLtt_write_string (char *str) { /* FIXME: Priority=medium * This should not go to stdout. */ fputs (str, stdout); } void SLtt_goto_rc (int row, int col) { row += Scroll_r1; VioSetCurPos (row, col, 0); Cursor_Row = row; Cursor_Col = col; } static void os2_video_getxy (void) { USHORT r, c; VioGetCurPos (&r, &c, 0); Cursor_Row = r; Cursor_Col = c; } void SLtt_begin_insert (void) { USHORT n; os2_video_getxy (); n = SLtt_Screen_Cols - Cursor_Col; n = 2 * (n - 1); VioReadCellStr ((PCH)Line_Buffer, &n, Cursor_Row, Cursor_Col, 0); VioWrtCellStr ((PCH)Line_Buffer, n, Cursor_Row, Cursor_Col + 1, 0); } void SLtt_end_insert (void) { } void SLtt_delete_char (void) { USHORT n; os2_video_getxy (); n = SLtt_Screen_Cols - Cursor_Col - 1; n *= 2; VioReadCellStr ((PCH)Line_Buffer, &n, Cursor_Row, Cursor_Col + 1, 0); VioWrtCellStr ((PCH)Line_Buffer, n, Cursor_Row, Cursor_Col, 0); } void SLtt_erase_line (void) { USHORT w; Attribute_Byte = 0x07; w = MK_SPACE_CHAR (); VioWrtNCell ((BYTE*)&w, SLtt_Screen_Cols, Cursor_Row, 0, 0); Current_Color = JNO_COLOR; /* since we messed with attribute byte */ } void SLtt_delete_nlines (int nlines) { SLtt_normal_video (); Line_Buffer[0] = ' '; Line_Buffer[1] = Attribute_Byte; VioScrollUp (Scroll_r1, 0, Scroll_r2, SLtt_Screen_Cols-1, nlines, (PCH) Line_Buffer, 0); } void SLtt_reverse_index (int nlines) { SLtt_normal_video (); Line_Buffer[0] = ' '; Line_Buffer[1] = Attribute_Byte; VioScrollDn (Scroll_r1, 0, Scroll_r2, SLtt_Screen_Cols-1, nlines, (PCH) Line_Buffer, 0); } static void os2_video_invert_region (int top_row, int bot_row) { int row, col; USHORT length = SLtt_Screen_Cols * 2; for (row = top_row; row < bot_row; row++) { VioReadCellStr ((PCH)Line_Buffer, &length, row, 0, 0); for (col = 1; col < length; col += 2) Line_Buffer [col] ^= 0xff; VioWrtCellStr ((PCH)Line_Buffer, length, row, 0, 0); } } void SLtt_beep (void) { int audible; /* audible bell */ int special = 0; /* first row to invert */ int visual = 0; /* final row to invert */ if (!SLtt_Ignore_Beep) return; audible = (SLtt_Ignore_Beep & 1); if ( (SLtt_Ignore_Beep & 4) ) { special = SLtt_Screen_Rows - 1; visual = special--; /* only invert bottom status line */ } else if ( (SLtt_Ignore_Beep & 2) ) { visual = SLtt_Screen_Rows; } if (visual) os2_video_invert_region (special, visual); if (audible) DosBeep (1500, 100); else DosSleep (100); if (visual) os2_video_invert_region (special, visual); } void SLtt_del_eol (void) { USHORT w; if (Current_Color != JNO_COLOR) SLtt_normal_video (); w = MK_SPACE_CHAR (); VioWrtNCell ((BYTE*)&w, (SLtt_Screen_Cols - Cursor_Col), Cursor_Row, Cursor_Col, 0); } static void write_attributes (SLsmg_Char_Type *src, unsigned int count) { register unsigned char *p = Line_Buffer; register unsigned short pair; int n = count; /* write into a character/attribute pair */ while (n-- > 0) { pair = SLSMG_CHAR_TO_USHORT(*src);/* character/color pair */ src++; SLtt_reverse_video (pair >> 8); /* color change */ *(p++) = pair & 0xff; /* character byte */ *(p++) = Attribute_Byte; /* attribute byte */ } VioWrtCellStr ((PCH)Line_Buffer, (USHORT)(2 * count), (USHORT)Cursor_Row, (USHORT)Cursor_Col, 0); } void SLtt_cls (void) { SLtt_normal_video (); Line_Buffer [0] = ' '; Line_Buffer [1] = Attribute_Byte; VioScrollUp (0, 0, -1, -1, -1, (PCH)Line_Buffer, 0); } void SLtt_putchar (char ch) { unsigned short p, *pp; if (Current_Color) SLtt_normal_video (); os2_video_getxy (); /* get current position */ switch (ch) { case 7: /* ^G - break */ SLtt_beep (); break; case 8: /* ^H - backspace */ goto_rc_abs (Cursor_Row, Cursor_Col - 1); break; case 13: /* ^M - carriage return */ goto_rc_abs (Cursor_Row, 0); break; default: /* write character to screen */ VioWrtCharStrAtt (&ch, 1, Cursor_Row, Cursor_Col, (BYTE*)&Attribute_Byte, 0); goto_rc_abs (Cursor_Row, Cursor_Col + 1); } } void SLtt_get_screen_size (void) { #ifdef __os2__ # ifdef __IBMC__ VIOMODEINFO vioModeInfo; # endif vioModeInfo.cb = sizeof(vioModeInfo); VioGetMode (&vioModeInfo, 0); SLtt_Screen_Cols = vioModeInfo.col; SLtt_Screen_Rows = vioModeInfo.row; #endif } void SLtt_get_terminfo (void) { SLtt_get_screen_size (); } int SLtt_init_video (void) { VIOINTENSITY RequestBlock; PTIB ptib; PPIB ppib; USHORT args[3] = { 6, 2, 1 }; Cursor_Row = Cursor_Col = 0; IsColor = 1; /* is it really? */ /* Enable high-intensity background colors */ RequestBlock.cb = sizeof (RequestBlock); RequestBlock.type = 2; RequestBlock.fs = 1; VioSetState (&RequestBlock, 0); /* nop if !fullscreen */ DosGetInfoBlocks (&ptib, &ppib); if ((ppib->pib_ultype) == 2) /* VIO */ Blink_Killed = 1; else { /* Fullscreen */ if (VioSetState (args, 0) == 0) Blink_Killed = 1; else Blink_Killed = 0; } if (!Attribute_Byte) { /* find the attribute currently under the cursor */ USHORT len, r, c; len = 2; VioGetCurPos (&r, &c, 0); VioReadCellStr ((PCH)Line_Buffer, &len, r, c, 0); Attribute_Byte = Line_Buffer[1]; SLtt_set_color (JNORMAL_COLOR, NULL, Color_Names[(Attribute_Byte) & 0xf], Color_Names[(Attribute_Byte) >> 4]); } SLtt_Use_Ansi_Colors = IsColor; SLtt_get_screen_size (); SLtt_reset_scroll_region (); fixup_colors (); return 0; } #endif /* OS2_VIDEO */ /*}}}*/ #ifdef WATCOM_VIDEO /*{{{*/ # include # define int86 int386 /* simplify code writing */ #include /* this is how to make a space character */ #define MK_SPACE_CHAR() (((Attribute_Byte) << 8) | 0x20) /* buffer to hold a line of character/attribute pairs */ #define MAXCOLS 256 static unsigned char Line_Buffer [MAXCOLS*2]; /* define for direct to memory screen writes */ static unsigned char *Video_Base; #define MK_SCREEN_POINTER(row,col) \ ((unsigned short *)(Video_Base + 2 * (SLtt_Screen_Cols * (row) + (col)))) #define ScreenPrimary (0xb800 << 4) #define ScreenSize (SLtt_Screen_Cols * SLtt_Screen_Rows) #define ScreenSetCursor(x,y) _settextposition (x+1,y+1) void ScreenGetCursor (int *x, int *y) { struct rccoord rc = _gettextposition (); *x = rc.row - 1; *y = rc.col - 1; } void ScreenRetrieve (unsigned char *dest) { memcpy (dest, (unsigned char *) ScreenPrimary, 2 * ScreenSize); } void ScreenUpdate (unsigned char *src) { memcpy ((unsigned char *) ScreenPrimary, src, 2 * ScreenSize); } void SLtt_write_string (char *str) { /* FIXME: Priority=medium * This should not go to stdout. */ fputs (str, stdout); } void SLtt_goto_rc (int row, int col) { row += Scroll_r1; if (row > SLtt_Screen_Rows) row = SLtt_Screen_Rows; if (col > SLtt_Screen_Cols) col = SLtt_Screen_Cols; ScreenSetCursor(row, col); Cursor_Row = row; Cursor_Col = col; } static void watcom_video_getxy (void) { ScreenGetCursor (&Cursor_Row, &Cursor_Col); } void SLtt_begin_insert (void) { unsigned short *p; unsigned short *pmin; int n; watcom_video_getxy (); n = SLtt_Screen_Cols - Cursor_Col; p = MK_SCREEN_POINTER (Cursor_Row, SLtt_Screen_Cols - 1); pmin = MK_SCREEN_POINTER (Cursor_Row, Cursor_Col); while (p-- > pmin) *(p + 1) = *p; } void SLtt_end_insert (void) { } void SLtt_delete_char (void) { unsigned short *p; register unsigned short *p1; int n; watcom_video_getxy (); n = SLtt_Screen_Cols - Cursor_Col - 1; p = MK_SCREEN_POINTER (Cursor_Row, Cursor_Col); while (n--) { p1 = p + 1; *p = *p1; p++; } } void SLtt_erase_line (void) { unsigned short w; unsigned short *p = MK_SCREEN_POINTER (Cursor_Row, 0); register unsigned short *pmax = p + SLtt_Screen_Cols; Attribute_Byte = 0x07; w = MK_SPACE_CHAR (); while (p < pmax) *p++ = w; Current_Color = JNO_COLOR; /* since we messed with attribute byte */ } void SLtt_delete_nlines (int nlines) { union REGS r; SLtt_normal_video (); r.x.eax = nlines; r.x.ecx = 0; r.h.ah = 6; r.h.ch = Scroll_r1; r.h.dl = SLtt_Screen_Cols - 1; r.h.dh = Scroll_r2; r.h.bh = Attribute_Byte; int86 (0x10, &r, &r); } void SLtt_reverse_index (int nlines) { union REGS r; SLtt_normal_video (); r.h.al = nlines; r.x.ecx = 0; r.h.ah = 7; r.h.ch = Scroll_r1; r.h.dl = SLtt_Screen_Cols - 1; r.h.dh = Scroll_r2; r.h.bh = Attribute_Byte; int86 (0x10, &r, &r); } static void watcom_video_invert_region (int top_row, int bot_row) { unsigned char buf [2 * 180 * 80]; /* 180 cols x 80 rows */ unsigned char *b, *bmax; b = buf + 1 + 2 * SLtt_Screen_Cols * top_row; bmax = buf + 1 + 2 * SLtt_Screen_Cols * bot_row; ScreenRetrieve (buf); while (b < bmax) { *b ^= 0xFF; b += 2; } ScreenUpdate (buf); } void SLtt_beep (void) { int audible; /* audible bell */ int special = 0; /* first row to invert */ int visual = 0; /* final row to invert */ if (!SLtt_Ignore_Beep) return; audible = (SLtt_Ignore_Beep & 1); if ( (SLtt_Ignore_Beep & 4) ) { special = SLtt_Screen_Rows - 1; visual = special--; /* only invert bottom status line */ } else if ( (SLtt_Ignore_Beep & 2) ) { visual = SLtt_Screen_Rows; } if (visual) watcom_video_invert_region (special, visual); if (audible) sound (1500); delay (100); if (audible) nosound (); if (visual) watcom_video_invert_region (special, visual); } void SLtt_del_eol (void) { unsigned short *p, *pmax; unsigned short w; int n; n = SLtt_Screen_Cols - Cursor_Col; p = MK_SCREEN_POINTER (Cursor_Row, Cursor_Col); pmax = p + n; if (Current_Color != JNO_COLOR) SLtt_normal_video (); w = MK_SPACE_CHAR (); while (p < pmax) *p++ = w; } static void write_attributes (SLsmg_Char_Type *src, unsigned int count) { register unsigned short pair; register unsigned short *pos = MK_SCREEN_POINTER (Cursor_Row, 0); /* write into a character/attribute pair */ while (count--) { pair = SLSMG_CHAR_TO_USHORT(*src);/* character/color pair */ src++; SLtt_reverse_video (pair >> 8); /* color change */ *(pos++) = ((unsigned short) Attribute_Byte << 8) | (pair & 0xff); } } void SLtt_cls (void) { SLtt_normal_video (); SLtt_reset_scroll_region (); SLtt_goto_rc (0, 0); SLtt_delete_nlines (SLtt_Screen_Rows); } void SLtt_putchar (char ch) { unsigned short p, *pp; if (Current_Color) SLtt_normal_video (); watcom_video_getxy (); switch (ch) { case 7: /* ^G - break */ SLtt_beep (); break; case 8: /* ^H - backspace */ goto_rc_abs (Cursor_Row, Cursor_Col - 1); break; case 13: /* ^M - carriage return */ goto_rc_abs (Cursor_Row, 0); break; default: /* write character to screen */ p = (Attribute_Byte << 8) | (unsigned char) ch; pp = MK_SCREEN_POINTER (Cursor_Row, Cursor_Col); *pp = p; goto_rc_abs (Cursor_Row, Cursor_Col + 1); } } void SLtt_get_screen_size (void) { struct videoconfig vc; _getvideoconfig(&vc); SLtt_Screen_Rows = vc.numtextrows; SLtt_Screen_Cols = vc.numtextcols; } void SLtt_get_terminfo (void) { SLtt_get_screen_size (); } int SLtt_init_video (void) { #ifdef HAS_SAVE_SCREEN save_screen (); #endif Cursor_Row = Cursor_Col = 0; Video_Base = (unsigned char *) ScreenPrimary; if (!Attribute_Byte) Attribute_Byte = 0x17; IsColor = 1; /* is it really? */ if (IsColor) { union REGS r; r.x.eax = 0x1003; r.x.ebx = 0; int86 (0x10, &r, &r); Blink_Killed = 1; } SLtt_Use_Ansi_Colors = IsColor; SLtt_get_screen_size (); SLtt_reset_scroll_region (); fixup_colors (); return 0; } #endif /* WATCOM_VIDEO */ /*}}}*/ /* -------------------------------------------------------------------------*\ * The rest of the functions are, for the most part, independent of a specific * video system. \* ------------------------------------------------------------------------ */ /*----------------------------------------------------------------------*\ * Function: void SLtt_set_scroll_region (int r1, int r2); * * define a scroll region of top_row to bottom_row \*----------------------------------------------------------------------*/ void SLtt_set_scroll_region (int top_row, int bottom_row) { Scroll_r1 = top_row; Scroll_r2 = bottom_row; } /*----------------------------------------------------------------------*\ * Function: void SLtt_reset_scroll_region (void); * * reset the scrol region to be the entire screen, * ie, SLtt_set_scroll_region (0, SLtt_Screen_Rows); \*----------------------------------------------------------------------*/ void SLtt_reset_scroll_region (void) { Scroll_r1 = 0; Scroll_r2 = SLtt_Screen_Rows - 1; } /*----------------------------------------------------------------------*\ * Function: int SLtt_flush_output (void); \*----------------------------------------------------------------------*/ int SLtt_flush_output (void) { #if defined(WIN32_VIDEO) return 0; #else /* FIXME: Priority=medium * This should not go to stdout. */ fflush (stdout); return 0; #endif } int SLtt_set_cursor_visibility (int show) { #if defined(WIN32_VIDEO) CONSOLE_CURSOR_INFO c; if (0 == GetConsoleCursorInfo (hStdout, &c)) return -1; c.bVisible = (show ? TRUE: FALSE); if (0 == SetConsoleCursorInfo (hStdout, &c)) return -1; return 0; #else (void) show; return -1; #endif } void SLtt_set_mono (int obj_unused, char *unused, SLtt_Char_Type c_unused) { (void) obj_unused; (void) unused; (void) c_unused; } /*----------------------------------------------------------------------*\ * Function: void SLtt_reverse_video (int color); * * set Attribute_Byte corresponding to COLOR. * Use Current_Color to remember the color which was set. * convert from the COLOR number to the attribute value. \*----------------------------------------------------------------------*/ void SLtt_reverse_video (int color) { if ((color >= JMAX_COLORS) || (color < 0)) return; Attribute_Byte = Color_Map [color]; Current_Color = color; } /*----------------------------------------------------------------------*\ * Function: void SLtt_normal_video (void); * * reset the attributes for normal video \*----------------------------------------------------------------------*/ void SLtt_normal_video (void) { SLtt_reverse_video (JNORMAL_COLOR); } /*----------------------------------------------------------------------*\ * Function: void SLtt_smart_puts (SLsmg_Char_Type *new_string, * SLsmg_Char_Type *old_string, * int len, int row); * * puts NEW_STRING, which has length LEN, at row ROW. NEW_STRING contains * characters/colors packed in the form value = ((color << 8) | (ch)); * * the puts tries to avoid overwriting the same characters/colors * * OLD_STRING is not used, maintained for compatibility with other systems \*----------------------------------------------------------------------*/ void SLtt_smart_puts (SLsmg_Char_Type *new_string, SLsmg_Char_Type *old_string, int len, int row) { (void) old_string; Cursor_Row = row; Cursor_Col = 0; write_attributes (new_string, len); } /*----------------------------------------------------------------------*\ * Function: int SLtt_reset_video (void); \*----------------------------------------------------------------------*/ #ifndef WIN32_VIDEO int SLtt_reset_video (void) { SLtt_reset_scroll_region (); SLtt_goto_rc (SLtt_Screen_Rows - 1, 0); #ifdef HAS_SAVE_SCREEN restore_screen (); #endif Attribute_Byte = 0x07; Current_Color = JNO_COLOR; SLtt_del_eol (); return 0; } #endif /*----------------------------------------------------------------------*\ * Function: void SLtt_set_color (int obj, char *what, char *fg, char *bg); * * set foreground and background colors of OBJ to the attributes which * correspond to the names FG and BG, respectively. * * WHAT is the name corresponding to the object OBJ, but is not used in * this routine. \*----------------------------------------------------------------------*/ void SLtt_set_color (int obj, char *what, char *fg, char *bg) { int i, b = 0, f = 7; (void) what; if ((obj < 0) || (obj >= JMAX_COLORS)) return; for (i = 0; i < JMAX_COLOR_NAMES; i++ ) { if (!strcmp (fg, Color_Names [i])) { f = i; break; } } for (i = 0; i < JMAX_COLOR_NAMES; i++) { if (!strcmp (bg, Color_Names [i])) { if (Blink_Killed) b = i; else b = i & 0x7; break; } } if (f == b) return; Color_Map [obj] = (b << 4) | f; /* if we're setting the normal color, and the attribute byte hasn't been set yet, set it to the new color */ if ((obj == 0) && (Attribute_Byte == 0)) SLtt_reverse_video (0); if (_SLtt_color_changed_hook != NULL) (*_SLtt_color_changed_hook)(); } static void fixup_colors (void) { unsigned int i; if (Blink_Killed) return; for (i = 0; i < JMAX_COLORS; i++) Color_Map[i] &= 0x7F; SLtt_normal_video (); }