win32ss/user/winsrv/consrv/include/conio.h

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Console Server DLL
   4  * FILE:            consrv/include/conio.h
   5  * PURPOSE:         Public Console I/O Interface
   6  * PROGRAMMERS:     Gé van Geldorp
   7  *                  Jeffrey Morlan
   8  *                  Hermes Belusca-Maito (hermes.belusca@sfr.fr)
   9  */
  10
  11 #pragma once
  12
  13 #include "rect.h"
  14
  15 // This is ALMOST a HACK!!!!!!!
  16 // Helpers for code refactoring
  17 #ifdef USE_NEW_CONSOLE_WAY
  18
  19 #define _CONSRV_CONSOLE  _WINSRV_CONSOLE
  20 #define  CONSRV_CONSOLE   WINSRV_CONSOLE
  21 #define PCONSRV_CONSOLE  PWINSRV_CONSOLE
  22
  23 #else
  24
  25 #define _CONSRV_CONSOLE  _CONSOLE
  26 #define  CONSRV_CONSOLE   CONSOLE
  27 #define PCONSRV_CONSOLE  PCONSOLE
  28
  29 #endif
  30
  31 /* Default attributes */
  32 #define DEFAULT_SCREEN_ATTRIB   (FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED)
  33 #define DEFAULT_POPUP_ATTRIB    (FOREGROUND_BLUE | FOREGROUND_RED   | \
  34                                  BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_INTENSITY)
  35
  36
  37 /* Object type magic numbers */
  38 typedef enum _CONSOLE_IO_OBJECT_TYPE
  39 {
  40     UNKNOWN         = 0x00, // --> Unknown object
  41     TEXTMODE_BUFFER = 0x01, // --> Output-type object for text SBs
  42     GRAPHICS_BUFFER = 0x02, // --> Output-type object for graphics SBs
  43     SCREEN_BUFFER   = 0x03, // --> Any SB type
  44     INPUT_BUFFER    = 0x04, // --> Input-type object
  45     ANY_TYPE_BUFFER = 0x07, // --> Any IO object
  46 } CONSOLE_IO_OBJECT_TYPE;
  47
  48 typedef struct _CONSOLE_IO_OBJECT
  49 {
  50     CONSOLE_IO_OBJECT_TYPE Type;
  51
  52     struct _CONSOLE* /* PCONSOLE */ Console;
  53     LONG ReferenceCount;    /* Is incremented each time a console object gets referenced */
  54
  55     LONG AccessRead, AccessWrite;
  56     LONG ExclusiveRead, ExclusiveWrite;
  57 } CONSOLE_IO_OBJECT, *PCONSOLE_IO_OBJECT;
  58
  59
  60 /******************************************************************************\
  61 |*                                                                            *|
  62 |*     Abstract "class" for screen-buffers, be they text-mode or graphics     *|
  63 |*                                                                            *|
  64 \******************************************************************************/
  65
  66 /*
  67  * See conoutput.c for the implementation
  68  */
  69
  70 typedef struct _CONSOLE_SCREEN_BUFFER CONSOLE_SCREEN_BUFFER,
  71                                     *PCONSOLE_SCREEN_BUFFER;
  72
  73 typedef struct _CONSOLE_SCREEN_BUFFER_VTBL
  74 {
  75     CONSOLE_IO_OBJECT_TYPE (*GetType)(PCONSOLE_SCREEN_BUFFER This);
  76 } CONSOLE_SCREEN_BUFFER_VTBL, *PCONSOLE_SCREEN_BUFFER_VTBL;
  77
  78 #define GetType(This)   (This)->Vtbl->GetType(This)
  79
  80 struct _CONSOLE_SCREEN_BUFFER
  81 {
  82     CONSOLE_IO_OBJECT Header;           /* Object header - MUST BE IN FIRST PLACE */
  83     PCONSOLE_SCREEN_BUFFER_VTBL Vtbl;   /* Virtual table */
  84
  85     LIST_ENTRY ListEntry;               /* Entry in console's list of buffers */
  86
  87     COORD   ScreenBufferSize;           /* Size of this screen buffer. (Rows, Columns) for text-mode and (Width, Height) for graphics-mode */
  88     COORD   ViewSize;                   /* Associated "view" (i.e. console) size */
  89
  90     COORD   OldScreenBufferSize;        /* Old size of this screen buffer */
  91     COORD   OldViewSize;                /* Old associated view size */
  92
  93     COORD   ViewOrigin;                 /* Beginning offset for the actual display area */
  94
  95 /***** Put that VV in TEXTMODE_SCREEN_BUFFER ?? *****/
  96     USHORT  VirtualY;                   /* Top row of buffer being displayed, reported to callers */
  97
  98     COORD   CursorPosition;             /* Current cursor position */
  99     BOOLEAN CursorBlinkOn;
 100     BOOLEAN ForceCursorOff;
 101 //  ULONG   CursorSize;
 102     CONSOLE_CURSOR_INFO CursorInfo; // FIXME: Keep this member or not ??
 103 /*********************************************/
 104
 105     HPALETTE PaletteHandle;             /* Handle to the color palette associated to this buffer */
 106     UINT     PaletteUsage;              /* The new use of the system palette. See SetSystemPaletteUse 'uUsage' parameter */
 107
 108 //  WORD   ScreenDefaultAttrib;         /* Default screen char attribute */
 109 //  WORD   PopupDefaultAttrib;          /* Default popup char attribute */
 110     USHORT Mode;                        /* Output buffer modes */
 111 };
 112
 113
 114
 115 /******************************************************************************\
 116 |*                                                                            *|
 117 |*           Text-mode and graphics-mode screen-buffer "classes"              *|
 118 |*                                                                            *|
 119 \******************************************************************************/
 120
 121 /*
 122  * See text.c for the implementation
 123  */
 124
 125 /************************************************************************
 126  * Screen buffer structure represents the win32 screen buffer object.   *
 127  * Internally, the portion of the buffer being shown CAN loop past the  *
 128  * bottom of the virtual buffer and wrap around to the top.  Win32 does *
 129  * not do this.  I decided to do this because it eliminates the need to *
 130  * do a massive memcpy() to scroll the contents of the buffer up to     *
 131  * scroll the screen on output, instead I just shift down the position  *
 132  * to be displayed, and let it wrap around to the top again.            *
 133  * The VirtualY member keeps track of the top Y coord that win32        *
 134  * clients THINK is currently being displayed, because they think that  *
 135  * when the display reaches the bottom of the buffer and another line   *
 136  * being printed causes another line to scroll down, that the buffer IS *
 137  * memcpy()'s up, and the bottom of the buffer is still displayed, but  *
 138  * internally, I just wrap back to the top of the buffer.               *
 139  ************************************************************************/
 140
 141 typedef struct _TEXTMODE_BUFFER_INFO
 142 {
 143     COORD   ScreenBufferSize;
 144     USHORT  ScreenAttrib;
 145     USHORT  PopupAttrib;
 146     ULONG   CursorSize;
 147     BOOLEAN IsCursorVisible;
 148 } TEXTMODE_BUFFER_INFO, *PTEXTMODE_BUFFER_INFO;
 149
 150 typedef struct _TEXTMODE_SCREEN_BUFFER
 151 {
 152     CONSOLE_SCREEN_BUFFER;      /* Screen buffer base class - MUST BE IN FIRST PLACE */
 153
 154     PCHAR_INFO Buffer;          /* Pointer to UNICODE screen buffer (Buffer->Char.UnicodeChar only is valid, not Char.AsciiChar) */
 155
 156     WORD ScreenDefaultAttrib;   /* Default screen char attribute */
 157     WORD PopupDefaultAttrib;    /* Default popup char attribute */
 158 } TEXTMODE_SCREEN_BUFFER, *PTEXTMODE_SCREEN_BUFFER;
 159
 160
 161 /*
 162  * See graphics.c for the implementation
 163  */
 164
 165 typedef struct _GRAPHICS_BUFFER_INFO
 166 {
 167     CONSOLE_GRAPHICS_BUFFER_INFO Info;
 168 } GRAPHICS_BUFFER_INFO, *PGRAPHICS_BUFFER_INFO;
 169
 170 typedef struct _GRAPHICS_SCREEN_BUFFER
 171 {
 172     CONSOLE_SCREEN_BUFFER;          /* Screen buffer base class - MUST BE IN FIRST PLACE */
 173
 174     ULONG   BitMapInfoLength;       /* Real size of the structure pointed by BitMapInfo */
 175     LPBITMAPINFO BitMapInfo;        /* Information on the bitmap buffer */
 176     ULONG   BitMapUsage;            /* See the uUsage parameter of GetDIBits */
 177     HANDLE  hSection;               /* Handle to the memory shared section for the bitmap buffer */
 178     PVOID   BitMap;                 /* Our bitmap buffer */
 179
 180     PVOID   ClientBitMap;           /* A copy of the client view of our bitmap buffer */
 181     HANDLE  Mutex;                  /* Our mutex, used to synchronize read / writes to the bitmap buffer */
 182     HANDLE  ClientMutex;            /* A copy of the client handle to our mutex */
 183     HANDLE  ClientProcess;          /* Handle to the client process who opened the buffer, to unmap the view */
 184 } GRAPHICS_SCREEN_BUFFER, *PGRAPHICS_SCREEN_BUFFER;
 185
 186
 187
 188 typedef struct _CONSOLE_INPUT_BUFFER
 189 {
 190     CONSOLE_IO_OBJECT Header;       /* Object header - MUST BE IN FIRST PLACE */
 191
 192     ULONG       InputBufferSize;    /* Size of this input buffer -- UNUSED!! */
 193     LIST_ENTRY  InputEvents;        /* List head for input event queue */
 194     HANDLE      ActiveEvent;        /* Event set when an input event is added in its queue */
 195
 196     USHORT      Mode;               /* Input buffer modes */
 197 } CONSOLE_INPUT_BUFFER, *PCONSOLE_INPUT_BUFFER;
 198
 199
 200 typedef struct _TERMINAL TERMINAL, *PTERMINAL;
 201 /* HACK: */ typedef struct _CONSOLE_INFO *PCONSOLE_INFO;
 202 typedef struct _TERMINAL_VTBL
 203 {
 204     /*
 205      * Internal interface (functions called by the console server only)
 206      */
 207     NTSTATUS (NTAPI *InitTerminal)(IN OUT PTERMINAL This,
 208                                    IN struct _CONSOLE* Console);
 209     VOID (NTAPI *DeinitTerminal)(IN OUT PTERMINAL This);
 210
 211
 212
 213 /************ Line discipline ***************/
 214
 215     /* Interface used only for text-mode screen buffers */
 216
 217     NTSTATUS (NTAPI *ReadStream)(IN OUT PTERMINAL This,
 218                                  IN BOOLEAN Unicode,
 219                                  /**PWCHAR Buffer,**/
 220                                  OUT PVOID Buffer,
 221                                  IN OUT PCONSOLE_READCONSOLE_CONTROL ReadControl,
 222                                  IN PVOID Parameter OPTIONAL,
 223                                  IN ULONG NumCharsToRead,
 224                                  OUT PULONG NumCharsRead OPTIONAL);
 225     NTSTATUS (NTAPI *WriteStream)(IN OUT PTERMINAL This,
 226                                   PTEXTMODE_SCREEN_BUFFER Buff,
 227                                   PWCHAR Buffer,
 228                                   DWORD Length,
 229                                   BOOL Attrib);
 230
 231 /************ Line discipline ***************/
 232
 233
 234
 235     /* Interface used for both text-mode and graphics screen buffers */
 236     VOID (NTAPI *DrawRegion)(IN OUT PTERMINAL This,
 237                              SMALL_RECT* Region);
 238     BOOL (NTAPI *SetCursorInfo)(IN OUT PTERMINAL This,
 239                                 PCONSOLE_SCREEN_BUFFER ScreenBuffer);
 240     BOOL (NTAPI *SetScreenInfo)(IN OUT PTERMINAL This,
 241                                 PCONSOLE_SCREEN_BUFFER ScreenBuffer,
 242                                 SHORT OldCursorX,
 243                                 SHORT OldCursorY);
 244     VOID (NTAPI *ResizeTerminal)(IN OUT PTERMINAL This);
 245     VOID (NTAPI *SetActiveScreenBuffer)(IN OUT PTERMINAL This);
 246     VOID (NTAPI *ReleaseScreenBuffer)(IN OUT PTERMINAL This,
 247                                       IN PCONSOLE_SCREEN_BUFFER ScreenBuffer);
 248
 249     /*
 250      * External interface (functions corresponding to the Console API)
 251      */
 252     VOID (NTAPI *GetLargestConsoleWindowSize)(IN OUT PTERMINAL This,
 253                                               PCOORD pSize);
 254     BOOL (NTAPI *SetPalette)(IN OUT PTERMINAL This,
 255                              HPALETTE PaletteHandle,
 256                              UINT PaletteUsage);
 257     INT   (NTAPI *ShowMouseCursor)(IN OUT PTERMINAL This,
 258                                    BOOL Show);
 259
 260 #if 0 // Possible future terminal interface
 261     BOOL (NTAPI *GetTerminalProperty)(IN OUT PTERMINAL This,
 262                                       ULONG Flag,
 263                                       PVOID Info,
 264                                       ULONG Size);
 265     BOOL (NTAPI *SetTerminalProperty)(IN OUT PTERMINAL This,
 266                                       ULONG Flag,
 267                                       PVOID Info /*,
 268                                       ULONG Size */);
 269 #endif
 270 } TERMINAL_VTBL, *PTERMINAL_VTBL;
 271
 272 struct _TERMINAL
 273 {
 274     PTERMINAL_VTBL Vtbl;        /* Virtual table */
 275     struct _CONSOLE* Console;   /* Console to which the terminal is attached to */
 276     PVOID Context;              /* Private context */
 277 };
 278
 279 /*
 280  * WARNING: Change the state of the console ONLY when the console is locked !
 281  */
 282 typedef enum _CONSOLE_STATE
 283 {
 284     CONSOLE_INITIALIZING,   /* Console is initializing */
 285     CONSOLE_RUNNING     ,   /* Console running */
 286     CONSOLE_TERMINATING ,   /* Console about to be destroyed (but still not) */
 287     CONSOLE_IN_DESTRUCTION  /* Console in destruction */
 288 } CONSOLE_STATE, *PCONSOLE_STATE;
 289
 290 // HACK!!
 291 struct _CONSOLE;
 292 /* HACK: */ typedef struct _CONSOLE *PCONSOLE;
 293 #ifndef USE_NEW_CONSOLE_WAY
 294 #include "conio_winsrv.h"
 295 #endif
 296
 297 typedef struct _CONSOLE
 298 {
 299 /******************************* Console Set-up *******************************/
 300
 301 #ifndef USE_NEW_CONSOLE_WAY
 302     WINSRV_CONSOLE; // HACK HACK!!
 303 #endif
 304
 305     LONG ReferenceCount;                    /* Is incremented each time a handle to something in the console (a screen-buffer or the input buffer of this console) gets referenced */
 306     CRITICAL_SECTION Lock;
 307
 308     ULONG ConsoleID;                        /* The ID of the console */
 309     LIST_ENTRY ListEntry;                   /* Entry in the list of consoles */
 310
 311     CONSOLE_STATE State;                    /* State of the console */
 312     TERMINAL TermIFace;                     /* Terminal-specific interface */
 313
 314     HANDLE UnpauseEvent;                    /* When != NULL, event for pausing the console */
 315
 316 /******************************** Input buffer ********************************/
 317     CONSOLE_INPUT_BUFFER InputBuffer;       /* Input buffer of the console */
 318     UINT InputCodePage;
 319
 320 /******************************* Screen buffers *******************************/
 321     LIST_ENTRY BufferList;                  /* List of all screen buffers for this console */
 322     PCONSOLE_SCREEN_BUFFER ActiveBuffer;    /* Pointer to currently active screen buffer */
 323     UINT OutputCodePage;
 324
 325 /****************************** Other properties ******************************/
 326     COORD   ConsoleSize;                    /* The current size of the console, for text-mode only */
 327     BOOLEAN FixedSize;                      /* TRUE if the console is of fixed size */
 328
 329 } CONSOLE; // , *PCONSOLE;
 330
 331 /* console.c */
 332 VOID NTAPI
 333 ConDrvPause(PCONSOLE Console);
 334 VOID NTAPI
 335 ConDrvUnpause(PCONSOLE Console);
 336
 337 NTSTATUS
 338 ConSrvConsoleCtrlEvent(IN ULONG CtrlEvent,
 339                        IN PCONSOLE_PROCESS_DATA ProcessData);
 340
 341
 342 #define GetConsoleInputBufferMode(Console)  \
 343     (Console)->InputBuffer.Mode
 344
 345
 346 /* conoutput.c */
 347 PCHAR_INFO ConioCoordToPointer(PTEXTMODE_SCREEN_BUFFER Buff, ULONG X, ULONG Y);
 348 NTSTATUS ConioResizeBuffer(PCONSOLE /*PCONSRV_CONSOLE*/ Console,
 349                            PTEXTMODE_SCREEN_BUFFER ScreenBuffer,
 350                            COORD Size);
 351
 352 /* EOF */