reactos/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
 202 /*
 203  * Structure used to hold console information
 204  */
 205 typedef struct _CONSOLE_INFO
 206 {
 207     ULONG   InputBufferSize;
 208     COORD   ScreenBufferSize;
 209     COORD   ConsoleSize;    /* The size of the console */
 210
 211     ULONG   CursorSize;
 212     BOOLEAN CursorBlinkOn;
 213     BOOLEAN ForceCursorOff;
 214
 215     USHORT  ScreenAttrib; // CHAR_INFO ScreenFillAttrib
 216     USHORT  PopupAttrib;
 217
 218     ULONG   CodePage;
 219
 220 } CONSOLE_INFO, *PCONSOLE_INFO;
 221
 222 typedef struct _TERMINAL_VTBL
 223 {
 224     /*
 225      * Internal interface (functions called by the console server only)
 226      */
 227     NTSTATUS (NTAPI *InitTerminal)(IN OUT PTERMINAL This,
 228                                    IN struct _CONSOLE* Console);
 229     VOID (NTAPI *DeinitTerminal)(IN OUT PTERMINAL This);
 230
 231
 232
 233 /************ Line discipline ***************/
 234
 235     /* Interface used only for text-mode screen buffers */
 236
 237     NTSTATUS (NTAPI *ReadStream)(IN OUT PTERMINAL This,
 238                                  IN BOOLEAN Unicode,
 239                                  /**PWCHAR Buffer,**/
 240                                  OUT PVOID Buffer,
 241                                  IN OUT PCONSOLE_READCONSOLE_CONTROL ReadControl,
 242                                  IN PVOID Parameter OPTIONAL,
 243                                  IN ULONG NumCharsToRead,
 244                                  OUT PULONG NumCharsRead OPTIONAL);
 245     NTSTATUS (NTAPI *WriteStream)(IN OUT PTERMINAL This,
 246                                   PTEXTMODE_SCREEN_BUFFER Buff,
 247                                   PWCHAR Buffer,
 248                                   DWORD Length,
 249                                   BOOL Attrib);
 250
 251 /************ Line discipline ***************/
 252
 253
 254
 255     /* Interface used for both text-mode and graphics screen buffers */
 256     VOID (NTAPI *DrawRegion)(IN OUT PTERMINAL This,
 257                              SMALL_RECT* Region);
 258     BOOL (NTAPI *SetCursorInfo)(IN OUT PTERMINAL This,
 259                                 PCONSOLE_SCREEN_BUFFER ScreenBuffer);
 260     BOOL (NTAPI *SetScreenInfo)(IN OUT PTERMINAL This,
 261                                 PCONSOLE_SCREEN_BUFFER ScreenBuffer,
 262                                 SHORT OldCursorX,
 263                                 SHORT OldCursorY);
 264     VOID (NTAPI *ResizeTerminal)(IN OUT PTERMINAL This);
 265     VOID (NTAPI *SetActiveScreenBuffer)(IN OUT PTERMINAL This);
 266     VOID (NTAPI *ReleaseScreenBuffer)(IN OUT PTERMINAL This,
 267                                       IN PCONSOLE_SCREEN_BUFFER ScreenBuffer);
 268
 269     /*
 270      * External interface (functions corresponding to the Console API)
 271      */
 272     VOID (NTAPI *GetLargestConsoleWindowSize)(IN OUT PTERMINAL This,
 273                                               PCOORD pSize);
 274     BOOL (NTAPI *SetPalette)(IN OUT PTERMINAL This,
 275                              HPALETTE PaletteHandle,
 276                              UINT PaletteUsage);
 277     INT   (NTAPI *ShowMouseCursor)(IN OUT PTERMINAL This,
 278                                    BOOL Show);
 279
 280 #if 0 // Possible future terminal interface
 281     BOOL (NTAPI *GetTerminalProperty)(IN OUT PTERMINAL This,
 282                                       ULONG Flag,
 283                                       PVOID Info,
 284                                       ULONG Size);
 285     BOOL (NTAPI *SetTerminalProperty)(IN OUT PTERMINAL This,
 286                                       ULONG Flag,
 287                                       PVOID Info /*,
 288                                       ULONG Size */);
 289 #endif
 290 } TERMINAL_VTBL, *PTERMINAL_VTBL;
 291
 292 struct _TERMINAL
 293 {
 294     PTERMINAL_VTBL Vtbl;        /* Virtual table */
 295     struct _CONSOLE* Console;   /* Console to which the terminal is attached to */
 296     PVOID Context;              /* Private context */
 297 };
 298
 299 /*
 300  * WARNING: Change the state of the console ONLY when the console is locked !
 301  */
 302 typedef enum _CONSOLE_STATE
 303 {
 304     CONSOLE_INITIALIZING,   /* Console is initializing */
 305     CONSOLE_RUNNING     ,   /* Console running */
 306     CONSOLE_TERMINATING ,   /* Console about to be destroyed (but still not) */
 307     CONSOLE_IN_DESTRUCTION  /* Console in destruction */
 308 } CONSOLE_STATE, *PCONSOLE_STATE;
 309
 310 // HACK!!
 311 struct _CONSOLE;
 312 /* HACK: */ typedef struct _CONSOLE *PCONSOLE;
 313 #ifndef USE_NEW_CONSOLE_WAY
 314 #include "conio_winsrv.h"
 315 #endif
 316
 317 typedef struct _CONSOLE
 318 {
 319 /******************************* Console Set-up *******************************/
 320
 321 #ifndef USE_NEW_CONSOLE_WAY
 322     WINSRV_CONSOLE; // HACK HACK!!
 323 #endif
 324
 325     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 */
 326     CRITICAL_SECTION Lock;
 327
 328     ULONG ConsoleID;                        /* The ID of the console */
 329     LIST_ENTRY ListEntry;                   /* Entry in the list of consoles */
 330
 331     CONSOLE_STATE State;                    /* State of the console */
 332     TERMINAL TermIFace;                     /* Terminal-specific interface */
 333
 334     HANDLE UnpauseEvent;                    /* When != NULL, event for pausing the console */
 335
 336 /******************************** Input buffer ********************************/
 337     CONSOLE_INPUT_BUFFER InputBuffer;       /* Input buffer of the console */
 338     UINT InputCodePage;
 339
 340 /******************************* Screen buffers *******************************/
 341     LIST_ENTRY BufferList;                  /* List of all screen buffers for this console */
 342     PCONSOLE_SCREEN_BUFFER ActiveBuffer;    /* Pointer to currently active screen buffer */
 343     UINT OutputCodePage;
 344
 345 /****************************** Other properties ******************************/
 346     COORD   ConsoleSize;                    /* The current size of the console, for text-mode only */
 347     BOOLEAN FixedSize;                      /* TRUE if the console is of fixed size */
 348
 349 } CONSOLE; // , *PCONSOLE;
 350
 351 /* console.c */
 352 VOID NTAPI
 353 ConDrvPause(PCONSOLE Console);
 354 VOID NTAPI
 355 ConDrvUnpause(PCONSOLE Console);
 356
 357 NTSTATUS
 358 ConSrvConsoleCtrlEvent(IN ULONG CtrlEvent,
 359                        IN PCONSOLE_PROCESS_DATA ProcessData);
 360
 361
 362 #define GetConsoleInputBufferMode(Console)  \
 363     (Console)->InputBuffer.Mode
 364
 365
 366 /* conoutput.c */
 367 PCHAR_INFO ConioCoordToPointer(PTEXTMODE_SCREEN_BUFFER Buff, ULONG X, ULONG Y);
 368 NTSTATUS ConioResizeBuffer(PCONSOLE /*PCONSRV_CONSOLE*/ Console,
 369                            PTEXTMODE_SCREEN_BUFFER ScreenBuffer,
 370                            COORD Size);
 371
 372 /* EOF */