console/interface.c

   1 /* interface.c */
   2
   3 /* The primary purpose of this function is to provide CONSOLE_*
   4    reotines that immediately call the appropiate driver handler.
   5    This cleans up code in the individual modules considerably.
   6    This could be done using a macro, but additional functionality
   7    may be provided here in the future. */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13 #include "windows.h"
  14 #include "console.h"
  15 #include "config.h"
  16
  17 static int pop_driver(char **, char **, int *);
  18
  19 void CONSOLE_Write(char out, int fg_color, int bg_color, int attribute)
  20 {
  21    if (driver.write)
  22    {
  23       driver.write(out, fg_color, bg_color, attribute);
  24       if (!driver.norefresh)
  25          CONSOLE_Refresh();
  26    }
  27 }
  28
  29 void CONSOLE_Init(char *drivers)
  30 {
  31       /* When this function is called drivers should be a string
  32          that consists of driver names followed by plus (+) signs
  33          to denote additions.
  34
  35          For example:
  36             drivers = tty                Load just the tty driver
  37             drivers = ncurses+xterm      Load ncurses then xterm
  38
  39          The "default" value is just tty.
  40       */
  41
  42       char *single;
  43       int length;
  44
  45       /* Suitable defaults... */
  46       driver.console_out = stdout;
  47       driver.console_in = stdin;
  48
  49       while (pop_driver(&drivers, &single, &length))
  50       {
  51          if (!strncmp(single, "tty", length))
  52             TTY_Start();
  53 #ifdef WINE_NCURSES
  54          else if (!strncmp(single, "ncurses", length))
  55             NCURSES_Start();
  56 #endif /* WINE_NCURSES */
  57          else if (!strncmp(single, "xterm", length))
  58             XTERM_Start();
  59       }
  60
  61    GENERIC_Start();
  62
  63    if (driver.init)
  64       driver.init();
  65 }
  66
  67 void CONSOLE_Close()
  68 {
  69    if (driver.close)
  70       driver.close();
  71 }
  72
  73 void CONSOLE_MoveCursor(char row, char col)
  74 {
  75    if (driver.moveCursor)
  76    {
  77       driver.moveCursor(row, col);
  78       if (!driver.norefresh)
  79          CONSOLE_Refresh();
  80    }
  81 }
  82
  83 void CONSOLE_ClearWindow(char row1, char col1, char row2, char col2,
  84    int bg_color, int attribute)
  85 {
  86    if (driver.clearWindow)
  87    {
  88       driver.clearWindow(row1, col1, row2, col2, bg_color, attribute);
  89       if (!driver.norefresh)
  90          CONSOLE_Refresh();
  91    }
  92 }
  93
  94 void CONSOLE_ScrollUpWindow(char row1, char col1, char row2, char col2,
  95    char lines, int bg_color, int attribute)
  96 {
  97    if (driver.scrollUpWindow)
  98    {
  99       driver.scrollUpWindow(row1, col1, row2, col2, lines, bg_color,
 100          attribute);
 101       if (!driver.norefresh)
 102          CONSOLE_Refresh();
 103    }
 104 }
 105
 106 void CONSOLE_ScrollDownWindow(char row1, char col1, char row2, char col2,
 107    char lines, int bg_color, int attribute)
 108 {
 109    if (driver.scrollDownWindow)
 110    {
 111       driver.scrollDownWindow(row1, col1, row2, col2, lines, bg_color,
 112          attribute);
 113       if (!driver.norefresh)
 114          CONSOLE_Refresh();
 115    }
 116 }
 117
 118 int CONSOLE_CheckForKeystroke(char *scan, char *ascii)
 119 /* These functions need to go through a conversion layer. Scancodes
 120    should *not* be determined by the driver, rather they should have
 121    a conv_* function in int16.c. Yuck. */
 122 {
 123    if (driver.checkForKeystroke)
 124       return driver.checkForKeystroke(scan, ascii);
 125    else
 126       return FALSE;
 127 }
 128
 129 void CONSOLE_GetKeystroke(char *scan, char *ascii)
 130 {
 131    if (driver.getKeystroke)
 132       driver.getKeystroke(scan, ascii);
 133 }
 134
 135 void CONSOLE_GetCursorPosition(char *row, char *col)
 136 {
 137    if (driver.getCursorPosition)
 138       driver.getCursorPosition(row, col);
 139 }
 140
 141 void CONSOLE_GetCharacterAtCursor(char *ch, int *fg, int *bg, int *a)
 142 {
 143    if (driver.getCharacterAtCursor)
 144       driver.getCharacterAtCursor(ch, fg, bg, a);
 145 }
 146
 147 void CONSOLE_Refresh()
 148 {
 149    if (driver.refresh)
 150       driver.refresh();
 151 }
 152
 153 int CONSOLE_AllocColor(int color)
 154 {
 155    if (driver.allocColor)
 156       return driver.allocColor(color);
 157    else
 158       return 0;
 159 }
 160
 161 /* This function is only at the CONSOLE level. */
 162 /* Admittably, calling the variable norefresh might be a bit dumb...*/
 163 void CONSOLE_SetRefresh(int setting)
 164 {
 165    if (setting)
 166       driver.norefresh = FALSE;
 167    else
 168       driver.norefresh = TRUE;
 169 }
 170
 171 /* This function is only at the CONSOLE level. */
 172 int CONSOLE_GetRefresh()
 173 {
 174    if (driver.norefresh)
 175       return FALSE;
 176    else
 177       return TRUE;
 178 }
 179
 180 void CONSOLE_ClearScreen()
 181 {
 182    if (driver.clearScreen)
 183    {
 184       driver.clearScreen();
 185       if (!driver.norefresh)
 186          CONSOLE_Refresh();
 187    }
 188 }
 189
 190 char CONSOLE_GetCharacter()
 191 {
 192    /* I'm not sure if we need this really. This is a function that can be
 193       accelerated that returns the next *non extended* keystroke */
 194    if (driver.getCharacter)
 195       return driver.getCharacter();
 196    else
 197       return (char) 0; /* Sure, this will probably break programs... */
 198 }
 199
 200 void CONSOLE_ResizeScreen(int x, int y)
 201 {
 202    if (driver.resizeScreen)
 203       driver.resizeScreen(x, y);
 204 }
 205
 206 void CONSOLE_NotifyResizeScreen(int x, int y)
 207 {
 208    if (driver.notifyResizeScreen)
 209       driver.notifyResizeScreen(x, y);
 210 }
 211
 212 void CONSOLE_SetBackgroundColor(int fg, int bg)
 213 {
 214    if (driver.setBackgroundColor)
 215       driver.setBackgroundColor(fg, bg);
 216 }
 217
 218 void CONSOLE_WriteRawString(char *str)
 219 {
 220    /* This is a special function that is only for internal use and
 221       does not actually call any of the console drivers. It's
 222       primary purpose is to provide a way for higher-level drivers
 223       to write directly to the underlying terminal without worry that
 224       there will be any retranslation done by the assorted drivers. Care
 225       should be taken to ensure that this only gets called when the thing
 226       written does not actually produce any output or a CONSOLE_Redraw()
 227       is called immediately afterwards.
 228       CONSOLE_Redraw() is not yet implemented.
 229    */
 230    fprintf(driver.console_out, "%s", str);
 231 }
 232
 233 /* Utility functions... */
 234
 235 int pop_driver(char **drivers, char **single, int *length)
 236 {
 237    /* Take the string in drivers and extract the first "driver" entry */
 238    /* Advance the pointer in drivers to the next entry, put the origional
 239       pointer in single, and put the length in length. */
 240    /* Return TRUE if we found one */
 241
 242    if (!*drivers)
 243       return FALSE;
 244
 245    *single = *drivers;
 246    *length = 0;
 247
 248    while ((*drivers[0] != NULL) && (*drivers[0] != '+'))
 249    {
 250       (*drivers)++;
 251       (*length)++;
 252    }
 253
 254    while (*drivers[0] == '+')
 255       (*drivers)++;
 256
 257    if (*length)
 258       return TRUE;
 259    else
 260       return FALSE;
 261
 262 }