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 "config.h"
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14
  15 #include "windef.h"
  16 #include "console.h"
  17 #include "options.h"
  18
  19 CONSOLE_device driver;
  20
  21 static int pop_driver(char **, char **, int *);
  22
  23 static int console_initialized = FALSE;
  24
  25 static int CONSOLE_Init(void)
  26 {
  27       char buffer[256];
  28       char *single, *drivers = buffer;
  29       int length;
  30       char initial_rows[5];
  31       char initial_columns[5];
  32
  33       /* Suitable defaults... */
  34       driver.console_out = stdout;
  35       driver.console_in = stdin;
  36
  37       /* drivers should be a string that consists of driver names
  38          followed by plus (+) signs to denote additions.
  39
  40          For example:
  41             drivers = tty                Load just the tty driver
  42             drivers = ncurses+xterm      Load ncurses then xterm
  43
  44          The "default" value is just tty.
  45       */
  46       PROFILE_GetWineIniString( "console", "Drivers", CONSOLE_DEFAULT_DRIVER,
  47                                 buffer, sizeof(buffer) );
  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    /* Read in generic configuration */
  62    /* This is primarily to work around a limitation in nxterm where
  63       this information is not correctly passed to the ncurses layer
  64       through the terminal. At least, I'm not doing it correctly if there
  65       is a way. But this serves as a generic way to do the same anyway. */
  66
  67    /* We are setting this to 80x25 here which is *not* the default for
  68       most xterm variants... It is however the standard VGA resolution */
  69
  70    /* FIXME: We need to be able to be able to specify that the window's
  71       dimensions should be used. This is required for correct emulation
  72       of Win32's console and Win32's DOS emulation */
  73
  74    PROFILE_GetWineIniString("console", "InitialRows",
  75       "24", initial_rows, 5);
  76    PROFILE_GetWineIniString("console", "InitialColumns",
  77       "80", initial_columns, 5);
  78
  79    sscanf(initial_rows, "%d", &driver.y_res);
  80    sscanf(initial_columns, "%d", &driver.x_res);
  81
  82    GENERIC_Start();
  83
  84    if (driver.init)
  85       driver.init();
  86
  87    /* Not all terminals let our programs know the proper resolution
  88       if the resolution is set on the command-line... */
  89    CONSOLE_NotifyResizeScreen(driver.x_res, driver.y_res);
  90
  91    atexit(CONSOLE_Close);
  92
  93    /* For now, always return TRUE */
  94    return TRUE;
  95 }
  96
  97 void CONSOLE_Write(char out, int fg_color, int bg_color, int attribute)
  98 {
  99    if (!console_initialized)
 100       console_initialized = CONSOLE_Init();
 101
 102    if (driver.write)
 103    {
 104       driver.write(out, fg_color, bg_color, attribute);
 105       if (!driver.norefresh)
 106          CONSOLE_Refresh();
 107    }
 108 }
 109
 110 void CONSOLE_Close(void)
 111 {
 112    if (driver.close)
 113       driver.close();
 114 }
 115
 116 void CONSOLE_MoveCursor(char row, char col)
 117 {
 118    if (!console_initialized)
 119       console_initialized = CONSOLE_Init();
 120
 121    if (driver.moveCursor)
 122    {
 123       driver.moveCursor(row, col);
 124       if (!driver.norefresh)
 125          CONSOLE_Refresh();
 126    }
 127 }
 128
 129 void CONSOLE_ClearWindow(char row1, char col1, char row2, char col2,
 130    int bg_color, int attribute)
 131 {
 132    if (!console_initialized)
 133       console_initialized = CONSOLE_Init();
 134
 135    if (driver.clearWindow)
 136    {
 137       driver.clearWindow(row1, col1, row2, col2, bg_color, attribute);
 138       if (!driver.norefresh)
 139          CONSOLE_Refresh();
 140    }
 141 }
 142
 143 void CONSOLE_ScrollUpWindow(char row1, char col1, char row2, char col2,
 144    char lines, int bg_color, int attribute)
 145 {
 146    if (!console_initialized)
 147       console_initialized = CONSOLE_Init();
 148
 149    if (driver.scrollUpWindow)
 150    {
 151       driver.scrollUpWindow(row1, col1, row2, col2, lines, bg_color,
 152          attribute);
 153       if (!driver.norefresh)
 154          CONSOLE_Refresh();
 155    }
 156 }
 157
 158 void CONSOLE_ScrollDownWindow(char row1, char col1, char row2, char col2,
 159    char lines, int bg_color, int attribute)
 160 {
 161    if (!console_initialized)
 162       console_initialized = CONSOLE_Init();
 163
 164    if (driver.scrollDownWindow)
 165    {
 166       driver.scrollDownWindow(row1, col1, row2, col2, lines, bg_color,
 167          attribute);
 168       if (!driver.norefresh)
 169          CONSOLE_Refresh();
 170    }
 171 }
 172
 173 int CONSOLE_CheckForKeystroke(char *scan, char *ascii)
 174 /* These functions need to go through a conversion layer. Scancodes
 175    should *not* be determined by the driver, rather they should have
 176    a conv_* function in int16.c. Yuck. */
 177 {
 178    if (!console_initialized)
 179       console_initialized = CONSOLE_Init();
 180
 181    if (driver.checkForKeystroke)
 182       return driver.checkForKeystroke(scan, ascii);
 183    else
 184       return FALSE;
 185 }
 186
 187 void CONSOLE_GetKeystroke(char *scan, char *ascii)
 188 {
 189    if (!console_initialized)
 190       console_initialized = CONSOLE_Init();
 191
 192    if (driver.getKeystroke)
 193       driver.getKeystroke(scan, ascii);
 194 }
 195
 196 void CONSOLE_GetCursorPosition(char *row, char *col)
 197 {
 198    if (!console_initialized)
 199       console_initialized = CONSOLE_Init();
 200
 201    if (driver.getCursorPosition)
 202       driver.getCursorPosition(row, col);
 203 }
 204
 205 void CONSOLE_GetCharacterAtCursor(char *ch, int *fg, int *bg, int *a)
 206 {
 207    if (!console_initialized)
 208       console_initialized = CONSOLE_Init();
 209
 210    if (driver.getCharacterAtCursor)
 211       driver.getCharacterAtCursor(ch, fg, bg, a);
 212 }
 213
 214 void CONSOLE_Refresh()
 215 {
 216    if (!console_initialized)
 217       console_initialized = CONSOLE_Init();
 218
 219    if (driver.refresh)
 220       driver.refresh();
 221 }
 222
 223 int CONSOLE_AllocColor(int color)
 224 {
 225    if (!console_initialized)
 226       console_initialized = CONSOLE_Init();
 227
 228    if (driver.allocColor)
 229       return driver.allocColor(color);
 230    else
 231       return 0;
 232 }
 233
 234 void CONSOLE_ClearScreen()
 235 {
 236    if (!console_initialized)
 237       console_initialized = CONSOLE_Init();
 238
 239    if (driver.clearScreen)
 240    {
 241       driver.clearScreen();
 242       if (!driver.norefresh)
 243          CONSOLE_Refresh();
 244    }
 245 }
 246
 247 char CONSOLE_GetCharacter()
 248 {
 249    if (!console_initialized)
 250       console_initialized = CONSOLE_Init();
 251
 252    /* I'm not sure if we need this really. This is a function that can be
 253       accelerated that returns the next *non extended* keystroke */
 254    if (driver.getCharacter)
 255       return driver.getCharacter();
 256    else
 257       return (char) 0; /* Sure, this will probably break programs... */
 258 }
 259
 260 void CONSOLE_ResizeScreen(int x, int y)
 261 {
 262    if (!console_initialized)
 263       console_initialized = CONSOLE_Init();
 264
 265    if (driver.resizeScreen)
 266       driver.resizeScreen(x, y);
 267 }
 268
 269 void CONSOLE_NotifyResizeScreen(int x, int y)
 270 {
 271    if (driver.notifyResizeScreen)
 272       driver.notifyResizeScreen(x, y);
 273 }
 274
 275 void CONSOLE_SetBackgroundColor(int fg, int bg)
 276 {
 277    if (!console_initialized)
 278       console_initialized = CONSOLE_Init();
 279
 280    if (driver.setBackgroundColor)
 281       driver.setBackgroundColor(fg, bg);
 282 }
 283
 284 void CONSOLE_GetBackgroundColor(int *fg, int *bg)
 285 {
 286    if (!console_initialized)
 287       console_initialized = CONSOLE_Init();
 288
 289    if (driver.getBackgroundColor)
 290       driver.getBackgroundColor(fg, bg);
 291 }
 292
 293 void CONSOLE_WriteRawString(char *str)
 294 {
 295    if (!console_initialized)
 296       console_initialized = CONSOLE_Init();
 297
 298    /* This is a special function that is only for internal use and
 299       does not actually call any of the console drivers. It's
 300       primary purpose is to provide a way for higher-level drivers
 301       to write directly to the underlying terminal without worry that
 302       there will be any retranslation done by the assorted drivers. Care
 303       should be taken to ensure that this only gets called when the thing
 304       written does not actually produce any output or a CONSOLE_Redraw()
 305       is called immediately afterwards.
 306       CONSOLE_Redraw() is not yet implemented.
 307    */
 308    fprintf(driver.console_out, "%s", str);
 309 }
 310
 311 /* This function is only at the CONSOLE level. */
 312 /* Admittably, calling the variable norefresh might be a bit dumb...*/
 313 void CONSOLE_SetRefresh(int setting)
 314 {
 315    if (setting)
 316       driver.norefresh = FALSE;
 317    else
 318       driver.norefresh = TRUE;
 319 }
 320
 321 /* This function is only at the CONSOLE level. */
 322 int CONSOLE_GetRefresh()
 323 {
 324    if (driver.norefresh)
 325       return FALSE;
 326    else
 327       return TRUE;
 328 }
 329
 330
 331 /* Utility functions... */
 332
 333 int pop_driver(char **drivers, char **single, int *length)
 334 {
 335    /* Take the string in drivers and extract the first "driver" entry */
 336    /* Advance the pointer in drivers to the next entry, put the origional
 337       pointer in single, and put the length in length. */
 338    /* Return TRUE if we found one */
 339
 340    if (!*drivers)
 341       return FALSE;
 342
 343    *single = *drivers;
 344    *length = 0;
 345
 346    while ((*drivers[0] != '\0') && (*drivers[0] != '+'))
 347    {
 348       (*drivers)++;
 349       (*length)++;
 350    }
 351
 352    while (*drivers[0] == '+')
 353       (*drivers)++;
 354
 355    if (*length)
 356       return TRUE;
 357    else
 358       return FALSE;
 359
 360 }