win32/console.c

   1 /*
   2  * Win32 kernel functions
   3  *
   4  * Copyright 1995 Martin von Loewis and Cameron Heide
   5  * Copyright 1997 Karl Garrison
   6  */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include "windows.h"
  11 #include "winerror.h"
  12 #include "wincon.h"
  13 #include "heap.h"
  14 #include "stddebug.h"
  15 #include "debug.h"
  16
  17 static CONSOLE_SCREEN_BUFFER_INFO dummyinfo =
  18 {
  19     {80, 24},
  20     {0, 0},
  21     0,
  22     {0, 0, 79, 23},
  23     {80, 24}
  24 };
  25
  26 /***********************************************************************
  27  *           SetConsoleCtrlHandler               (KERNEL32.459)
  28  */
  29 BOOL32 WINAPI SetConsoleCtrlHandler(HANDLER_ROUTINE * func,  BOOL32 a)
  30 {
  31         return 0;
  32 }
  33
  34 /***********************************************************************
  35  *           CreateConsoleScreenBuffer   (KERNEL32.151)
  36  */
  37 HANDLE32 WINAPI CreateConsoleScreenBuffer( DWORD dwDesiredAccess,
  38                                            DWORD dwShareMode,
  39                                            LPSECURITY_ATTRIBUTES lpSecurityAttributes,
  40                                            DWORD dwFlags,
  41                                            LPVOID lpScreenBufferData)
  42 {
  43         fprintf(stderr, "CreateConsoleScreenBuffer(): stub !\n");
  44         return INVALID_HANDLE_VALUE32;
  45 }
  46
  47 /***********************************************************************
  48  *           GetConsoleScreenBufferInfo   (KERNEL32.190)
  49  */
  50 BOOL32 WINAPI GetConsoleScreenBufferInfo( HANDLE32 hConsoleOutput,
  51                                           LPCONSOLE_SCREEN_BUFFER_INFO csbi )
  52 {
  53     csbi->dwSize.x = 80;
  54     csbi->dwSize.y = 24;
  55     csbi->dwCursorPosition.x = 0;
  56     csbi->dwCursorPosition.y = 0;
  57     csbi->wAttributes = 0;
  58     csbi->srWindow.Left = 0;
  59     csbi->srWindow.Right        = 79;
  60     csbi->srWindow.Top  = 0;
  61     csbi->srWindow.Bottom       = 23;
  62     csbi->dwMaximumWindowSize.x = 80;
  63     csbi->dwMaximumWindowSize.y = 24;
  64     return TRUE;
  65 }
  66
  67 /***********************************************************************
  68  *           SetConsoleActiveScreenBuffer   (KERNEL32.623)
  69  */
  70 BOOL32 WINAPI SetConsoleActiveScreenBuffer(HANDLE32 hConsoleOutput)
  71 {
  72         fprintf(stderr, "SetConsoleActiveScreenBuffer(): stub !\n");
  73         return 0;
  74 }
  75
  76 /***********************************************************************
  77  *            GetLargestConsoleWindowSize   (KERNEL32.226)
  78  */
  79 DWORD WINAPI GetLargestConsoleWindowSize( HANDLE32 hConsoleOutput )
  80 {
  81     return (DWORD)MAKELONG(dummyinfo.dwMaximumWindowSize.x,dummyinfo.dwMaximumWindowSize.y);
  82 }
  83
  84 /***********************************************************************
  85  *            GetConsoleCP   (KERNEL32.226)
  86  */
  87 UINT32 WINAPI GetConsoleCP(VOID)
  88 {
  89     return GetACP();
  90 }
  91
  92 /***********************************************************************
  93  *            GetConsoleOutputCP   (KERNEL32.189)
  94  */
  95 UINT32 WINAPI GetConsoleOutputCP(VOID)
  96 {
  97     return GetConsoleCP();
  98 }
  99
 100 /***********************************************************************
 101  *            GetConsoleMode   (KERNEL32.188)
 102  */
 103 BOOL32 WINAPI GetConsoleMode(HANDLE32 hcon,LPDWORD mode)
 104 {
 105         *mode =         ENABLE_PROCESSED_INPUT  |
 106                         ENABLE_LINE_INPUT       |
 107                         ENABLE_ECHO_INPUT;
 108         return TRUE;
 109 }
 110
 111 /***********************************************************************
 112  *            SetConsoleMode   (KERNEL32.188)
 113  */
 114 BOOL32 WINAPI SetConsoleMode(HANDLE32 hcon,DWORD mode)
 115 {
 116     fprintf(stdnimp,"SetConsoleMode(%08x,%08lx)\n",hcon,mode);
 117     return TRUE;
 118 }
 119
 120 /***********************************************************************
 121  *            GetConsoleTitleA   (KERNEL32.191)
 122  */
 123 DWORD WINAPI GetConsoleTitle32A(LPSTR title,DWORD size)
 124 {
 125     lstrcpyn32A(title,"Console",size);
 126     return strlen("Console");
 127 }
 128
 129 /***********************************************************************
 130  *            GetConsoleTitleW   (KERNEL32.192)
 131  */
 132 DWORD WINAPI GetConsoleTitle32W(LPWSTR title,DWORD size)
 133 {
 134     lstrcpynAtoW(title,"Console",size);
 135     return strlen("Console");
 136 }
 137
 138 /***********************************************************************
 139  *            WriteConsoleA   (KERNEL32.729)
 140  */
 141 BOOL32 WINAPI WriteConsole32A( HANDLE32 hConsoleOutput,
 142                                LPCVOID lpBuffer,
 143                                DWORD nNumberOfCharsToWrite,
 144                                LPDWORD lpNumberOfCharsWritten,
 145                                LPVOID lpReserved )
 146 {
 147     *lpNumberOfCharsWritten = fprintf( stderr, "%.*s",
 148                                        (int)nNumberOfCharsToWrite,
 149                                        (LPSTR)lpBuffer );
 150     return TRUE;
 151 }
 152
 153 /***********************************************************************
 154  *            WriteConsoleOutputA   (KERNEL32.732)
 155  */
 156 BOOL32 WINAPI WriteConsoleOutput32A( HANDLE32 hConsoleOutput,
 157                                      LPCHAR_INFO lpBuffer,
 158                                      COORD dwBufferSize,
 159                                      COORD dwBufferCoord,
 160                                      LPSMALL_RECT lpWriteRegion)
 161 {
 162         return FALSE;
 163 }
 164
 165 /***********************************************************************
 166  *            WriteConsoleW   (KERNEL32.577)
 167  */
 168 BOOL32 WINAPI WriteConsole32W( HANDLE32 hConsoleOutput,
 169                                LPCVOID lpBuffer,
 170                                DWORD nNumberOfCharsToWrite,
 171                                LPDWORD lpNumberOfCharsWritten,
 172                                LPVOID lpReserved )
 173 {
 174     LPSTR buf =  HEAP_strdupWtoA( GetProcessHeap(), 0, lpBuffer );
 175     *lpNumberOfCharsWritten = fprintf( stderr, "%.*s",
 176                                        (int)nNumberOfCharsToWrite, buf );
 177     HeapFree( GetProcessHeap(), 0, buf );
 178     return TRUE;
 179 }
 180
 181 /***********************************************************************
 182  *            ReadConsoleA   (KERNEL32.419)
 183  */
 184 BOOL32 WINAPI ReadConsole32A( HANDLE32 hConsoleInput,
 185                               LPVOID lpBuffer,
 186                               DWORD nNumberOfCharsToRead,
 187                               LPDWORD lpNumberOfCharsRead,
 188                               LPVOID lpReserved )
 189 {
 190         fgets(lpBuffer,nNumberOfCharsToRead,stdin);
 191         *lpNumberOfCharsRead = strlen(lpBuffer);
 192         return TRUE;
 193 }
 194
 195 /***********************************************************************
 196  *            ReadConsoleW   (KERNEL32.427)
 197  */
 198 BOOL32 WINAPI ReadConsole32W( HANDLE32 hConsoleInput,
 199                               LPVOID lpBuffer,
 200                               DWORD nNumberOfCharsToRead,
 201                               LPDWORD lpNumberOfCharsRead,
 202                               LPVOID lpReserved )
 203 {
 204     LPSTR buf = (LPSTR)HEAP_xalloc( GetProcessHeap(), 0, nNumberOfCharsToRead);
 205     fgets(buf,nNumberOfCharsToRead,stdin);
 206     lstrcpynAtoW(lpBuffer,buf,nNumberOfCharsToRead);
 207     *lpNumberOfCharsRead = strlen(buf);
 208     HeapFree( GetProcessHeap(), 0, buf );
 209     return TRUE;
 210 }
 211
 212 /***********************************************************************
 213  *            SetConsoleTitle32A   (KERNEL32.476)
 214  */
 215 BOOL32 WINAPI SetConsoleTitle32A(LPCSTR title)
 216 {
 217     fprintf(stderr,"SetConsoleTitle(%s)\n",title);
 218     return TRUE;
 219 }
 220
 221 /***********************************************************************
 222  *            SetConsoleTitle32W   (KERNEL32.477)
 223  */
 224 BOOL32 WINAPI SetConsoleTitle32W( LPCWSTR title )
 225 {
 226     LPSTR titleA = HEAP_strdupWtoA( GetProcessHeap(), 0, title );
 227     fprintf(stderr,"SetConsoleTitle(%s)\n",titleA);
 228     HeapFree( GetProcessHeap(), 0, titleA );
 229     return TRUE;
 230 }
 231
 232 /***********************************************************************
 233  *            FlushConsoleInputBuffer   (KERNEL32.132)
 234  */
 235 BOOL32 WINAPI FlushConsoleInputBuffer(HANDLE32 hConsoleInput)
 236 {
 237     fprintf(stderr,"FlushConsoleInputBuffer(%d)\n",hConsoleInput);
 238     return TRUE;
 239 }
 240
 241 BOOL32 WINAPI SetConsoleCursorPosition(HANDLE32 hcons,COORD c)
 242 {
 243     /* x are columns, y rows */
 244     if (!c.y) {
 245         fprintf(stderr,"\r");
 246         if (c.x)
 247                 fprintf(stderr,"\e[%dC",c.x);
 248         return TRUE;
 249     }
 250     /* handle rest of the cases */
 251     return FALSE;
 252 }
 253
 254 /***********************************************************************
 255  *            GetNumberOfConsoleInputEvents   (KERNEL32.246)
 256  */
 257 BOOL32 WINAPI GetNumberOfConsoleInputEvents(HANDLE32 hcon,LPDWORD nrofevents)
 258 {
 259         *nrofevents = 0;
 260         return TRUE;
 261 }
 262
 263 /***********************************************************************
 264  *            GetNumberOfConsoleMouseButtons   (KERNEL32.358)
 265  */
 266 BOOL32 WINAPI GetNumberOfConsoleMouseButtons(LPDWORD nrofbuttons)
 267 {
 268     *nrofbuttons = 2;
 269     fprintf(stderr,"GetNumberOfConsoleMouseButtons: STUB returning 2\n");
 270     return TRUE;
 271 }
 272
 273 /***********************************************************************
 274  *            PeekConsoleInputA   (KERNEL32.550)
 275  */
 276 BOOL32 WINAPI PeekConsoleInput32A(HANDLE32 hConsoleInput,
 277                                   LPINPUT_RECORD pirBuffer,
 278                                   DWORD cInRecords,
 279                                   LPDWORD lpcRead)
 280 {
 281     pirBuffer = NULL;
 282     cInRecords = 0;
 283     *lpcRead = 0;
 284     fprintf(stderr,"PeekConsoleInput32A: STUB returning TRUE\n");
 285         return TRUE;
 286 }
 287
 288 /***********************************************************************
 289  *            PeekConsoleInputW   (KERNEL32.551)
 290  */
 291 BOOL32 WINAPI PeekConsoleInput32W(HANDLE32 hConsoleInput,
 292                                   LPINPUT_RECORD pirBuffer,
 293                                   DWORD cInRecords,
 294                                   LPDWORD lpcRead)
 295 {
 296     pirBuffer = NULL;
 297     cInRecords = 0;
 298     *lpcRead = 0;
 299     fprintf(stderr,"PeekConsoleInput32W: STUB returning TRUE\n");
 300     return TRUE;
 301 }
 302
 303 /***********************************************************************
 304  *            GetConsoleCursorInfo32   (KERNEL32.296)
 305  */
 306 BOOL32 WINAPI GetConsoleCursorInfo32(HANDLE32 hcon, LPDWORD cinfo)
 307 {
 308   cinfo[0] = 10; /* 10% of character box is cursor.  */
 309   cinfo[1] = TRUE;  /* Cursor is visible.  */
 310   fprintf (stdnimp, "GetConsoleCursorInfo32 -- STUB!\n");
 311   return TRUE;
 312 }
 313
 314 /***********************************************************************
 315  *            SetConsoleCursorInfo32   (KERNEL32.626)
 316  */
 317 BOOL32 WINAPI SetConsoleCursorInfo32(HANDLE32 hcon, LPDWORD cinfo)
 318 {
 319   fprintf (stdnimp, "SetConsoleCursorInfo32 -- STUB!\n");
 320   return TRUE;
 321 }