source: trunk/src/kernel32/console.cpp @ 21916

Last change on this file since 21916 was 21916, checked in by dmik, 9 years ago

Merge branch gcc-kmk to trunk.

File size: 131.8 KB
Line 
1/* $Id: console.cpp,v 1.33 2004-02-19 13:03:06 sandervl Exp $ */
2
3/*
4 * Win32 Console API Translation for OS/2
5 *
6 * 1998/02/10 Patrick Haller (haller@zebra.fh-weingarten.de)
7 *
8 * @(#) console.cpp         1.0.0   1998/02/10 PH Start from scratch
9 *
10 * Project Odin Software License can be found in LICENSE.TXT
11 *
12 */
13
14
15#ifdef DEBUG
16#define DEBUG_LOCAL
17#define DEBUG_LOCAL2
18#endif
19
20//#undef DEBUG_LOCAL
21//#undef DEBUG_LOCAL2
22
23
24/*****************************************************************************
25 * Remark                                                                    *
26 *****************************************************************************
27
28 - DWORD HandlerRoutine (DWORD dwCtrlType)
29   basically an exception handler routine. handles a few signals / excpts.
30   should be somewhere near the exception handling code ... :)
31
32   Hmm, however as PM applications don't really get a ctrl-c signal,
33   I'll have to do this on my own ...
34
35 - supply unicode<->ascii conversions for all the _A and _W function pairs.
36
37 - problem: we can't prevent thread1 from blocking the message queue ?
38            what will happen if a WinTerminate() is issued there ?
39            will the message queue be closed and provide smooth tasking ?
40            how will open32 react on this ?
41
42 - ECHO_LINE_INPUT / ReadFile blocks till CR
43
44 - scrollbars
45 * do some flowchart to exactly determine WHEN to use WHICH setting
46   and perform WHAT action
47
48 - clipboard support
49*/
50
51
52/*******************************************************************************
53*   Header Files                                                               *
54*******************************************************************************/
55
56// Vio/Kbd/Mou declarations conflict in GCC and in real OS2TK headers;
57// force GCC declarations since we link against GCC libs
58#if defined (__EMX__) && defined (USE_OS2_TOOLKIT_HEADERS)
59#undef USE_OS2_TOOLKIT_HEADERS
60#endif
61
62#define  INCL_WIN
63#define  INCL_DOSMEMMGR
64#define  INCL_DOSSEMAPHORES
65#define  INCL_DOSERRORS
66#define  INCL_DOSEXCEPTIONS
67#define  INCL_DOSPROCESS
68#define  INCL_DOSMODULEMGR
69#define  INCL_DOSDEVICES
70#define  INCL_VIO
71#define  INCL_KBD
72#define  INCL_AVIO
73#include <os2wrap.h>         //Odin32 OS/2 api wrappers
74
75#include <process.h>
76#include <stdlib.h>
77#include <string.h>
78
79#include <win32type.h>
80#include <win32api.h>
81#include <misc.h>
82#include <odincrt.h>
83
84#include "conwin.h"          // Windows Header for console only
85#include "HandleManager.h"
86#include "handlenames.h"
87#include "HMDevice.h"
88
89#include "console.h"
90#include "console2.h"
91#include "conin.h"
92#include "conout.h"
93#include "conbuffer.h"
94#include "conbuffervio.h"
95
96#include "conprop.h"
97#include "unicode.h"
98#include "heapstring.h"
99
100#define DBG_LOCALLOG    DBG_console
101#include "dbglocal.h"
102
103#include <os2sel.h>
104
105
106/*******************************************************************************
107*   Process Global Structures                                                  *
108*******************************************************************************/
109static ICONSOLEGLOBALS ConsoleGlobals;
110static ICONSOLEINPUT   ConsoleInput;
111BOOL                   flVioConsole = FALSE;
112
113/*******************************************************************************
114*   Internal Functions                                                         *
115*******************************************************************************/
116static void iConsoleInputQueueLock();
117static void iConsoleInputQueueUnlock();
118
119
120/*****************************************************************************
121 * Name      : iConsoleInputQueueLock
122 * Purpose   : lock the input queue to ensure correct event sequence
123 * Parameters:
124 * Variables :
125 * Result    :
126 * Remark    :
127 * Status    :
128 *
129 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
130 *****************************************************************************/
131
132static void iConsoleInputQueueLock()
133{
134  APIRET rc;
135
136  rc = DosRequestMutexSem(ConsoleInput.hmtxInputQueue,
137                          SEM_INDEFINITE_WAIT);
138  if (rc != NO_ERROR)
139     dprintf(("KERNEL32: Console:iConsoleInputQueueLock error %08xh\n",
140              rc));
141}
142
143
144/*****************************************************************************
145 * Name      : iConsoleInputQueueUnlock
146 * Purpose   : unlock the input queue
147 * Parameters:
148 * Variables :
149 * Result    :
150 * Remark    :
151 * Status    :
152 *
153 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
154 *****************************************************************************/
155
156static void iConsoleInputQueueUnlock()
157{
158  APIRET rc;
159
160  rc = DosReleaseMutexSem(ConsoleInput.hmtxInputQueue);
161  if (rc != NO_ERROR)
162     dprintf(("KERNEL32: Console:iConsoleInputQueueUnlock error %08xh\n",
163              rc));
164}
165
166
167/*****************************************************************************
168 * Name      :
169 * Purpose   :
170 * Parameters:
171 * Variables :
172 * Result    :
173 * Remark    :
174 * Status    :
175 *
176 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
177 *****************************************************************************/
178
179APIRET iConsoleInit(BOOL fVioConsole)              /* creation of the console subsystem */
180{
181  APIRET rc;                                       /* API return code */
182  ULONG  ulPostCount;                              /* semaphore post counter */
183
184
185  flVioConsole = fVioConsole;
186
187  if (ConsoleGlobals.hevConsole != NULLHANDLE) /* we're already initialized ?*/
188    return (NO_ERROR);                             /* then abort immediately */
189
190  rc = DosSetSignalExceptionFocus(SIG_SETFOCUS, &ulPostCount);
191  if(rc) {
192      dprintf(("DosSetSignalExceptionFocus failed with %d", rc));
193  }
194
195  if(flVioConsole == TRUE)
196  {
197    /***************************************************************************
198    * Create pseudo-devices and initialize ConsoleGlobals                     *
199    ***************************************************************************/
200
201    rc = iConsoleDevicesRegister();                /* ensure devices are there */
202    if (rc != NO_ERROR)                                    /* check for errors */
203    {
204        return (rc);                                    /* raise error condition */
205    }
206    rc = DosCreateMutexSem(NULL,
207                             &ConsoleInput.hmtxInputQueue,
208                             0L,
209                             FALSE);
210    if (rc != NO_ERROR)                                       /* other error ? */
211    {
212        return (rc);                                    /* raise error condition */
213    }
214
215    return NO_ERROR;
216  }
217  else {
218    /* create console synchronization semaphore */
219    rc = DosCreateEventSem (NULL,
220                            &ConsoleGlobals.hevConsole,
221                            0L,                        /* semaphore is private */
222                            FALSE);                             /* reset state */
223    if (rc != NO_ERROR)                                       /* other error ? */
224        return (rc);                                    /* raise error condition */
225
226
227                                         /* create console input queue semaphore */
228    rc = DosCreateEventSem (NULL,
229                              &ConsoleInput.hevInputQueue,
230                              0L,                        /* semaphore is private */
231                              FALSE);                             /* reset state */
232    if (rc != NO_ERROR)                                       /* other error ? */
233    {
234        DosCloseEventSem(ConsoleGlobals.hevConsole);    /* close other semaphore */
235        return (rc);                                    /* raise error condition */
236    }
237
238
239    rc = DosCreateMutexSem(NULL,
240                             &ConsoleInput.hmtxInputQueue,
241                             0L,
242                             FALSE);
243    if (rc != NO_ERROR)                                       /* other error ? */
244    {
245        DosCloseEventSem(ConsoleGlobals.hevConsole);    /* close other semaphore */
246        DosCloseEventSem(ConsoleInput.hevInputQueue);   /* close other semaphore */
247        return (rc);                                    /* raise error condition */
248    }
249
250    /***************************************************************************
251    * Create pseudo-devices and initialize ConsoleGlobals                     *
252    ***************************************************************************/
253
254    rc = iConsoleDevicesRegister();                /* ensure devices are there */
255    if (rc != NO_ERROR)                                    /* check for errors */
256    {
257        DosCloseEventSem(ConsoleGlobals.hevConsole);    /* close other semaphore */
258        DosCloseEventSem(ConsoleInput.hevInputQueue);   /* close other semaphore */
259        return (rc);                                    /* raise error condition */
260    }
261
262
263    /***************************************************************************
264    * Presentation Manager Initialization phase                               *
265    ***************************************************************************/
266
267        /* OK, we're about to initialize the console subsystem for this process. */
268                               /* start message thread for console object window */
269    ConsoleGlobals.tidConsole = _beginthread(iConsoleMsgThread,
270                                               NULL,
271                                               12288,
272                                               NULL);
273                                       /* has the thread been created properly ? */
274    if (ConsoleGlobals.tidConsole == -1)
275    {
276        DosCloseEventSem(ConsoleInput.hevInputQueue);   /* close other semaphore */
277        DosCloseEventSem(ConsoleGlobals.hevConsole);    /* close event semaphore */
278        ConsoleGlobals.hevConsole = NULLHANDLE;         /* for ConsoleIsActive() */
279        return (rc);                                    /* raise error condition */
280    }
281    else
282        DosSetPriority(PRTYS_THREAD,                             /* set priority */
283                       ConsoleGlobals.Options.ulConsoleThreadPriorityClass,
284                       ConsoleGlobals.Options.ulConsoleThreadPriorityDelta,
285                       ConsoleGlobals.tidConsole);
286
287
288                          /* wait for the child thread to do it's initialization */
289                                                  /* timeout isn't really useful */
290    rc = DosWaitEventSem(ConsoleGlobals.hevConsole,
291                           SEM_INDEFINITE_WAIT);
292    if (rc != NO_ERROR)                                    /* check for errors */
293    {
294        DosCloseEventSem(ConsoleInput.hevInputQueue);   /* close other semaphore */
295        DosCloseEventSem(ConsoleGlobals.hevConsole);    /* close event semaphore */
296        ConsoleGlobals.hevConsole = NULLHANDLE;         /* for ConsoleIsActive() */
297        return (rc);                                    /* raise error condition */
298    }
299
300    DosResetEventSem(ConsoleGlobals.hevConsole,       /* reset event semaphore */
301                       &ulPostCount);
302
303    rc = ConsoleGlobals.rcConsole;   /* pass thru console thread's return code */
304
305    return (rc);                                                         /* OK */
306  }
307}
308
309
310/*****************************************************************************
311 * Name      : ConsoleDevicesRegister
312 * Purpose   : creates and registers console devices if the standard handles
313 *             are not redirected to a file
314 * Parameters:
315 * Variables :
316 * Result    :
317 * Remark    :
318 * Status    :
319 *
320 * Author    : Patrick Haller [Tue, 1998/03/17 01:55]
321 *****************************************************************************/
322
323APIRET iConsoleDevicesRegister(void)
324{
325  DWORD  dwType;                                       /* device handle type */
326  HANDLE hStandardIn;                              /* stdin handle to CONIN$ */
327  HANDLE hStandardOut;                           /* stdout handle to CONOUT$ */
328  HANDLE hStandardError;                         /* stderr handle to CONOUT$ */
329
330  HMDeviceConsoleInClass     *pHMDeviceConsoleIn;
331  HMDeviceConsoleOutClass    *pHMDeviceConsoleOut;
332  HMDeviceConsoleBufferClass *pHMDeviceConsoleBuffer;
333
334  DWORD rc;
335
336  static BOOL fDevicesInitialized;     /* have we been initialized already ? */
337
338  if (fDevicesInitialized == TRUE)                 /* OK, we're already done */
339    return (NO_ERROR);
340  else
341    fDevicesInitialized = TRUE;
342
343  dprintf(("KERNEL32:ConsoleDevicesRegister\n"));
344
345
346  /*************************************
347   * Initialize Console Window Options *
348   *************************************/
349
350  // load defaults
351  ConsolePropertyDefault(&ConsoleGlobals.Options);
352
353  ConsoleGlobals.ulTimerFrequency = 10;  /* cursor + blitter timer frequency */
354
355  ConsoleGlobals.coordWindowSize.X               = ConsoleGlobals.Options.coordDefaultSize.X;
356  ConsoleGlobals.coordWindowSize.Y               = ConsoleGlobals.Options.coordDefaultSize.Y;
357  ConsoleGlobals.coordWindowPos.X                = 0;
358  ConsoleGlobals.coordWindowPos.Y                = 0;
359  if(flVioConsole == TRUE) {
360        VIOMODEINFO videoinfo;
361
362        videoinfo.cb = sizeof(VIOMODEINFO);
363        rc = VioGetMode(&videoinfo, 0);
364        if(rc == 0) {
365            dprintf(("video mode (%d,%d)", videoinfo.col, videoinfo.row));
366            ConsoleGlobals.coordWindowSize.X = videoinfo.col;
367            ConsoleGlobals.coordWindowSize.Y = videoinfo.row;
368        }
369  }
370
371
372  ConsoleGlobals.flFrameFlags = FCF_SIZEBORDER   |   /* frame creation flags */
373                                FCF_TITLEBAR     |
374                                FCF_SHELLPOSITION|
375                                FCF_SYSMENU      |
376                                FCF_TASKLIST     |
377                                FCF_AUTOICON     |
378                                FCF_HORZSCROLL   |
379                                FCF_VERTSCROLL   |
380                                FCF_MINMAX;
381
382                                                   /* generate copy of title */
383  ConsoleGlobals.pszWindowTitle = strdup(GetCommandLineA());
384
385                                    /* obtain module handle to our resources */
386  rc = DosQueryModuleHandleStrict("KERNEL32",
387                                  &ConsoleGlobals.hmodResource);
388  if (rc != NO_ERROR)
389    dprintf(("KERNEL32/CONSOLE: Can't get handle to KERNEL32 (%u).\n",
390             rc));
391
392                                             /* standard console input modes */
393  ConsoleInput.dwConsoleMode = ENABLE_LINE_INPUT      |
394                               ENABLE_PROCESSED_INPUT;
395  /* @@@PH ENABLE_ECHO_INPUT || ENABLE_MOUSE_INPUT; */
396
397  ConsoleGlobals.hConsoleBufferDefault = INVALID_HANDLE_VALUE;
398  ConsoleGlobals.hConsoleBuffer        = INVALID_HANDLE_VALUE;
399
400
401  if (flVioConsole == FALSE)
402  {
403    // defaults are effective, try to read and apply stored properties
404    if (ConsolePropertyLoad(&ConsoleGlobals.Options) == NO_ERROR)
405        ConsolePropertyApply(&ConsoleGlobals.Options);
406  }
407
408
409  /***************************************************************************
410   * Standard handles     Initialization phase                               *
411   ***************************************************************************/
412
413  /* create devices and register devices with handlemanager */
414  pHMDeviceConsoleIn  = new HMDeviceConsoleInClass("CONIN$",
415                                                   &ConsoleInput,
416                                                   &ConsoleGlobals);
417
418  rc = HMDeviceRegister ("CONIN$",
419                         pHMDeviceConsoleIn);
420  if (rc != NO_ERROR)                                  /* check for errors */
421      dprintf(("KERNEL32:ConsoleDevicesRegister: registering CONIN$ failed with %u.\n",
422               rc));
423
424
425  pHMDeviceConsoleOut = new HMDeviceConsoleOutClass("CONOUT$",
426                                                    &ConsoleInput,
427                                                    &ConsoleGlobals);
428  rc = HMDeviceRegister ("CONOUT$",
429                         pHMDeviceConsoleOut);
430  if (rc != NO_ERROR)                                  /* check for errors */
431      dprintf(("KERNEL32:ConsoleDevicesRegister: registering CONOUT$ failed with %u.\n",
432               rc));
433
434  // add standard symbolic links
435  HandleNamesAddSymbolicLink("CON",        "CONOUT$");
436  HandleNamesAddSymbolicLink("CON:",       "CONOUT$");
437  HandleNamesAddSymbolicLink("\\\\.\\CON", "CONOUT$");
438
439  if(flVioConsole == TRUE)
440  {
441        pHMDeviceConsoleBuffer = (HMDeviceConsoleBufferClass *)new HMDeviceConsoleVioBufferClass("CONBUFFER$",
442                                                                                                 &ConsoleInput,
443                                                                                                 &ConsoleGlobals);
444  }
445  else {
446        pHMDeviceConsoleBuffer = new HMDeviceConsoleBufferClass("CONBUFFER$",
447                                                                &ConsoleInput,
448                                                                &ConsoleGlobals);
449  }
450  rc = HMDeviceRegister ("CONBUFFER$",
451                         pHMDeviceConsoleBuffer);
452  if (rc != NO_ERROR)                                  /* check for errors */
453      dprintf(("KERNEL32:ConsoleDevicesRegister: registering CONBUFFER$ failed with %u.\n",
454               rc));
455
456
457  if(flVioConsole == FALSE)
458  {
459   /***********************************************************************
460    * initialize stdin handle                                             *
461    ***********************************************************************/
462   hStandardIn = GetStdHandle(STD_INPUT_HANDLE);
463   dwType = GetFileType(hStandardIn);
464   if (dwType == FILE_TYPE_CHAR)                /* is handle redirected ? */
465     hStandardIn = HMCreateFile("CONIN$",
466                                GENERIC_READ | GENERIC_WRITE,
467                                FILE_SHARE_READ | FILE_SHARE_WRITE,
468                                NULL,
469                                0,
470                                CONSOLE_TEXTMODE_BUFFER,
471                                0);
472
473   HMSetStdHandle(STD_INPUT_HANDLE,
474                  hStandardIn);
475
476   /***********************************************************************
477    * initialize stdout handle                                            *
478    ***********************************************************************/
479   hStandardOut = GetStdHandle(STD_OUTPUT_HANDLE);
480   dwType = GetFileType(hStandardOut);
481   if (dwType == FILE_TYPE_CHAR)                /* is handle redirected ? */
482     hStandardOut = HMCreateFile("CONOUT$",
483                                 GENERIC_READ | GENERIC_WRITE,
484                                 FILE_SHARE_READ | FILE_SHARE_WRITE,
485                                 NULL,
486                                 0,
487                                 CONSOLE_TEXTMODE_BUFFER,
488                                 0);
489
490   HMSetStdHandle(STD_OUTPUT_HANDLE,
491                  hStandardOut);
492
493   /***********************************************************************
494    * initialize stderr handle                                            *
495    ***********************************************************************/
496   hStandardError = GetStdHandle(STD_ERROR_HANDLE);
497   dwType = GetFileType(hStandardError);
498   if (dwType == FILE_TYPE_CHAR)                /* is handle redirected ? */
499     hStandardError = HMCreateFile("CONOUT$",
500                                   GENERIC_READ | GENERIC_WRITE,
501                                   FILE_SHARE_READ | FILE_SHARE_WRITE,
502                                   NULL,
503                                   0,
504                                   CONSOLE_TEXTMODE_BUFFER,
505                                   0);
506
507   HMSetStdHandle(STD_ERROR_HANDLE,
508                  hStandardError);
509  }
510
511  return (NO_ERROR);                                                   /* OK */
512}
513
514
515/*****************************************************************************
516 * Name      : static APIRET ConsoleTerminate
517 * Purpose   : Shuts the OS/2 console subsystem down
518 * Parameters: VOID
519 * Variables :
520 * Result    : OS/2 API return code
521 * Remark    : That consolebuffer handle that became allocated as default
522 *             screen buffer is lost here. This would be a serious memory
523 *             leak if an application keeps opening and closing the console
524 *             frequently.
525 * Status    :
526 *
527 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
528 *****************************************************************************/
529
530ULONG iConsoleTerminate(VOID)
531{
532  APIRET rc = NO_ERROR;
533
534  if(flVioConsole == FALSE)
535  {
536    DosCloseEventSem(ConsoleGlobals.hevConsole);      /* close other semaphore */
537    DosCloseEventSem(ConsoleInput.hevInputQueue);     /* close other semaphore */
538
539
540    WinPostMsg (ConsoleGlobals.hwndFrame,         /* force thread to terminate */
541                WM_CLOSE,
542                (MPARAM)NULL,
543                (MPARAM)NULL);
544
545    rc = DosWaitThread(&ConsoleGlobals.tidConsole,/* wait until thd terminates */
546                       DCWW_WAIT);
547
548  }
549  DosCloseMutexSem(ConsoleInput.hmtxInputQueue);          /* close semaphore */
550
551  /* close the consolebuffer handle */
552  HMCloseHandle(ConsoleGlobals.hConsoleBufferDefault);
553  free(ConsoleGlobals.pszWindowTitle);   /* free previously allocated memory */
554
555  return (rc);                                                         /* OK */
556}
557
558
559/*****************************************************************************
560 * Name      : static void ConsoleWaitClose
561 * Purpose   : Wait for the user to close console window
562 * Parameters: VOID
563 * Variables :
564 * Result    :
565 * Remark    :
566 * Status    :
567 *
568 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
569 *****************************************************************************/
570
571void iConsoleWaitClose(void)
572{
573  CHAR szBuffer[128];                                /* buffer for the title */
574  BOOL fResult;                /* result from subsequent calls to Win32 APIs */
575
576                                /* check if there is a console window at all */
577  if (iConsoleIsActive() == FALSE)
578    return;                                                          /* nope */
579
580  if(flVioConsole == TRUE)  //no need to wait for VIO session
581    return;
582
583  strcpy (szBuffer,               /* indicate console process has terminated */
584          "Completed: ");
585
586  fResult = GetConsoleTitleA(szBuffer + 11,/* 11 is length of Completed:_ */
587                                sizeof(szBuffer) - 11);
588
589
590                                /* Set new title: Win32 Console - Terminated */
591  fResult = SetConsoleTitleA(szBuffer);
592
593  DosCloseEventSem(ConsoleGlobals.hevConsole);      /* close other semaphore */
594  DosCloseEventSem(ConsoleInput.hevInputQueue);     /* close other semaphore */
595  DosCloseMutexSem(ConsoleInput.hmtxInputQueue);          /* close semaphore */
596
597
598                                          /* terminate console immediately ? */
599  if (ConsoleGlobals.Options.fTerminateAutomatically == FALSE) {
600    if(getenv("ODIN_AUTOEXITCONSOLE") == NULL) {
601        DosWaitThread(&ConsoleGlobals.tidConsole,   /* wait until thd terminates */
602                      DCWW_WAIT);
603    }
604  }
605}
606
607
608/*****************************************************************************
609 * Name      : static BOOL ConsoleIsActive
610 * Purpose   : Check if Console window is opened
611 * Parameters: VOID
612 * Variables :
613 * Result    :
614 * Remark    :
615 * Status    :
616 *
617 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
618 *****************************************************************************/
619
620BOOL iConsoleIsActive(void)
621{
622  if(flVioConsole == TRUE) //actually, this isn't needed in VIO mode
623     return TRUE;
624
625  return (NULLHANDLE != ConsoleGlobals.hevConsole);
626}
627
628
629/*****************************************************************************
630 * Name      : static VOID ConsoleMsgThread
631 * Purpose   : Message handler thread for the console object window
632 * Parameters: PVOID pDummy
633 * Variables :
634 * Result    : is placed in Globals.rcConsole
635 * Remark    : the main thread has to wait for this thread
636 * Status    :
637 *
638 * Author    : Patrick Haller [Tue, 1998/02/10 02:49]
639 *****************************************************************************/
640
641VOID iConsoleMsgThread(PVOID pParameters)
642{
643  APIRET rc;                                              /* API return code */
644
645
646  ConsoleGlobals.rcConsole = NO_ERROR;                     /* initialization */
647
648  ConsoleGlobals.hab = WinInitialize(0);             /* enable thread for PM */
649  if (ConsoleGlobals.hab == NULLHANDLE) /* if anchor block allocation failed */
650    ConsoleGlobals.rcConsole = ERROR_NOT_ENOUGH_MEMORY;
651  else
652  {
653                                                     /* create message queue */
654    ConsoleGlobals.hmq = WinCreateMsgQueue(ConsoleGlobals.hab,
655                                           0);
656    if (ConsoleGlobals.hmq == NULLHANDLE)  /* if msg queue allocation failed */
657    {
658      WinTerminate(ConsoleGlobals.hab);     /* stop thread from accessing PM */
659      ConsoleGlobals.rcConsole = ERROR_NOT_ENOUGH_MEMORY;
660    }
661    else
662    {
663      if (WinRegisterClass(ConsoleGlobals.hab, /* register our class with PM */
664                           SZ_CONSOLE_CLASS,
665                           iConsoleWindowProc,
666                           CS_SIZEREDRAW,
667                           0)
668          == FALSE)
669      {
670        WinDestroyMsgQueue(ConsoleGlobals.hmq);     /* destroy message queue */
671        WinTerminate(ConsoleGlobals.hab);   /* stop thread from accessing PM */
672        ConsoleGlobals.rcConsole = ERROR_NOT_ENOUGH_MEMORY;
673      }
674      else
675      {
676        ConsoleGlobals.hwndFrame = WinCreateStdWindow(HWND_DESKTOP,
677                                                      WS_VISIBLE,
678                                                      &ConsoleGlobals.flFrameFlags,
679                                                      SZ_CONSOLE_CLASS,
680                                                      ConsoleGlobals.pszWindowTitle,
681                                                      0,
682                                                      ConsoleGlobals.hmodResource,
683                                                      ID_CONSOLE_MAIN,
684                                                      &ConsoleGlobals.hwndClient);
685        if (ConsoleGlobals.hwndFrame == NULLHANDLE) /* check window creation */
686        {
687          WinDestroyMsgQueue(ConsoleGlobals.hmq);   /* destroy message queue */
688          WinTerminate(ConsoleGlobals.hab); /* stop thread from accessing PM */
689          ConsoleGlobals.rcConsole = ERROR_NOT_ENOUGH_MEMORY;
690        } /* WinCreateStdWindow */
691      } /* WinRegisterClass */
692    } /* WinCreateMsgQueue */
693  } /* WinInitialize */
694
695
696  DosPostEventSem(ConsoleGlobals.hevConsole);      /* signal the main thread */
697
698
699  if (ConsoleGlobals.rcConsole != NO_ERROR)      /* if we ran into a problem */
700  {
701    DosCloseEventSem(ConsoleInput.hevInputQueue);   /* close other semaphore */
702    DosCloseEventSem(ConsoleGlobals.hevConsole); /* subsystem not running .. */
703    ConsoleGlobals.hevConsole = NULLHANDLE;         /* for ConsoleIsActive() */
704    return;                    /* abort the message queue thread immediately */
705  }
706
707
708  while( WinGetMsg(ConsoleGlobals.hab,                       /* message loop */
709                   &ConsoleGlobals.qmsg,
710                   NULLHANDLE,
711                   0,
712                   0) )
713    WinDispatchMsg(ConsoleGlobals.hab,               /* dispatch the message */
714                   &ConsoleGlobals.qmsg);
715
716                                    /* do the cleanup, destroy window, queue */
717                                    /* and stop thread from using PM         */
718  WinDestroyWindow  (ConsoleGlobals.hwndFrame);
719  WinDestroyMsgQueue(ConsoleGlobals.hmq);
720  WinTerminate      (ConsoleGlobals.hab);
721
722                   /* destruction of semaphore indicates console is shutdown */
723  DosCloseEventSem(ConsoleInput.hevInputQueue);     /* close other semaphore */
724  DosCloseEventSem(ConsoleGlobals.hevConsole);
725  DosCloseMutexSem(ConsoleInput.hmtxInputQueue);          /* close semaphore */
726
727  ConsoleGlobals.hevConsole   = NULLHANDLE;         /* for ConsoleIsActive() */
728  ConsoleInput.hevInputQueue  = NULLHANDLE;
729  ConsoleInput.hmtxInputQueue = NULLHANDLE;
730
731  /* @@@PH we've got to exit the process here ! */
732  ExitProcess(1);
733}
734
735
736/*****************************************************************************
737 * Name      : static MRESULT EXPENTRY ConsoleWindowProc
738 * Purpose   : Window Procedure for OUR console window
739 * Parameters: HWND   hwnd - window handle
740 *             ULONG  msg  - message identifier
741 *             MPARAM mp1  - message parameter 1
742 *             MPARAM mp2  - message parameter 2
743 * Variables :
744 * Result    : MRESULT for PM
745 * Remark    :
746 * Status    :
747 *
748 * Author    : Patrick Haller [Tue, 1998/02/10 03:24]
749 *****************************************************************************/
750
751MRESULT EXPENTRY iConsoleWindowProc(HWND   hwnd,
752                                    ULONG  msg,
753                                    MPARAM mp1,
754                                    MPARAM mp2)
755{
756  static RECTL rcl;                                      /* window rectangle */
757  static HPS   hps;
758
759  switch(msg)
760  {
761    /*************************************************************************
762     * WM_CREATE window creation                                             *
763     *************************************************************************/
764
765    case WM_CREATE:
766      WinPostMsg(hwnd,                            /* deferred initialization */
767                 UM_CONSOLE_CREATE,
768                 (MPARAM)NULL,
769                 (MPARAM)NULL);
770      break;
771
772
773    case UM_CONSOLE_CREATE:
774    {
775      APIRET    rc;                                       /* API return code */
776      HWND      hwndFrame;                            /* frame window handle */
777
778                                                /* subclass the frame window */
779      hwndFrame = ConsoleGlobals.hwndFrame;
780      ConsoleGlobals.pfnwpFrameOriginal = WinSubclassWindow(hwndFrame,
781                                                            iConsoleFrameWindowProc);
782
783      ConsoleGlobals.hwndMenuConsole
784                      = WinLoadMenu (hwnd,             /* load context menue */
785                                     ConsoleGlobals.hmodResource,
786                                     ID_CONSOLE_MAIN);
787
788                                               /* set an icon for the dialog */
789      ConsoleGlobals.hPtrConsole = WinLoadPointer(HWND_DESKTOP,
790                                                  ConsoleGlobals.hmodResource,
791                                                  ID_CONSOLE_MAIN );
792      WinSendMsg(ConsoleGlobals.hwndFrame,
793                 WM_SETICON,
794                 (MPARAM)ConsoleGlobals.hPtrConsole,
795                 0L );
796
797               /* determine handles of the horizontal / vertical scroll bars */
798      ConsoleGlobals.hwndVertScroll = WinWindowFromID(ConsoleGlobals.hwndFrame,
799                                                      FID_VERTSCROLL);
800
801      ConsoleGlobals.hwndHorzScroll = WinWindowFromID(ConsoleGlobals.hwndFrame,
802                                                      FID_HORZSCROLL);
803
804                            /* the initial state of the controls is DETACHED */
805      WinSetParent(ConsoleGlobals.hwndHorzScroll,          /* detach control */
806                   HWND_OBJECT,
807                   FALSE);
808
809      WinSetParent(ConsoleGlobals.hwndVertScroll,          /* detach control */
810                   HWND_OBJECT,
811                   FALSE);
812
813
814                                           /* create AVIO presentation space */
815      rc = VioCreatePS(&ConsoleGlobals.hvpsConsole,
816                       ConsoleGlobals.coordWindowSize.Y,
817                       ConsoleGlobals.coordWindowSize.X,
818                       0,                               /* format, must be 0 */
819                       FORMAT_CGA,
820                       0);                       /* template hvps, must be 0 */
821      if (rc != NO_ERROR)                                    /* check errors */
822        dprintf(("KERNEL32/CONSOLE:VioCreatePS=%u\n",
823                 rc));
824
825 /* PH 1998/02/12 this seems to be an OS/2 PM bug:
826    when doing a WinOpenWindowDC here, PM hangs. Seems it never gets back into
827    the message loop. To investigate and report to IBM
828  */
829
830                               /* get a device context for the client window */
831      ConsoleGlobals.hdcConsole = WinOpenWindowDC(hwnd);
832                                           /* associate AVIO PS with the HDC */
833      rc = VioAssociate(ConsoleGlobals.hdcConsole,
834                        ConsoleGlobals.hvpsConsole);
835      if (rc != NO_ERROR)                                    /* check errors */
836        dprintf(("KERNEL32/CONSOLE:VioAssociate=%u\n",
837                 rc));
838
839      iConsoleFontQuery();                       /* query current cell sizes */
840
841                                          /* adjust window size and position */
842      HMDeviceRequest(ConsoleGlobals.hConsoleBuffer,
843                      DRQ_INTERNAL_CONSOLEADJUSTWINDOW,
844                      0,
845                      0,
846                      0,
847                      0);
848
849            /* @@@PH if console is maximized - now switched on per default ! */
850      WinSetWindowPos (ConsoleGlobals.hwndFrame,
851                       HWND_DESKTOP,
852                       0,
853                       0,
854                       ConsoleGlobals.Options.coordDefaultSize.X *
855                         ConsoleGlobals.sCellCX +
856                         2 * WinQuerySysValue(HWND_DESKTOP, SV_CXSIZEBORDER),
857                       ConsoleGlobals.Options.coordDefaultSize.Y *
858                         ConsoleGlobals.sCellCY +
859                         WinQuerySysValue(HWND_DESKTOP, SV_CYTITLEBAR) +
860                         2 * WinQuerySysValue(HWND_DESKTOP, SV_CYSIZEBORDER),
861                       SWP_SIZE);
862
863                             /* do we have to set the window position also ? */
864      if (ConsoleGlobals.Options.fSetWindowPosition == TRUE)
865        WinSetWindowPos (ConsoleGlobals.hwndFrame,
866                         HWND_DESKTOP,
867                         ConsoleGlobals.Options.coordDefaultPosition.X,
868                         ConsoleGlobals.Options.coordDefaultPosition.Y,
869                         0,
870                         0,
871                         SWP_MOVE);
872
873                     /* start timer service for blitting and cursor blinking */
874      ConsoleGlobals.idTimer = WinStartTimer (ConsoleGlobals.hab,
875                                              hwnd,
876                                              CONSOLE_TIMER_ID,  /* timer id */
877                                              ConsoleGlobals.ulTimerFrequency);
878
879      WinPostMsg (hwnd,   /* send myself a start message so we get the first */
880                  WM_TIMER,                             /* frame immediately */
881                  (MPARAM)NULL,
882                  (MPARAM)NULL);
883    }
884    break;
885
886
887    /*************************************************************************
888     * WM_DESTROY window destruction                                         *
889     *************************************************************************/
890
891    case WM_DESTROY:
892      WinStopTimer (ConsoleGlobals.hab,                      /* anchor block */
893                    hwnd,
894                    ConsoleGlobals.idTimer);                     /* timer ID */
895
896      VioAssociate(NULL,
897                   ConsoleGlobals.hvpsConsole); /* disassociates the AVIO PS */
898      VioDestroyPS(ConsoleGlobals.hvpsConsole); /* destroys the AVIO PS      */
899
900      WinDestroyWindow(ConsoleGlobals.hwndMenuConsole);
901      WinDestroyPointer(ConsoleGlobals.hPtrConsole);
902      break;
903
904
905    /*************************************************************************
906     * WM_TIMER display cursor and update AVIO PS if required                *
907     *************************************************************************/
908
909    case WM_TIMER:
910                                       /* check if console has to be updated */
911      if (ConsoleGlobals.fUpdateRequired == TRUE)
912      {
913        ConsoleGlobals.fUpdateRequired = FALSE;     /* as soon as possible ! */
914
915                                /* as device to map itself to the VIO buffer */
916        HMDeviceRequest(ConsoleGlobals.hConsoleBuffer,
917                        DRQ_INTERNAL_CONSOLEBUFFERMAP,
918                        0,
919                        0,
920                        0,
921                        0);
922
923        { /* DEBUG */
924          APIRET rc;
925                                           /* and now bring it to the screen */
926        rc = VioShowPS(ConsoleGlobals.coordWindowSize.Y,
927                       ConsoleGlobals.coordWindowSize.X,
928                       0,
929                       ConsoleGlobals.hvpsConsole);
930
931          dprintf(("KERNEL32::Console::1 VioShowPS(%u,%u,%u)=%u\n",
932                   ConsoleGlobals.coordWindowSize.Y,
933                   ConsoleGlobals.coordWindowSize.X,
934                   ConsoleGlobals.hvpsConsole,
935                   rc));
936        }
937
938                                             /* cursor is overwritten here ! */
939        HMDeviceRequest(ConsoleGlobals.hConsoleBuffer,
940                        DRQ_INTERNAL_CONSOLECURSORSHOW,
941                        CONSOLECURSOR_OVERWRITTEN,
942                        0,
943                        0,
944                        0);
945      }
946      else
947      {
948        ConsoleGlobals.ulTimerCursor++;                  /* increase counter */
949        if (ConsoleGlobals.ulTimerCursor > ConsoleGlobals.Options.ucCursorDivisor)
950        {
951          ConsoleGlobals.ulTimerCursor = 0;                 /* reset counter */
952                                                     /* let our cursor blink */
953          HMDeviceRequest(ConsoleGlobals.hConsoleBuffer,
954                          DRQ_INTERNAL_CONSOLECURSORSHOW,
955                          CONSOLECURSOR_BLINK,
956                          0,
957                          0,
958                          0);
959        }
960      }
961      break;
962
963
964    /*************************************************************************
965     * WM_MINMAXFRAME handle window repaint in case of iconized window       *
966     *************************************************************************/
967
968    case WM_MINMAXFRAME :
969    {
970      BOOL  fShow = ! (((PSWP) mp1)->fl & SWP_MINIMIZE);
971      HENUM henum;
972      HWND  hwndChild;
973
974      WinEnableWindowUpdate ( hwnd, FALSE );
975
976      for (henum=WinBeginEnumWindows(hwnd);
977           (hwndChild = WinGetNextWindow (henum)) != 0; )
978      WinShowWindow ( hwndChild, fShow );
979
980      WinEndEnumWindows ( henum );
981      WinEnableWindowUpdate ( hwnd, TRUE );
982    }
983    break;
984
985
986    /*************************************************************************
987     * WM_PAINT repaint the window                                           *
988     *************************************************************************/
989    case WM_PAINT:
990      hps = WinBeginPaint(hwnd,
991                          (HPS)NULL,
992                          &rcl);
993                                   /* blit the whole AVIO presentation space */
994      { /* DEBUG */
995        APIRET rc;
996                                     /* and now bring it to the screen */
997        rc = VioShowPS(ConsoleGlobals.coordWindowSize.Y,
998                       ConsoleGlobals.coordWindowSize.X,
999                       0,
1000                       ConsoleGlobals.hvpsConsole);
1001
1002        dprintf(("KERNEL32::Console::2 VioShowPS(%u,%u,%u)=%u\n",
1003                 ConsoleGlobals.coordWindowSize.Y,
1004                 ConsoleGlobals.coordWindowSize.X,
1005                 ConsoleGlobals.hvpsConsole,
1006                 rc));
1007      }
1008
1009      WinEndPaint(hps);
1010      break;
1011
1012
1013    /*************************************************************************
1014     * WM_SIZE resize the window                                             *
1015     *************************************************************************/
1016    case WM_SIZE:
1017    {
1018                                       /* calculate scrollbars if neccessary */
1019      HMDeviceRequest(ConsoleGlobals.hConsoleBuffer,
1020                      DRQ_INTERNAL_CONSOLEADJUSTWINDOW,
1021                      0,
1022                      0,
1023                      0,
1024                      0);
1025
1026      return WinDefAVioWindowProc(hwnd,
1027                                  (USHORT)msg,
1028                                  (ULONG)mp1,
1029                                  (ULONG)mp2);
1030    }
1031
1032
1033    /*************************************************************************
1034     * context menue                                                         *
1035     *************************************************************************/
1036    case WM_CONTEXTMENU:
1037    {
1038      WinPopupMenu (hwnd,
1039                    hwnd,
1040                    ConsoleGlobals.hwndMenuConsole,
1041                    SHORT1FROMMP(mp1),
1042                    SHORT2FROMMP(mp1),
1043                    CM_CONSOLE_PROPERTIES,                        /* item id */
1044                    PU_HCONSTRAIN |
1045                    PU_VCONSTRAIN |
1046                    PU_KEYBOARD   |
1047                    PU_MOUSEBUTTON1 |
1048                    PU_MOUSEBUTTON2 |
1049                    PU_POSITIONONITEM);
1050    }
1051    return (MPARAM)FALSE;
1052
1053
1054    /*************************************************************************
1055     * WM_COMMAND command processing                                         *
1056     *************************************************************************/
1057    case WM_COMMAND:
1058    {
1059      switch(SHORT1FROMMP(mp1))             /* select appropriate identifier */
1060      {
1061        /* close console window, however we can't call ConsoleTerminate here!*/
1062        case CM_CONSOLE_EXIT:
1063          WinPostMsg (ConsoleGlobals.hwndFrame,
1064                      WM_CLOSE,
1065                      (MPARAM)NULL,
1066                      (MPARAM)NULL);
1067
1068          return (MPARAM)FALSE;
1069
1070
1071        case CM_CONSOLE_REPAINT:
1072          WinInvalidateRect(ConsoleGlobals.hwndClient,/* redraw frame window */
1073                            NULL,
1074                            TRUE);
1075          return (MPARAM)FALSE;
1076
1077                                               /* open the properties dialog */
1078        case CM_CONSOLE_PROPERTIES:
1079        {
1080          ULONG ulResult;                              /* response from user */
1081
1082          ConsoleGlobals.Options.hmodResources =       /* save module handle */
1083            ConsoleGlobals.hmodResource;
1084
1085          ulResult = WinDlgBox(HWND_DESKTOP,
1086                               ConsoleGlobals.hwndClient,
1087                               &ConsolePropertyDlgProc,
1088                               ConsoleGlobals.hmodResource,
1089                               DLG_CONSOLE_PROPERTIES,
1090                               (PVOID)&ConsoleGlobals.Options);
1091          switch (ulResult)
1092          {
1093            case ID_BTN_SAVE:
1094              ConsolePropertySave(&ConsoleGlobals.Options);
1095              ConsolePropertyApply(&ConsoleGlobals.Options);
1096              break;
1097
1098            case ID_BTN_APPLY:
1099              ConsolePropertyApply(&ConsoleGlobals.Options);
1100              break;
1101
1102            default:           break;
1103          }
1104
1105          return (MPARAM) FALSE;
1106        }
1107      }
1108    }
1109    break;
1110
1111
1112    /*************************************************************************
1113     * WM_CHAR keyboard char processing                                      *
1114     *************************************************************************/
1115
1116    case WM_CHAR:
1117      iConsoleInputEventPushKey(mp1,                /* push event into queue */
1118                                mp2);
1119      break;                                  /* enable further processing ! */
1120
1121
1122    /*************************************************************************
1123     * WM_SETFOCUS focus changing processing                                 *
1124     *************************************************************************/
1125
1126    case WM_SETFOCUS:
1127      iConsoleInputEventPushFocus((BOOL)mp2);       /* push event into queue */
1128      break;                                  /* enable further processing ! */
1129
1130
1131    /*************************************************************************
1132     * WM_MOUSEMOVE mouse event processing                                   *
1133     *************************************************************************/
1134
1135    case WM_MOUSEMOVE:
1136    case WM_BUTTON1UP:
1137    case WM_BUTTON1DOWN:
1138    case WM_BUTTON2UP:
1139    case WM_BUTTON2DOWN:
1140    case WM_BUTTON3UP:
1141    case WM_BUTTON3DOWN:
1142    case WM_BUTTON1DBLCLK:
1143    case WM_BUTTON2DBLCLK:
1144    case WM_BUTTON3DBLCLK:
1145      iConsoleInputEventPushMouse(msg,
1146                                  mp1,              /* push event into queue */
1147                                  mp2);
1148      break;                                  /* enable further processing ! */
1149  }
1150
1151  return WinDefWindowProc(hwnd,                     /* to default processing */
1152                          msg,
1153                          mp1,
1154                          mp2);
1155}
1156
1157
1158/*****************************************************************************
1159 * Name      : static MRESULT EXPENTRY ConsoleFrameWindowProc
1160 * Purpose   : Window Procedure for OUR console frame window
1161 * Parameters: HWND   hwnd - window handle
1162 *             ULONG  msg  - message identifier
1163 *             MPARAM mp1  - message parameter 1
1164 *             MPARAM mp2  - message parameter 2
1165 * Variables :
1166 * Result    : MRESULT for PM
1167 * Remark    :
1168 * Status    :
1169 *
1170 * Author    : Patrick Haller [Tue, 1998/02/10 03:24]
1171 *****************************************************************************/
1172
1173MRESULT EXPENTRY iConsoleFrameWindowProc(HWND   hwnd,
1174                                         ULONG  msg,
1175                                         MPARAM mp1,
1176                                         MPARAM mp2)
1177{
1178  switch(msg)
1179  {
1180    /*************************************************************************
1181     * WM_QUERYTRACKINFO handling                                            *
1182     *************************************************************************/
1183    case WM_QUERYTRACKINFO:
1184    {
1185       MRESULT    mr;                                      /* message result */
1186       PTRACKINFO pTrackInfo;           /* frame window tracking information */
1187
1188                             /* let the original code do the hard work first */
1189       mr = ConsoleGlobals.pfnwpFrameOriginal(hwnd,
1190                                              msg,
1191                                              mp1,
1192                                              mp2);
1193
1194       pTrackInfo = (PTRACKINFO)mp2;                /* get track information */
1195
1196       /* @@@PH */
1197       pTrackInfo->ptlMinTrackSize.x = max(pTrackInfo->ptlMinTrackSize.x, 200);
1198       pTrackInfo->ptlMinTrackSize.y = max(pTrackInfo->ptlMinTrackSize.y, 100);
1199       pTrackInfo->ptlMaxTrackSize.x = min(pTrackInfo->ptlMaxTrackSize.x, ConsoleGlobals.coordMaxWindowPels.X);
1200       pTrackInfo->ptlMaxTrackSize.y = min(pTrackInfo->ptlMaxTrackSize.y, ConsoleGlobals.coordMaxWindowPels.Y);
1201
1202       return (mr);                                        /* deliver result */
1203    }
1204  }
1205
1206                                /* call original frame window procedure code */
1207  return (ConsoleGlobals.pfnwpFrameOriginal(hwnd,
1208                                            msg,
1209                                            mp1,
1210                                            mp2));
1211}
1212
1213
1214/*****************************************************************************
1215 * Name      : static void ConsoleBufferMap
1216 * Purpose   : draw a whole consolebuffer into the VIO space
1217 * Parameters: PCONSOLEBUFFER pConsoleBuffer
1218 * Variables :
1219 * Result    : none
1220 * Remark    :
1221 * Status    :
1222 *
1223 * Author    : Patrick Haller [Tue, 1998/02/17 12:57]
1224 *****************************************************************************/
1225
1226void iConsoleBufferMap(PCONSOLEBUFFER pConsoleBuffer)
1227{
1228  ULONG ulLine;
1229
1230  ULONG ulSizeX;                               /* blitting length and height */
1231  ULONG ulSizeY;
1232
1233  ulSizeX = 2 * min(ConsoleGlobals.coordWindowSize.X,
1234                    pConsoleBuffer->coordBufferSize.X -
1235                    ConsoleGlobals.coordWindowPos.X);
1236
1237  ulSizeY = min(ConsoleGlobals.coordWindowSize.Y,
1238                pConsoleBuffer->coordBufferSize.Y -
1239                ConsoleGlobals.coordWindowPos.Y);
1240
1241                      /* check if we're called with non-existing line buffer */
1242  if (pConsoleBuffer->ppszLine == NULL)
1243    return;
1244
1245  for (ulLine = ConsoleGlobals.coordWindowPos.Y;
1246       ulLine < ulSizeY;
1247       ulLine++)
1248    VioWrtCellStr(pConsoleBuffer->ppszLine[ulLine] +
1249                    ConsoleGlobals.coordWindowPos.X,
1250                  ulSizeX,
1251                  ulLine,
1252                  0,
1253                  ConsoleGlobals.hvpsConsole);
1254}
1255
1256
1257/*****************************************************************************
1258 * Name      : static void ConsoleBufferFillLine
1259 * Purpose   : fills a line with a certain output pattern
1260 * Parameters: ULONG ulPattern, PUSHORT pusTarget, ULONG ulSize
1261 * Variables :
1262 * Result    : none
1263 * Remark    :
1264 * Status    :
1265 *
1266 * Author    : Patrick Haller [Tue, 1998/02/17 12:57]
1267 *****************************************************************************/
1268
1269void iConsoleBufferFillLine(ULONG   ulPattern,
1270                            PUSHORT pusTarget,
1271                            ULONG   ulSize)
1272{
1273  ULONG  ulCounter;
1274
1275  for (ulCounter = 0;
1276       ulCounter < (ulSize >> 1);
1277       ulCounter++,
1278       pusTarget+=2)
1279    *(PULONG)pusTarget = ulPattern;
1280
1281  if (ulSize & 0x00000001)
1282    *pusTarget = (USHORT)ulPattern;
1283}
1284
1285
1286/*****************************************************************************
1287 * Name      : static void ConsoleBufferScrollUp
1288 * Purpose   : scroll whole buffer n lines up,
1289 *             fill new lines with default attribute
1290 * Parameters: PCONSOLEBUFFER pConsoleBuffer
1291 *             ULONG          ulLines
1292 * Variables :
1293 * Result    : none
1294 * Remark    :
1295 * Status    :
1296 *
1297 * Author    : Patrick Haller [Tue, 1998/02/17 12:57]
1298 *****************************************************************************/
1299
1300void iConsoleBufferScrollUp(PCONSOLEBUFFER pConsoleBuffer,
1301                            ULONG          ulLines)
1302{
1303  ULONG ulLine;
1304  ULONG ulPosition;
1305  ULONG ulScrollLine;
1306
1307  static ULONG ulUpdateCounter;                /* counter for jump-scrolling */
1308
1309                              /* calculate new line offset to the first line */
1310  pConsoleBuffer->ulScrollLineOffset += ulLines;
1311  pConsoleBuffer->ulScrollLineOffset %= pConsoleBuffer->coordBufferSize.Y;
1312
1313                                                   /* do we have to scroll ? */
1314  if (ulLines < pConsoleBuffer->coordBufferSize.Y)
1315  {
1316    for (ulLine = 0;                                     /* do the scrolling */
1317         ulLine < ConsoleGlobals.coordWindowSize.Y;
1318         ulLine++)
1319    {
1320      ulScrollLine = (ulLine + pConsoleBuffer->ulScrollLineOffset)
1321                     % pConsoleBuffer->coordBufferSize.Y;
1322
1323      ulPosition = (ULONG)pConsoleBuffer->ppszLine
1324                   + (pConsoleBuffer->coordBufferSize.Y * sizeof (PSZ) )
1325                   + (pConsoleBuffer->coordBufferSize.X * 2 * ulScrollLine);
1326
1327      pConsoleBuffer->ppszLine[ulLine] = (PSZ)ulPosition;
1328    }
1329  }
1330
1331                                                  /* enforce the upper limit */
1332  if (ulLines > pConsoleBuffer->coordBufferSize.Y)
1333    ulLines = pConsoleBuffer->coordBufferSize.Y;
1334
1335  ulPosition = ( ((ULONG)(pConsoleBuffer->ucDefaultAttribute) << 8) +
1336                 ((ULONG)' ') +
1337                 ((ULONG)(pConsoleBuffer->ucDefaultAttribute) << 24) +
1338                 ((ULONG)' ' << 16) );
1339
1340                                                    /* scroll the line index */
1341  for (ulLine = pConsoleBuffer->coordBufferSize.Y - ulLines;
1342       ulLine < pConsoleBuffer->coordBufferSize.Y;
1343       ulLine++)
1344    iConsoleBufferFillLine(ulPosition,
1345                           (PUSHORT)(pConsoleBuffer->ppszLine[ulLine]),
1346                           pConsoleBuffer->coordBufferSize.X);
1347
1348    /* this code ensures frequent screen updating, even if the timer prooves */
1349                                                            /* to be to slow */
1350  ulUpdateCounter++;
1351  if (ulUpdateCounter > ConsoleGlobals.Options.ulUpdateLimit)
1352  {
1353    ulUpdateCounter = 0;                                /* reset the counter */
1354    iConsoleBufferMap(pConsoleBuffer);
1355    VioShowPS(ConsoleGlobals.coordWindowSize.Y,
1356              ConsoleGlobals.coordWindowSize.X,
1357              0,
1358              ConsoleGlobals.hvpsConsole);
1359
1360    ConsoleGlobals.fUpdateRequired = FALSE;          /* no more required ... */
1361  }
1362}
1363
1364
1365/*****************************************************************************
1366 * Name      : static APIRET ConsoleInputEventPush
1367 * Purpose   : add an element to the console input queue
1368 * Parameters: PINPUT_RECORD pInputRecord
1369 * Variables :
1370 * Result    : API returncode
1371 * Remark    :
1372 * Status    :
1373 *
1374 * Author    : Patrick Haller [Tue, 1998/03/07 16:55]
1375 *****************************************************************************/
1376
1377APIRET iConsoleInputEventPush(PINPUT_RECORD pInputRecord)
1378{
1379  PINPUT_RECORD pirFree;                           /* pointer to free record */
1380  APIRET        rc;                                        /* API-returncode */
1381
1382  dprintf2(("KERNEL32/CONSOLE:ConsoleInputEventPush(%08x).\n",
1383           pInputRecord));
1384
1385  iConsoleInputQueueLock();
1386                                                           /* get free event */
1387  pirFree = &ConsoleInput.arrInputRecord[ConsoleInput.ulIndexFree];
1388  if (pirFree->EventType != 0x0000)
1389  {
1390    iConsoleInputQueueUnlock();
1391    return (ERROR_QUE_NO_MEMORY);                         /* queue is full ! */
1392  }
1393                                                       /* put event in queue */
1394
1395  ConsoleInput.ulIndexFree++;                        /* update index counter */
1396  if (ConsoleInput.ulIndexFree >= CONSOLE_INPUTQUEUESIZE)
1397    ConsoleInput.ulIndexFree = 0;
1398
1399  ConsoleInput.ulEvents++;                   /* increate queue event counter */
1400
1401  iConsoleInputQueueUnlock();
1402
1403  memcpy(pirFree,                                               /* copy data */
1404         pInputRecord,
1405         sizeof (INPUT_RECORD) );
1406
1407  if(flVioConsole == FALSE)
1408  {     /* unblock reading threads */
1409        rc = DosPostEventSem(ConsoleInput.hevInputQueue);
1410  }
1411  else  rc = 0;
1412  return (rc);                                                         /* OK */
1413}
1414
1415
1416/*****************************************************************************
1417 * Name      : static APIRET ConsoleInputEventPop
1418 * Purpose   : read first element from the console input queue
1419 * Parameters: PINPUT_RECORD pInputRecord
1420 * Variables :
1421 * Result    : API returncode
1422 * Remark    :
1423 * Status    :
1424 *
1425 * Author    : Patrick Haller [Tue, 1998/03/07 16:55]
1426 *****************************************************************************/
1427
1428APIRET iConsoleInputEventPop(PINPUT_RECORD pInputRecord)
1429{
1430  PINPUT_RECORD pirEvent;                         /* pointer to event record */
1431  APIRET        rc;                                        /* API-returncode */
1432
1433  dprintf2(("KERNEL32/CONSOLE:ConsoleInputEventPop(%08x).\n",
1434           pInputRecord));
1435
1436  if (ConsoleInput.ulEvents == 0)                         /* empty console ? */
1437    return (ERROR_QUE_EMPTY);                            /* queue is empty ! */
1438
1439  iConsoleInputQueueLock();
1440                                                          /* get first event */
1441  pirEvent = &ConsoleInput.arrInputRecord[ConsoleInput.ulIndexEvent];
1442  if (pirEvent->EventType == 0x0000)
1443  {
1444    iConsoleInputQueueUnlock();
1445    return (ERROR_QUE_EMPTY);                            /* queue is empty ! */
1446  }
1447
1448  if (ConsoleInput.ulEvents >= 0)       /* decrease number of console events */
1449    ConsoleInput.ulEvents--;
1450
1451  ConsoleInput.ulIndexEvent++;                       /* update index counter */
1452  if (ConsoleInput.ulIndexEvent >= CONSOLE_INPUTQUEUESIZE)
1453    ConsoleInput.ulIndexEvent = 0;
1454
1455                                                       /* put event in queue */
1456  memcpy(pInputRecord,                                          /* copy data */
1457         pirEvent,
1458         sizeof (INPUT_RECORD) );
1459
1460  pirEvent->EventType = 0x0000;                 /* mark event as read = free */
1461
1462  iConsoleInputQueueUnlock();
1463
1464  return (NO_ERROR);                                                   /* OK */
1465}
1466
1467
1468/*****************************************************************************
1469 * Name      : static APIRET ConsoleInputEventPushKey
1470 * Purpose   : push key event into the queue
1471 * Parameters: MPARAM mp1, MPARAM mp2 from WM_CHAR processing
1472 * Variables :
1473 * Result    : API returncode
1474 * Remark    : @@@PH: 2nd table that learns codes automatically from "down"
1475 *                    messages from PM. With Alt-a, etc. it is 0 for "up" ?
1476 * Status    :
1477 *
1478 * Author    : Patrick Haller [Tue, 1998/03/07 16:55]
1479 *****************************************************************************/
1480
1481char tabVirtualKeyCodes[TABVIRTUALKEYCODES] =
1482{
1483/* --- PM key -- NT key --- */
1484   /*              0x00 */ 0,
1485   /* VK_BUTTON1   0x01 */ 0x01, /* WIN_VK_LBUTTON ??? */
1486   /* VK_BUTTON2   0x02 */ 0x02, /* WIN_VK_RBUTTON ??? */
1487   /* VK_BUTTON3   0x03 */ 0x04, /* WIN_VK_MBUTTON ??? */
1488   /* VK_BREAK     0x04 */ 0x03, /* WIN_VK_CANCEL  ??? */
1489   /* VK_BACKSPACE 0x05 */ 0x08, /* WIN_VK_BACK    */
1490   /* VK_TAB       0x06 */ 0x09, /* WIN_VK_TAB     */
1491   /* VK_BACKTAB   0x07 */ 0,
1492   /* VK_NEWLINE   0x08 */ 0,
1493   /* VK_SHIFT     0x09 */ 0x10, /* WIN_VK_SHIFT   */
1494   /* VK_CTRL      0x0A */ 0x11, /* WIN_VK_CONTROL */
1495   /* VK_ALT       0x0B */ 0x12, /* WIN_VK_MENU    */
1496   /* VK_ALTGRAF   0x0C */ 0,
1497   /* VK_PAUSE     0x0D */ 0x13, /* WIN_VK_PAUSE   */
1498   /* VK_CAPSLOCK  0x0E */ 0x14, /* WIN_VK_CAPITAL ??? */
1499   /* VK_ESC       0x0F */ 0x1b, /* WIN_VK_ESCAPE  */
1500   /* VK_SPACE     0x10 */ 0x20, /* WIN_VK_SPACE   */
1501   /* VK_PAGEUP    0x11 */ 0x21, /* WIN_VK_PRIOR   ??? */
1502   /* VK_PAGEDOWN  0x12 */ 0x22, /* WIN_VK_NEXT    ??? */
1503   /* VK_END       0x13 */ 0x23, /* WIN_VK_END     */
1504   /* VK_HOME      0x14 */ 0x24, /* WIN_VK_HOME    */
1505   /* VK_LEFT      0x15 */ 0x25, /* WIN_VK_LEFT    */
1506   /* VK_UP        0x16 */ 0x26, /* WIN_VK_UP      */
1507   /* VK_RIGHT     0x17 */ 0x27, /* WIN_VK_RIGHT   */
1508   /* VK_DOWN      0x18 */ 0x28, /* WIN_VK_DOWN    */
1509   /* VK_PRINTSCRN 0x19 */ 0x2A, /* WIN_VK_PRINT   */
1510   /* VK_INSERT    0x1A */ 0x2D, /* WIN_VK_INSERT  */
1511   /* VK_DELETE    0x1B */ 0x2E, /* WIN_VK_DELETE  */
1512   /* VK_SCRLLOCK  0x1C */ 0x91, /* WIN_VK_SCROLL  */
1513   /* VK_NUMLOCK   0x1D */ 0x90, /* WIN_VK_NUMLOCK */
1514   /* VK_ENTER     0x1E */ 0x0D, /* WIN_VK_RETURN  */
1515   /* VK_SYSRQ     0x1F */ 0,
1516   /* VK_F1        0x20 */ 0x70, /* WIN_VK_F1      */
1517   /* VK_F2        0x21 */ 0x71, /* WIN_VK_F2      */
1518   /* VK_F3        0x22 */ 0x72, /* WIN_VK_F3      */
1519   /* VK_F4        0x23 */ 0x73, /* WIN_VK_F4      */
1520   /* VK_F5        0x24 */ 0x74, /* WIN_VK_F5      */
1521   /* VK_F6        0x25 */ 0x75, /* WIN_VK_F6      */
1522   /* VK_F7        0x26 */ 0x76, /* WIN_VK_F7      */
1523   /* VK_F8        0x27 */ 0x77, /* WIN_VK_F8      */
1524   /* VK_F9        0x28 */ 0x78, /* WIN_VK_F9      */
1525   /* VK_F10       0x29 */ 0x79, /* WIN_VK_F10     */
1526   /* VK_F11       0x2A */ 0x7A, /* WIN_VK_F11     */
1527   /* VK_F12       0x2B */ 0x7B, /* WIN_VK_F12     */
1528   /* VK_F13       0x2C */ 0x7C, /* WIN_VK_F13     */
1529   /* VK_F14       0x2D */ 0x7D, /* WIN_VK_F14     */
1530   /* VK_F15       0x2E */ 0x7E, /* WIN_VK_F15     */
1531   /* VK_F16       0x2F */ 0x7F, /* WIN_VK_F16     */
1532   /* VK_F17       0x30 */ 0x80, /* WIN_VK_F17     */
1533   /* VK_F18       0x31 */ 0x81, /* WIN_VK_F18     */
1534   /* VK_F19       0x32 */ 0x82, /* WIN_VK_F19     */
1535   /* VK_F20       0x33 */ 0x83, /* WIN_VK_F20     */
1536   /* VK_F21       0x34 */ 0x84, /* WIN_VK_F21     */
1537   /* VK_F22       0x35 */ 0x85, /* WIN_VK_F22     */
1538   /* VK_F23       0x36 */ 0x86, /* WIN_VK_F23     */
1539   /* VK_F24       0x37 */ 0x87, /* WIN_VK_F24     */
1540   /* VK_ENDDRAG   0x38 */ 0,
1541   /* VK_CLEAR     0x39 */ 0x0C, /* WIN_VK_CLEAR   */
1542   /* VK_EREOF     0x3A */ 0xF9, /* WIN_VK_EREOF   */
1543   /* VK_PA1       0x3B */ 0xFD, /* WIN_VK_PA1     */
1544   /* VK_ATTN      0x3C */ 0xF6, /* WIN_VK_ATTN    */
1545   /* VK_CRSEL     0x3D */ 0xF7, /* WIN_VK_CRSEL   */
1546   /* VK_EXSEL     0x3E */ 0xF8, /* WIN_VK_EXSEL   */
1547   /* VK_COPY      0x3F */ 0,
1548   /* VK_BLK1      0x40 */ 0,
1549   /* VK_BLK2      0x41 */ 0,
1550   /*              0x42 */ 0,
1551   /*              0x43 */ 0,
1552   /*              0x44 */ 0,
1553   /*              0x45 */ 0,
1554   /*              0x46 */ 0,
1555   /*              0x47 */ 0,
1556   /*              0x48 */ 0,
1557   /*              0x49 */ 0,
1558   /*              0x4A */ 0,
1559   /*              0x4B */ 0,
1560   /*              0x4C */ 0,
1561   /*              0x4D */ 0,
1562   /*              0x4E */ 0,
1563   /*              0x4F */ 0,
1564   /* from UNIKBD.H:             */
1565   /* VK_PA2              0x0050 */ 0,
1566   /* VK_PA3              0x0051 */ 0,
1567   /* VK_GROUP            0x0052 */ 0,
1568   /* VK_GROUPLOCK        0x0053 */ 0,
1569   /* VK_APPL             0x0054 */ 0x5D, /* WIN_VK_APPS ??? */
1570   /* VK_WINLEFT          0x0055 */ 0x5B, /* WIN_VK_LWIN */
1571   /* VK_WINRIGHT         0x0056 */ 0x5C, /* WIN_VK_RWIN */
1572   /*                     0x0057 */ 0,
1573   /*                     0x0058 */ 0,
1574   /*                     0x0059 */ 0,
1575   /*                     0x005A */ 0,
1576   /*                     0x005B */ 0,
1577   /*                     0x005C */ 0,
1578   /*                     0x005D */ 0,
1579   /*                     0x005E */ 0,
1580   /*                     0x005F */ 0,
1581   /*                     0x0060 */ 0,
1582   /* VK_M_DOWNLEFT       0x0061 */ 0,
1583   /* VK_M_DOWN           0x0062 */ 0,
1584   /* VK_M_DOWNRIGHT      0x0063 */ 0,
1585   /* VK_M_LEFT           0x0064 */ 0,
1586   /* VK_M_CENTER         0x0065 */ 0,
1587   /* VK_M_RIGHT          0x0066 */ 0,
1588   /* VK_M_UPLEFT         0x0067 */ 0,
1589   /* VK_M_UP             0x0068 */ 0,
1590   /* VK_M_UPRIGHT        0x0069 */ 0,
1591   /* VK_M_BUTTONLOCK     0x006A */ 0,
1592   /* VK_M_BUTTONRELEASE  0x006B */ 0,
1593   /* VK_M_DOUBLECLICK    0x006C */ 0,
1594
1595#if 0
15960xA4, /* WIN_VK_LMENU   ??? */
15970xA5, /* WIN_VK_RMENU   ??? */
1598#define VK_SELECT         0x29
1599#define VK_EXECUTE        0x2B
1600#define VK_SNAPSHOT       0x2C
1601#define VK_HELP           0x2F
1602#define VK_NUMPAD0        0x60
1603#define VK_NUMPAD1        0x61
1604#define VK_NUMPAD2        0x62
1605#define VK_NUMPAD3        0x63
1606#define VK_NUMPAD4        0x64
1607#define VK_NUMPAD5        0x65
1608#define VK_NUMPAD6        0x66
1609#define VK_NUMPAD7        0x67
1610#define VK_NUMPAD8        0x68
1611#define VK_NUMPAD9        0x69
1612#define VK_MULTIPLY       0x6A
1613#define VK_ADD            0x6B
1614#define VK_SEPARATOR      0x6C
1615#define VK_SUBTRACT       0x6D
1616#define VK_DECIMAL        0x6E
1617#define VK_DIVIDE         0x6F
1618#define VK_LSHIFT         0xA0
1619#define VK_RSHIFT         0xA1
1620#define VK_LCONTROL       0xA2
1621#define VK_RCONTROL       0xA3
1622#define VK_PROCESSKEY     0xE5
1623#define VK_PLAY           0xFA
1624#define VK_ZOOM           0xFB
1625#define VK_NONAME         0xFC
1626#define VK_OEM_CLEAR      0xFE
1627#endif
1628
1629};
1630
1631
1632APIRET iConsoleInputEventPushKey(MPARAM mp1,
1633                                 MPARAM mp2)
1634{
1635  INPUT_RECORD InputRecord;                    /* the input record structure */
1636  APIRET       rc;                                         /* API-returncode */
1637  USHORT       fsFlags    = ((ULONG)mp1 & 0x0000ffff);             /* get key flags */
1638  UCHAR        ucRepeat   = ((ULONG)mp1 & 0x00ff0000) >> 16;
1639  UCHAR        ucScanCode = ((ULONG)mp1 & 0xff000000) >> 24;
1640  UCHAR        usCh       = ((ULONG)mp2 & 0x0000ffff);
1641  USHORT       usVk       = ((ULONG)mp2 & 0xffff0000) >> 16;
1642  UCHAR        ucChar     = usCh & 0x00ff;
1643
1644  dprintf2(("KERNEL32/CONSOLE:ConsoleInputEventPushKey(%08x,%08x).\n",
1645           mp1,
1646           mp2));
1647
1648
1649  InputRecord.EventType = KEY_EVENT;                 /* fill event structure */
1650  InputRecord.Event.KeyEvent.dwControlKeyState = 0;
1651
1652  if (fsFlags & KC_SHIFT) InputRecord.Event.KeyEvent.dwControlKeyState |= SHIFT_PRESSED;
1653  if (fsFlags & KC_ALT)   InputRecord.Event.KeyEvent.dwControlKeyState |= LEFT_ALT_PRESSED;
1654  if (fsFlags & KC_CTRL)  InputRecord.Event.KeyEvent.dwControlKeyState |= LEFT_CTRL_PRESSED;
1655
1656  /* @@@PH no support for RIGHT_ALT_PRESSED,
1657                          RIGHT_CTRL_PRESSED,
1658                          NUMLOCK_ON,
1659                          SCROLLLOCK_ON,
1660                          CAPSLOCK_ON,
1661                          ENHANCED_KEY
1662   */
1663
1664  InputRecord.Event.KeyEvent.bKeyDown         = !(fsFlags & KC_KEYUP);
1665  InputRecord.Event.KeyEvent.wRepeatCount     = ucRepeat;
1666  InputRecord.Event.KeyEvent.wVirtualKeyCode  = usVk;
1667  InputRecord.Event.KeyEvent.wVirtualScanCode = ucScanCode;
1668
1669             /* check if ascii is valid, if so then wVirtualKeyCode = ascii, */
1670             /* else go through the table                                    */
1671  if (fsFlags & KC_CHAR) /* usCh valid ? */
1672  {
1673          /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
1674          /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
1675    if ( ( (usCh >= 'a') && (usCh <= 'z') ) ||                /* lowercase ? */
1676         ( (usCh >= '0') && (usCh <= '9') )
1677       )
1678      InputRecord.Event.KeyEvent.wVirtualKeyCode = usCh & 0xDF;
1679    else
1680      InputRecord.Event.KeyEvent.wVirtualKeyCode = usCh;
1681  }
1682  else
1683    if (fsFlags & KC_VIRTUALKEY)          /* translate OS/2 virtual key code */
1684    {
1685      if (usVk < TABVIRTUALKEYCODES)                  /* limit to table size */
1686        InputRecord.Event.KeyEvent.wVirtualKeyCode =
1687          tabVirtualKeyCodes[usVk];                     /* translate keycode */
1688    }
1689
1690                /* this is a workaround for empty / invalid wVirtualKeyCodes */
1691  if (InputRecord.Event.KeyEvent.wVirtualKeyCode == 0x0000)
1692  {
1693    if ( ( (usCh >= 'a') && (usCh <= 'z') ) ||                /* lowercase ? */
1694         ( (usCh >= '0') && (usCh <= '9') )
1695       )
1696      InputRecord.Event.KeyEvent.wVirtualKeyCode = usCh & 0xDF;
1697    else
1698      InputRecord.Event.KeyEvent.wVirtualKeyCode = usCh;
1699  }
1700
1701
1702  /* @@@PH handle special keys */
1703  if ( (ucChar != 0xe0) && (ucChar != 0x00) )
1704    InputRecord.Event.KeyEvent.uChar.AsciiChar  = ucChar;
1705  else
1706  {
1707    /* extended key ! */
1708    InputRecord.Event.KeyEvent.dwControlKeyState |= ENHANCED_KEY;
1709    InputRecord.Event.KeyEvent.uChar.AsciiChar  = (ucChar >> 8);
1710  }
1711
1712              /* further processing according the current input console mode */
1713  if (ConsoleInput.dwConsoleMode & ENABLE_PROCESSED_INPUT)
1714  {
1715    /* filter ctrl-c, etc. */
1716  }
1717
1718#if 0
1719  /* DEBUG */
1720  dprintf(("DEBUG: mp1=%08x mp2=%08x\n",
1721           mp1,
1722           mp2));
1723  dprintf(("DEBUG: fsFlags = %04x repeat=%u hwscan=%2x",
1724           fsFlags,
1725           ucRepeat,
1726           ucScanCode ));
1727  dprintf((" uscc=%04x usvk=%04x\n",
1728           SHORT1FROMMP(mp2),
1729           SHORT2FROMMP(mp2)));
1730
1731  dprintf(("DEBUG: ascii=[%c] (%02x)",
1732           InputRecord.Event.KeyEvent.uChar.AsciiChar,
1733           InputRecord.Event.KeyEvent.uChar.AsciiChar));
1734#endif
1735
1736  rc = iConsoleInputEventPush(&InputRecord);          /* add it to the queue */
1737  return (rc);                                                         /* OK */
1738}
1739
1740
1741/*****************************************************************************
1742 * Name      : static APIRET ConsoleInputEventPushMouse
1743 * Purpose   : push mouse event into the queue
1744 * Parameters: MPARAM mp1, MPARAM mp2 from WM_MOUSEMOVE processing
1745 * Variables :
1746 * Result    : API returncode
1747 * Remark    :
1748 * Status    :
1749 *
1750 * Author    : Patrick Haller [Tue, 1998/03/07 16:55]
1751 *****************************************************************************/
1752
1753APIRET iConsoleInputEventPushMouse(ULONG  ulMessage,
1754                                   MPARAM mp1,
1755                                   MPARAM mp2)
1756{
1757  INPUT_RECORD     InputRecord;                /* the input record structure */
1758  APIRET             rc;                                   /* API-returncode */
1759  USHORT             fsFlags = SHORT2FROMMP(mp2);           /* get key flags */
1760  static USHORT      usButtonState;     /* keeps track of mouse button state */
1761
1762                                      /* do we have to process mouse input ? */
1763  if ( !(ConsoleInput.dwConsoleMode & ENABLE_MOUSE_INPUT))
1764    return (NO_ERROR);                                 /* return immediately */
1765
1766  dprintf2(("KERNEL32/CONSOLE:ConsoleInputEventPushMouse(%08x,%08x,%08x).\n",
1767           ulMessage,
1768           mp1,
1769           mp2));
1770
1771  memset(&InputRecord,                                 /* zero the structure */
1772         0,
1773         sizeof (INPUT_RECORD) );
1774
1775  InputRecord.EventType = MOUSE_EVENT;               /* fill event structure */
1776
1777  switch (ulMessage)
1778  {
1779    case WM_MOUSEMOVE:
1780      InputRecord.Event.MouseEvent.dwEventFlags      = MOUSE_MOVED;
1781      InputRecord.Event.MouseEvent.dwMousePosition.X = SHORT1FROMMP(mp1);
1782      InputRecord.Event.MouseEvent.dwMousePosition.Y = SHORT2FROMMP(mp1);
1783
1784      InputRecord.Event.MouseEvent.dwButtonState     = usButtonState;
1785
1786      if (fsFlags & KC_SHIFT) InputRecord.Event.MouseEvent.dwControlKeyState |= SHIFT_PRESSED;
1787      if (fsFlags & KC_ALT)   InputRecord.Event.MouseEvent.dwControlKeyState |= LEFT_ALT_PRESSED;
1788      if (fsFlags & KC_CTRL)  InputRecord.Event.MouseEvent.dwControlKeyState |= LEFT_CTRL_PRESSED;
1789
1790      /* @@@PH no support for RIGHT_ALT_PRESSED,
1791                              RIGHT_CTRL_PRESSED,
1792                              NUMLOCK_ON,
1793                              SCROLLLOCK_ON,
1794                              CAPSLOCK_ON,
1795                              ENHANCED_KEY
1796       */
1797      break;
1798
1799    case WM_BUTTON1UP:
1800      usButtonState            &= ~FROM_LEFT_1ST_BUTTON_PRESSED;
1801      InputRecord.Event.MouseEvent.dwButtonState = usButtonState;
1802      break;
1803
1804    case WM_BUTTON1DOWN:
1805      usButtonState            |=  FROM_LEFT_1ST_BUTTON_PRESSED;
1806      InputRecord.Event.MouseEvent.dwButtonState = usButtonState;
1807      break;
1808
1809    case WM_BUTTON2UP:
1810      usButtonState &= ~FROM_LEFT_2ND_BUTTON_PRESSED;
1811      InputRecord.Event.MouseEvent.dwButtonState = usButtonState;
1812      break;
1813
1814    case WM_BUTTON2DOWN:
1815      usButtonState |= FROM_LEFT_2ND_BUTTON_PRESSED;
1816      InputRecord.Event.MouseEvent.dwButtonState = usButtonState;
1817      break;
1818
1819    case WM_BUTTON3UP:
1820      usButtonState &= ~FROM_LEFT_3RD_BUTTON_PRESSED;
1821      InputRecord.Event.MouseEvent.dwButtonState = usButtonState;
1822      break;
1823
1824    case WM_BUTTON3DOWN:
1825      usButtonState |=  FROM_LEFT_3RD_BUTTON_PRESSED;
1826      InputRecord.Event.MouseEvent.dwButtonState = usButtonState;
1827      break;
1828
1829    case WM_BUTTON1DBLCLK:
1830      InputRecord.Event.MouseEvent.dwEventFlags = DOUBLE_CLICK;
1831      InputRecord.Event.MouseEvent.dwButtonState = FROM_LEFT_1ST_BUTTON_PRESSED;
1832      usButtonState &= ~FROM_LEFT_1ST_BUTTON_PRESSED;
1833      break;
1834
1835    case WM_BUTTON2DBLCLK:
1836      InputRecord.Event.MouseEvent.dwEventFlags = DOUBLE_CLICK;
1837      InputRecord.Event.MouseEvent.dwButtonState = FROM_LEFT_2ND_BUTTON_PRESSED;
1838      usButtonState &= ~FROM_LEFT_2ND_BUTTON_PRESSED;
1839      break;
1840
1841    case WM_BUTTON3DBLCLK:
1842      InputRecord.Event.MouseEvent.dwEventFlags = DOUBLE_CLICK;
1843      InputRecord.Event.MouseEvent.dwButtonState = FROM_LEFT_3RD_BUTTON_PRESSED;
1844      usButtonState &= ~FROM_LEFT_3RD_BUTTON_PRESSED;
1845      break;
1846  }
1847
1848                        /* @@@PH pseudo-support for RIGHTMOST_BUTTON_PRESSED */
1849  if (InputRecord.Event.MouseEvent.dwButtonState & FROM_LEFT_3RD_BUTTON_PRESSED)
1850    InputRecord.Event.MouseEvent.dwButtonState |= RIGHTMOST_BUTTON_PRESSED;
1851
1852  rc = iConsoleInputEventPush(&InputRecord);          /* add it to the queue */
1853  return (rc);                                                         /* OK */
1854}
1855
1856
1857/*****************************************************************************
1858 * Name      : static APIRET ConsoleInputEventPushWindow
1859 * Purpose   : push menu event into the queue
1860 * Parameters: DWORD dwCommandId
1861 * Variables :
1862 * Result    : API returncode
1863 * Remark    :
1864 * Status    :
1865 *
1866 * Author    : Patrick Haller [Tue, 1998/03/07 16:55]
1867 *****************************************************************************/
1868
1869APIRET iConsoleInputEventPushWindow(COORD coordWindowSize)
1870{
1871  INPUT_RECORD     InputRecord;                /* the input record structure */
1872  APIRET           rc;                                     /* API-returncode */
1873
1874                                     /* do we have to process window input ? */
1875  if ( !(ConsoleInput.dwConsoleMode & ENABLE_WINDOW_INPUT))
1876    return (NO_ERROR);                                 /* return immediately */
1877
1878  dprintf2(("KERNEL32/CONSOLE:ConsoleInputEventPushWindow(x = %u, y = %u).\n",
1879           coordWindowSize.X,
1880           coordWindowSize.Y));
1881
1882  InputRecord.EventType = WINDOW_BUFFER_SIZE_EVENT;  /* fill event structure */
1883
1884  InputRecord.Event.WindowBufferSizeEvent.dwSize = coordWindowSize;
1885
1886  rc = iConsoleInputEventPush(&InputRecord);          /* add it to the queue */
1887  return (rc);                                                         /* OK */
1888}
1889
1890
1891/*****************************************************************************
1892 * Name      : static APIRET ConsoleInputEventPushMenu
1893 * Purpose   : push window event into the queue
1894 * Parameters: COORD coordWindowSize
1895 * Variables :
1896 * Result    : API returncode
1897 * Remark    :
1898 * Status    :
1899 *
1900 * Author    : Patrick Haller [Tue, 1998/03/07 16:55]
1901 *****************************************************************************/
1902
1903APIRET iConsoleInputEventPushMenu(DWORD dwCommandId)
1904{
1905  INPUT_RECORD     InputRecord;                /* the input record structure */
1906  APIRET           rc;                                     /* API-returncode */
1907
1908  /* @@@PH this is unknown to me - there's no separate bit for menu events ? */
1909                                     /* do we have to process window input ? */
1910  if ( !(ConsoleInput.dwConsoleMode & ENABLE_WINDOW_INPUT))
1911    return (NO_ERROR);                                 /* return immediately */
1912
1913  dprintf2(("KERNEL32/CONSOLE:ConsoleInputEventPushMenu(%08x).\n",
1914           dwCommandId));
1915
1916  InputRecord.EventType = MENU_EVENT;                /* fill event structure */
1917
1918  InputRecord.Event.MenuEvent.dwCommandId = dwCommandId;
1919
1920  rc = iConsoleInputEventPush(&InputRecord);          /* add it to the queue */
1921  return (rc);                                                         /* OK */
1922}
1923
1924
1925/*****************************************************************************
1926 * Name      : static APIRET ConsoleInputEventPushFocus
1927 * Purpose   : push focus event into the queue
1928 * Parameters: BOOL bSetFocus
1929 * Variables :
1930 * Result    : API returncode
1931 * Remark    :
1932 * Status    :
1933 *
1934 * Author    : Patrick Haller [Tue, 1998/03/07 16:55]
1935 *****************************************************************************/
1936
1937APIRET iConsoleInputEventPushFocus(BOOL bSetFocus)
1938{
1939  INPUT_RECORD     InputRecord;                /* the input record structure */
1940  APIRET           rc;                                     /* API-returncode */
1941
1942  /* @@@PH this is unknown to me - there's no separate bit for menu events ? */
1943                                     /* do we have to process window input ? */
1944  if ( !(ConsoleInput.dwConsoleMode & ENABLE_WINDOW_INPUT))
1945    return (NO_ERROR);                                 /* return immediately */
1946
1947  dprintf2(("KERNEL32/CONSOLE:ConsoleInputEventPushFocus(%08x).\n",
1948           bSetFocus));
1949
1950  InputRecord.EventType = FOCUS_EVENT;               /* fill event structure */
1951
1952  InputRecord.Event.FocusEvent.bSetFocus = bSetFocus;
1953
1954  rc = iConsoleInputEventPush(&InputRecord);          /* add it to the queue */
1955  return (rc);                                                         /* OK */
1956}
1957
1958
1959/*****************************************************************************
1960 * Name      : static ULONG ConsoleInputQueueEvents
1961 * Purpose   : query number of events in the queue
1962 * Parameters:
1963 * Variables :
1964 * Result    : number of events
1965 * Remark    :
1966 * Status    :
1967 *
1968 * Author    : Patrick Haller [Tue, 1998/03/07 16:55]
1969 *****************************************************************************/
1970
1971ULONG iConsoleInputQueryEvents(PICONSOLEINPUT pConsoleInput, int fWait)
1972{
1973 ULONG ulPostCounter;                   /* semaphore post counter - ignored */
1974 APIRET rc;                                               /* API returncode */
1975
1976  if(flVioConsole)
1977  {
1978    KBDKEYINFO keyinfo;
1979
1980        rc = KbdCharIn(&keyinfo, IO_NOWAIT, 0); //grab key if present; don't wait
1981        if((rc || !(keyinfo.fbStatus & 0x40)) && fWait == QUERY_EVENT_WAIT && ConsoleInput.ulEvents == 0) {
1982                rc = KbdCharIn(&keyinfo, IO_WAIT, 0);
1983        }
1984        while(rc == 0 && (keyinfo.fbStatus & 0x40))
1985        {
1986                INPUT_RECORD InputRecord = {0};
1987
1988                InputRecord.EventType = KEY_EVENT;
1989                InputRecord.Event.KeyEvent.wRepeatCount = 1;
1990                InputRecord.Event.KeyEvent.bKeyDown     = 1;
1991                InputRecord.Event.KeyEvent.dwControlKeyState = 0;
1992
1993                if(keyinfo.fbStatus & 2)
1994                        InputRecord.Event.KeyEvent.dwControlKeyState |= ENHANCED_KEY;
1995
1996                if(keyinfo.fsState & (KBDSTF_RIGHTSHIFT|KBDSTF_LEFTSHIFT))
1997                        InputRecord.Event.KeyEvent.dwControlKeyState |= SHIFT_PRESSED;
1998
1999                if(keyinfo.fsState & KBDSTF_LEFTALT)
2000                        InputRecord.Event.KeyEvent.dwControlKeyState |= LEFT_ALT_PRESSED;
2001
2002                if(keyinfo.fsState & KBDSTF_RIGHTALT)
2003                        InputRecord.Event.KeyEvent.dwControlKeyState |= RIGHT_ALT_PRESSED;
2004
2005                if(keyinfo.fsState & KBDSTF_LEFTCONTROL)
2006                    InputRecord.Event.KeyEvent.dwControlKeyState |= LEFT_CTRL_PRESSED;
2007
2008                if(keyinfo.fsState & KBDSTF_RIGHTCONTROL)
2009                    InputRecord.Event.KeyEvent.dwControlKeyState |= RIGHT_CTRL_PRESSED;
2010
2011                if(keyinfo.fsState & KBDSTF_CAPSLOCK_ON)
2012                    InputRecord.Event.KeyEvent.dwControlKeyState |= CAPSLOCK_ON;
2013
2014                if(keyinfo.fsState & KBDSTF_SCROLLLOCK_ON)
2015                    InputRecord.Event.KeyEvent.dwControlKeyState |= SCROLLLOCK_ON;
2016
2017                if(keyinfo.fsState & KBDSTF_NUMLOCK_ON)
2018                    InputRecord.Event.KeyEvent.dwControlKeyState |= NUMLOCK_ON;
2019
2020                InputRecord.Event.KeyEvent.wVirtualKeyCode  = 0;
2021                InputRecord.Event.KeyEvent.wVirtualScanCode = keyinfo.chScan;
2022                InputRecord.Event.KeyEvent.uChar.AsciiChar  = keyinfo.chChar;
2023
2024                rc = iConsoleInputEventPush(&InputRecord);          /* add it to the queue */
2025                if(rc) {
2026                    dprintf(("WARNING: lost key!!"));
2027                    break;
2028                }
2029
2030                rc = KbdCharIn(&keyinfo, IO_NOWAIT, 0); //grab key if present; don't wait
2031        }
2032  }
2033  else
2034  if(fWait == QUERY_EVENT_WAIT && ConsoleInput.ulEvents == 0)
2035  {
2036        rc = DosWaitEventSem(pConsoleInput->hevInputQueue,      /* wait for input */
2037                             SEM_INDEFINITE_WAIT);
2038        DosResetEventSem(pConsoleInput->hevInputQueue,         /* reset semaphore */
2039                         &ulPostCounter);              /* post counter - ignored */
2040  }
2041  return (ConsoleInput.ulEvents);        /* return number of events in queue */
2042}
2043
2044
2045/*****************************************************************************
2046 * Name      : static void ConsoleCursorShow
2047 * Purpose   : query number of events in the queue
2048 * Parameters:
2049 * Variables :
2050 * Result    : number of events
2051 * Remark    :
2052 * Status    :
2053 *
2054 * Author    : Patrick Haller [Tue, 1998/03/07 16:55]
2055 *****************************************************************************/
2056
2057void iConsoleCursorShow (PCONSOLEBUFFER pConsoleBuffer,
2058                         ULONG          ulCursorMode)
2059{
2060  HPS   hps;                                    /* presentation space handle */
2061  RECTL rclCursor;                                   /* the cursor rectangle */
2062  static BOOL fState;                                /* current cursor state */
2063  RECTL rclWindow;                                    /* current window size */
2064
2065  dprintf2(("KERNEL32:Console:ConsoleCursorShow(%u)\n",
2066           ulCursorMode));
2067
2068  if (pConsoleBuffer->CursorInfo.bVisible == FALSE)/* cursor is switched off */
2069    return;                                            /* return immediately */
2070
2071  switch (ulCursorMode)
2072  {
2073    case CONSOLECURSOR_HIDE:
2074      if (fState == FALSE)                       /* cursor currently shown ? */
2075        return;                                     /* no, abort immediately */
2076      else
2077        fState = FALSE;       /* set to invisible and invert our cursor rect */
2078      break;
2079
2080    case CONSOLECURSOR_SHOW:
2081      if (fState == TRUE)                        /* cursor currently shown ? */
2082        return;                                     /* yes,abort immediately */
2083      else
2084        fState = TRUE;          /* set to visible and invert our cursor rect */
2085      break;
2086
2087    case CONSOLECURSOR_BLINK:
2088      fState = !fState;      /* let there be on off on off on off on off ... */
2089      break;
2090
2091    case CONSOLECURSOR_OVERWRITTEN:       /* our cursor has been overwritten */
2092      fState = TRUE;                       /* so show the cursor immediately */
2093      break;
2094  }
2095
2096
2097                                              /* query current window's size */
2098  WinQueryWindowRect(ConsoleGlobals.hwndClient,
2099                     &rclWindow);
2100
2101                                      /* calculate coordinates of the cursor */
2102  rclCursor.xLeft   = ConsoleGlobals.sCellCX * pConsoleBuffer->coordCursorPosition.X;
2103  rclCursor.xRight  = rclCursor.xLeft + ConsoleGlobals.sCellCX;
2104
2105  //@@@PH top calculation is wrong!
2106  rclCursor.yBottom = rclWindow.yTop
2107                      - ConsoleGlobals.sCellCY * (pConsoleBuffer->coordCursorPosition.Y + 1);
2108  rclCursor.yTop    = rclCursor.yBottom +        /* cursor height in percent */
2109                      (ConsoleGlobals.sCellCY *
2110                       pConsoleBuffer->CursorInfo.dwSize /
2111                       100);
2112
2113  hps = WinGetPS(ConsoleGlobals.hwndClient);                      /* get HPS */
2114
2115  /* @@@PH invert coordinates here ... */
2116  WinInvertRect(hps,                  /* our cursor is an inverted rectangle */
2117                &rclCursor);
2118
2119  WinReleasePS(hps);                                /* release the hps again */
2120}
2121
2122
2123/*****************************************************************************
2124 * Name      : static APIRET ConsoleFontQuery
2125 * Purpose   : queries the current font cell sizes
2126 * Parameters:
2127 * Variables :
2128 * Result    : API returncode
2129 * Remark    :
2130 * Status    :
2131 *
2132 * Author    : Patrick Haller [Tue, 1998/03/07 16:55]
2133 *****************************************************************************/
2134
2135APIRET iConsoleFontQuery (void)
2136{
2137  return(VioGetDeviceCellSize(&ConsoleGlobals.sCellCY,  /* query VIO manager */
2138                              &ConsoleGlobals.sCellCX,
2139                              ConsoleGlobals.hvpsConsole));
2140}
2141
2142
2143/*****************************************************************************
2144 * Name      : static void ConsoleCursorShow
2145 * Purpose   : query number of events in the queue
2146 * Parameters:
2147 * Variables :
2148 * Result    : number of events
2149 * Remark    : called during INIT, FONTCHANGE, RESIZE, BUFFERCHANGE
2150 * Status    :
2151 *
2152 * Author    : Patrick Haller [Wed, 1998/04/29 16:55]
2153 *****************************************************************************/
2154
2155void iConsoleAdjustWindow (PCONSOLEBUFFER pConsoleBuffer)
2156{
2157  LONG   lX, lY;                                    /* temporary long values */
2158  RECTL  rcl;
2159  PRECTL pRcl = &rcl;
2160  ULONG  flStyle;                              /* window frame control style */
2161
2162  BOOL fNeedVertScroll;                      /* indicates need of scrollbars */
2163  BOOL fNeedHorzScroll;
2164
2165  LONG lScrollX;                           /* width and height of scrollbars */
2166  LONG lScrollY;
2167
2168                                         /* now calculate actual window size */
2169  lX = ConsoleGlobals.sCellCX * ConsoleGlobals.coordWindowSize.X;
2170  lY = ConsoleGlobals.sCellCY * ConsoleGlobals.coordWindowSize.Y;
2171
2172  if ( (ConsoleGlobals.sCellCX == 0) ||          /* prevent division by zero */
2173       (ConsoleGlobals.sCellCY == 0) )
2174    return;
2175
2176         /* calculate maximum console window size in pixels for the tracking */
2177  ConsoleGlobals.coordMaxWindowPels.X = ConsoleGlobals.sCellCX * pConsoleBuffer->coordWindowSize.X
2178                                        + WinQuerySysValue(HWND_DESKTOP, SV_CXSIZEBORDER) * 2;
2179
2180  ConsoleGlobals.coordMaxWindowPels.Y = ConsoleGlobals.sCellCY * pConsoleBuffer->coordWindowSize.Y
2181                                        + WinQuerySysValue(HWND_DESKTOP, SV_CYSIZEBORDER) * 2
2182                                        + WinQuerySysValue(HWND_DESKTOP, SV_CYTITLEBAR);
2183
2184  /***************************/
2185  /* @@@PH broken code below */
2186  /***************************/
2187  return;
2188
2189                             /* add the window border height and width, etc. */
2190  WinQueryWindowRect (ConsoleGlobals.hwndClient,
2191                      pRcl);
2192
2193                                                   /* calculate visible area */
2194   /* calculate real client window rectangle and take care of the scrollbars */
2195  lScrollX = WinQuerySysValue(HWND_DESKTOP, SV_CXVSCROLL);
2196  lScrollY = WinQuerySysValue(HWND_DESKTOP, SV_CYHSCROLL);
2197  if (ConsoleGlobals.fHasHorzScroll)
2198  {
2199    lY += lScrollY;
2200    ConsoleGlobals.coordMaxWindowPels.Y += lScrollY;
2201  }
2202
2203  if (ConsoleGlobals.fHasVertScroll)
2204  {
2205    lX += lScrollX;
2206    ConsoleGlobals.coordMaxWindowPels.X += lScrollX;
2207  }
2208
2209  /* @@@PH might NOT exceed maximum VioPS size ! */
2210  ConsoleGlobals.coordWindowSize.X = (pRcl->xRight - pRcl->xLeft)
2211                                     / ConsoleGlobals.sCellCX;
2212
2213  ConsoleGlobals.coordWindowSize.Y = (pRcl->yTop   - pRcl->yBottom)
2214                                     / ConsoleGlobals.sCellCY;
2215
2216                                    /* do we have to enable the scrollbars ? */
2217  fNeedHorzScroll = lX < pConsoleBuffer->coordWindowSize.X * ConsoleGlobals.sCellCX;
2218  fNeedVertScroll = lY < pConsoleBuffer->coordWindowSize.Y * ConsoleGlobals.sCellCY;
2219
2220
2221  if ( (ConsoleGlobals.fHasVertScroll != fNeedVertScroll) ||
2222       (ConsoleGlobals.fHasHorzScroll != fNeedHorzScroll) )
2223  {
2224    flStyle = WinQueryWindowULong(ConsoleGlobals.hwndFrame,
2225                                  QWL_STYLE);
2226
2227                                           /* now set or remove the controls */
2228    if (ConsoleGlobals.fHasHorzScroll != fNeedHorzScroll)
2229      if (fNeedHorzScroll)
2230      {
2231        flStyle |= FCF_HORZSCROLL;
2232        WinSetParent(ConsoleGlobals.hwndHorzScroll,        /* attach control */
2233                     ConsoleGlobals.hwndFrame,
2234                     FALSE);
2235      }
2236      else
2237      {
2238        flStyle &= ~FCF_HORZSCROLL;
2239        WinSetParent(ConsoleGlobals.hwndHorzScroll,        /* detach control */
2240                     HWND_OBJECT,
2241                     FALSE);
2242        ConsoleGlobals.coordWindowPos.X = 0;    /* we can see the whole buffer */
2243      }
2244
2245    if (ConsoleGlobals.fHasVertScroll != fNeedVertScroll)
2246      if (fNeedVertScroll)
2247      {
2248        flStyle |= FCF_VERTSCROLL;
2249        WinSetParent(ConsoleGlobals.hwndVertScroll,        /* attach control */
2250                     ConsoleGlobals.hwndFrame,
2251                     FALSE);
2252      }
2253      else
2254      {
2255        flStyle &= ~FCF_VERTSCROLL;
2256        WinSetParent(ConsoleGlobals.hwndVertScroll,        /* detach control */
2257                     HWND_OBJECT,
2258                     FALSE);
2259        ConsoleGlobals.coordWindowPos.Y = 0;  /* we can see the whole buffer */
2260      }
2261
2262
2263    WinSendMsg(ConsoleGlobals.hwndFrame,                     /* update frame */
2264               WM_UPDATEFRAME,
2265               MPFROMLONG(flStyle),
2266               MPVOID);
2267
2268    WinInvalidateRect(ConsoleGlobals.hwndFrame,       /* redraw frame window */
2269                      NULL,
2270                      TRUE);
2271
2272    ConsoleGlobals.fHasVertScroll = fNeedVertScroll;       /* update globals */
2273    ConsoleGlobals.fHasHorzScroll = fNeedHorzScroll;       /* update globals */
2274  }
2275
2276
2277                                    /* setup the scrollbars and scrollranges */
2278  if (ConsoleGlobals.fHasVertScroll)
2279  {
2280    /* setup vertical scrollbar */
2281  }
2282
2283
2284  if (ConsoleGlobals.fHasHorzScroll)
2285  {
2286    /* setup horizonal scrollbar */
2287  }
2288
2289
2290  WinCalcFrameRect(ConsoleGlobals.hwndFrame,    /* calculate frame rectangle */
2291                   pRcl,
2292                   FALSE);
2293
2294  /* @@@PH client may not overlap frame ! */
2295  /* @@@PH write values to TRACKINFO      */
2296
2297#if 0
2298  /* @@@PH this results in recursion */
2299  WinSetWindowPos (ConsoleGlobals.hwndClient,   /* adjust client window size */
2300                   ConsoleGlobals.hwndFrame,
2301                   0,
2302                   0,
2303                   lX,
2304                   lY,
2305                   SWP_SIZE);
2306
2307  WinSetWindowPos (ConsoleGlobals.hwndFrame,    /* adjust client window size */
2308                   HWND_DESKTOP,
2309                   pRcl->xLeft,
2310                   pRcl->yBottom,
2311                   pRcl->xRight,
2312                   pRcl->yTop,
2313                   SWP_SIZE);
2314#endif
2315}
2316
2317extern "C" {
2318
2319/*****************************************************************************
2320 * Name      : BOOL WIN32API AllocConsole
2321 * Purpose   : The AllocConsole function allocates a new console
2322 *             for the calling process
2323 * Parameters: VOID
2324 * Variables :
2325 * Result    : BOOL: TRUE  - function succeeded
2326 *                   FALSE - function failed. Extended error information
2327 *                           obtainable via GetLastError
2328 * Remark    :
2329 * Status    : REWRITTEN UNTESTED
2330 *
2331 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2332 *****************************************************************************/
2333
2334BOOL WIN32API AllocConsole(VOID)
2335{
2336  APIRET rc;                                               /* API returncode */
2337
2338  dprintf(("KERNEL32/CONSOLE: OS2AllocConsole() called"));
2339
2340  rc = iConsoleInit(flVioConsole);               /* initialize subsystem if required */
2341  if (rc != NO_ERROR)                            /* check for errors */
2342  {
2343    SetLastError(rc);                            /* pass thru the error code */
2344    return FALSE;                                          /* signal failure */
2345  }
2346  else
2347    return TRUE;                                                /* Fine ! :) */
2348}
2349
2350
2351/*****************************************************************************
2352 * Name      : HANDLE WIN32API CreateConsoleScreenBuffer
2353 * Purpose   : The CreateConsoleScreenBuffer function creates a console
2354 *             screen buffer and returns a handle of it.
2355 * Parameters: DWORD  dwDesiredAccess    - access flag
2356 *             DWORD  dwShareMode        - buffer share more
2357 *             PVOID  pIgnored           - LPSECURITY_ATTRIBUTES -> NT
2358 *             DWORD  dwFlags            - type of buffer to create
2359 *             LPVOID lpScreenBufferData - reserved
2360 * Variables :
2361 * Result    :
2362 * Remark    : a console buffer is a kernel heap object equipped with
2363 *             share modes, access rights, etc.
2364 *             we can't really map this to OS/2 unless we build a
2365 *             console device driver for it ... maybe this turns out to
2366 *             be necessary since we've got to handle CONIN$ and CONOUT$, too.
2367 * Status    :
2368 *
2369 * Author    : Patrick Haller [Tue, 1998/02/10 03:55]
2370 *****************************************************************************/
2371
2372HANDLE WIN32API CreateConsoleScreenBuffer(DWORD  dwDesiredAccess,
2373                                          DWORD  dwShareMode,
2374                                          LPVOID lpSecurityAttributes,
2375                                          DWORD  dwFlags,
2376                                          LPVOID lpScreenBufferData)
2377{
2378  HANDLE hResult;
2379
2380  hResult = HMCreateFile("CONBUFFER$",         /* create a new buffer handle */
2381                         dwDesiredAccess,
2382                         dwShareMode,
2383                         (LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
2384                         0,
2385                         dwFlags,
2386                         INVALID_HANDLE_VALUE);
2387
2388  return hResult;
2389}
2390
2391
2392/*****************************************************************************
2393 * Name      :
2394 * Purpose   :
2395 * Parameters:
2396 * Variables :
2397 * Result    :
2398 * Remark    :
2399 * Status    :
2400 *
2401 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2402 *****************************************************************************/
2403
2404BOOL WIN32API FillConsoleOutputAttribute(HANDLE  hConsoleOutput,
2405                                            WORD    wAttribute,
2406                                            DWORD   nLength,
2407                                            COORD   dwWriteCoord,
2408                                            LPDWORD lpNumberOfAttrsWritten)
2409{
2410  BOOL fResult;
2411
2412  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
2413                                  DRQ_FILLCONSOLEOUTPUTATTRIBUTE,
2414                                  (ULONG)wAttribute,
2415                                  (ULONG)nLength,
2416                                  COORD2ULONG(dwWriteCoord),
2417                                  (ULONG)lpNumberOfAttrsWritten);
2418
2419  return fResult;
2420}
2421
2422
2423/*****************************************************************************
2424 * Name      :
2425 * Purpose   :
2426 * Parameters:
2427 * Variables :
2428 * Result    :
2429 * Remark    :
2430 * Status    :
2431 *
2432 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2433 *****************************************************************************/
2434
2435BOOL WIN32API FillConsoleOutputCharacterA(HANDLE  hConsoleOutput,
2436                                             UCHAR   cCharacter,
2437                                             DWORD   nLength,
2438                                             COORD   dwWriteCoord,
2439                                             LPDWORD lpNumberOfCharsWritten )
2440{
2441  BOOL fResult;
2442
2443  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
2444                                  DRQ_FILLCONSOLEOUTPUTCHARACTERA,
2445                                  (ULONG)cCharacter,
2446                                  (ULONG)nLength,
2447                                  COORD2ULONG(dwWriteCoord),
2448                                  (ULONG)lpNumberOfCharsWritten);
2449
2450  return fResult;
2451}
2452
2453
2454/*****************************************************************************
2455 * Name      :
2456 * Purpose   :
2457 * Parameters:
2458 * Variables :
2459 * Result    :
2460 * Remark    :
2461 * Status    :
2462 *
2463 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2464 *****************************************************************************/
2465
2466BOOL WIN32API FillConsoleOutputCharacterW(HANDLE  hConsoleOutput,
2467                                             WCHAR   cCharacter,
2468                                             DWORD   nLength,
2469                                             COORD   dwWriteCoord,
2470                                             LPDWORD lpNumberOfCharsWritten )
2471{
2472  BOOL fResult;
2473
2474  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
2475                                  DRQ_FILLCONSOLEOUTPUTCHARACTERW,
2476                                  (ULONG)cCharacter,
2477                                  (ULONG)nLength,
2478                                  COORD2ULONG(dwWriteCoord),
2479                                  (ULONG)lpNumberOfCharsWritten);
2480
2481  return fResult;
2482}
2483
2484
2485/*****************************************************************************
2486 * Name      :
2487 * Purpose   :
2488 * Parameters:
2489 * Variables :
2490 * Result    :
2491 * Remark    :
2492 * Status    :
2493 *
2494 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2495 *****************************************************************************/
2496
2497BOOL WIN32API FlushConsoleInputBuffer( HANDLE hConsoleInput )
2498{
2499  BOOL fResult;
2500
2501  fResult = (BOOL)HMDeviceRequest(hConsoleInput,
2502                                  DRQ_FLUSHCONSOLEINPUTBUFFER,
2503                                  0,
2504                                  0,
2505                                  0,
2506                                  0);
2507
2508  return fResult;
2509}
2510
2511
2512/*****************************************************************************
2513 * Name      : BOOL WIN32API FreeConsole
2514 * Purpose   : The FreeConsole function detaches the calling process
2515 *             from its console.
2516 * Parameters: VOID
2517 * Variables :
2518 * Result    : BOOL: TRUE  - function succeeded
2519 *                   FALSE - function failed. Extended error information
2520 *                           obtainable via GetLastError
2521 * Remark    :
2522 * Status    : REWRITTEN UNTESTED
2523 *
2524 * Author    : Patrick Haller [Tue, 1998/02/10 03:35]
2525 *****************************************************************************/
2526
2527BOOL WIN32API FreeConsole( VOID )
2528{
2529  APIRET rc;                                               /* API returncode */
2530
2531  rc = iConsoleTerminate();               /* terminate subsystem if required */
2532  if (rc != NO_ERROR)                                    /* check for errors */
2533  {
2534    SetLastError(rc);                            /* pass thru the error code */
2535    return FALSE;                                          /* signal failure */
2536  }
2537  else
2538    return TRUE;                                                /* Fine ! :) */
2539
2540  return TRUE;
2541}
2542
2543
2544/*****************************************************************************
2545 * Name      :
2546 * Purpose   :
2547 * Parameters:
2548 * Variables :
2549 * Result    :
2550 * Remark    :
2551 * Status    :
2552 *
2553 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2554 *****************************************************************************/
2555
2556UINT WIN32API GetConsoleCP(VOID)
2557{
2558  dprintf(("KERNEL32/CONSOLE: GetConsoleCP not implemented"));
2559
2560  return 1;
2561}
2562
2563
2564/*****************************************************************************
2565 * Name      :
2566 * Purpose   :
2567 * Parameters:
2568 * Variables :
2569 * Result    :
2570 * Remark    :
2571 * Status    :
2572 *
2573 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2574 *****************************************************************************/
2575
2576BOOL WIN32API GetConsoleCursorInfo(HANDLE               hConsoleOutput,
2577                                      PCONSOLE_CURSOR_INFO lpConsoleCursorInfo)
2578{
2579  BOOL fResult;
2580
2581  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
2582                                  DRQ_GETCONSOLECURSORINFO,
2583                                  (ULONG)lpConsoleCursorInfo,
2584                                  0,
2585                                  0,
2586                                  0);
2587
2588  return fResult;
2589}
2590
2591
2592/*****************************************************************************
2593 * Name      :
2594 * Purpose   :
2595 * Parameters:
2596 * Variables :
2597 * Result    :
2598 * Remark    :
2599 * Status    :
2600 *
2601 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2602 *****************************************************************************/
2603
2604BOOL WIN32API GetConsoleMode(HANDLE  hConsole,
2605                                LPDWORD lpMode)
2606{
2607  BOOL fResult;
2608
2609  fResult = (BOOL)HMDeviceRequest(hConsole,
2610                                  DRQ_GETCONSOLEMODE,
2611                                  (ULONG) lpMode,
2612                                  0,
2613                                  0,
2614                                  0);
2615
2616  return fResult;
2617}
2618
2619
2620/*****************************************************************************
2621 * Name      :
2622 * Purpose   :
2623 * Parameters:
2624 * Variables :
2625 * Result    :
2626 * Remark    :
2627 * Status    :
2628 *
2629 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2630 *****************************************************************************/
2631
2632UINT WIN32API GetConsoleOutputCP(VOID)
2633{
2634  dprintf(("KERNEL32/CONSOLE: GetConsoleOutputCP not implemented"));
2635
2636  return 1;
2637}
2638
2639
2640/*****************************************************************************
2641 * Name      :
2642 * Purpose   :
2643 * Parameters:
2644 * Variables :
2645 * Result    :
2646 * Remark    :
2647 * Status    :
2648 *
2649 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2650 *****************************************************************************/
2651
2652BOOL WIN32API GetConsoleScreenBufferInfo(HANDLE                      hConsoleOutput,
2653                                         PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo)
2654{
2655  BOOL fResult;
2656
2657  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
2658                                  DRQ_GETCONSOLESCREENBUFFERINFO,
2659                                  (ULONG)lpConsoleScreenBufferInfo,
2660                                  0,
2661                                  0,
2662                                  0);
2663
2664  return fResult;
2665}
2666
2667
2668/*****************************************************************************
2669 * Name      : DWORD WIN32API GetConsoleTitle
2670 * Purpose   : Query the current console window title
2671 * Parameters: LPTSTR lpConsoleTitle
2672 *             DWORD  nSize
2673 * Variables :
2674 * Result    : number of copied bytes
2675 * Remark    :
2676 * Status    : REWRITTEN UNTESTED
2677 *
2678 * Author    : Patrick Haller [Thu, 1998/02/12 23:31]
2679 *****************************************************************************/
2680
2681DWORD WIN32API GetConsoleTitleA(LPTSTR lpConsoleTitle,
2682                                DWORD  nSize)
2683{
2684  ULONG ulLength;                                          /* length of text */
2685
2686  if (ConsoleGlobals.pszWindowTitle == NULL)    /* is there a window title ? */
2687    return 0;                                           /* abort immediately */
2688
2689  ulLength = strlen(ConsoleGlobals.pszWindowTitle);        /* length of text */
2690
2691  strncpy(lpConsoleTitle,
2692          ConsoleGlobals.pszWindowTitle,
2693          nSize);
2694  lpConsoleTitle[nSize-1] = 0;
2695
2696  return (nSize < ulLength) ? nSize : ulLength;
2697}
2698
2699
2700/*****************************************************************************
2701 * Name      : DWORD WIN32API GetConsoleTitle
2702 * Purpose   : Query the current console window title
2703 * Parameters: LPTSTR lpConsoleTitle
2704 *             DWORD  nSize
2705 * Variables :
2706 * Result    : number of copied bytes
2707 * Remark    :
2708 * Status    : REWRITTEN UNTESTED
2709 *
2710 * Author    : Patrick Haller [Thu, 1998/02/12 23:31]
2711 *****************************************************************************/
2712
2713
2714DWORD WIN32API GetConsoleTitleW(LPWSTR lpConsoleTitle,
2715                                DWORD  nSize)
2716{
2717  if (ConsoleGlobals.pszWindowTitle == NULL)    /* is there a window title ? */
2718    return 0;                                           /* abort immediately */
2719
2720  MultiByteToWideChar( GetConsoleCP(), 0, ConsoleGlobals.pszWindowTitle, -1,
2721        lpConsoleTitle, nSize );
2722  lpConsoleTitle[ nSize - 1 ] = 0;
2723
2724  return lstrlenW( lpConsoleTitle );
2725}
2726
2727
2728/*****************************************************************************
2729 * Name      : COORD WIN32API GetLargestConsoleWindowSize
2730 * Purpose   : Determine maximum AVIO size
2731 * Parameters:
2732 * Variables :
2733 * Result    :
2734 * Remark    :
2735 * Status    :
2736 *
2737 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2738 *****************************************************************************/
2739
2740COORD WIN32API GetLargestConsoleWindowSize(HANDLE hConsoleOutput)
2741{
2742  DWORD dwResult;
2743  COORD coordResult;
2744
2745  dwResult = HMDeviceRequest(hConsoleOutput,
2746                             DRQ_GETLARGESTCONSOLEWINDOWSIZE,
2747                             0,
2748                             0,
2749                             0,
2750                             0);
2751
2752  ULONG2COORD(coordResult,dwResult)
2753  return ( coordResult );
2754}
2755
2756
2757/*****************************************************************************
2758 * Name      :
2759 * Purpose   :
2760 * Parameters:
2761 * Variables :
2762 * Result    :
2763 * Remark    :
2764 * Status    :
2765 *
2766 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2767 *****************************************************************************/
2768
2769BOOL WIN32API GetNumberOfConsoleInputEvents(HANDLE  hConsoleInput,
2770                                            LPDWORD lpNumberOfEvents)
2771{
2772  BOOL fResult;
2773
2774  fResult = (BOOL)HMDeviceRequest(hConsoleInput,
2775                                  DRQ_GETNUMBEROFCONSOLEINPUTEVENTS,
2776                                  (ULONG)lpNumberOfEvents,
2777                                  0,
2778                                  0,
2779                                  0);
2780
2781  return fResult;
2782}
2783
2784
2785/*****************************************************************************
2786 * Name      :
2787 * Purpose   :
2788 * Parameters:
2789 * Variables :
2790 * Result    :
2791 * Remark    :
2792 * Status    :
2793 *
2794 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2795 *****************************************************************************/
2796
2797BOOL WIN32API GetNumberOfConsoleMouseButtons(LPDWORD lpcNumberOfMouseButtons)
2798{
2799  LONG lMouseButtons;
2800
2801  lMouseButtons = WinQuerySysValue(HWND_DESKTOP,        /* query PM for that */
2802                                   SV_CMOUSEBUTTONS);
2803
2804  *lpcNumberOfMouseButtons = (DWORD)lMouseButtons;
2805
2806  return TRUE;
2807}
2808
2809
2810/*****************************************************************************
2811 * Name      :
2812 * Purpose   :
2813 * Parameters:
2814 * Variables :
2815 * Result    :
2816 * Remark    :
2817 * Status    :
2818 *
2819 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2820 *****************************************************************************/
2821
2822BOOL WIN32API PeekConsoleInputW(HANDLE        hConsoleInput,
2823                                   PINPUT_RECORD pirBuffer,
2824                                   DWORD         cInRecords,
2825                                   LPDWORD       lpcRead)
2826{
2827  BOOL fResult;
2828
2829  fResult = (BOOL)HMDeviceRequest(hConsoleInput,
2830                                  DRQ_PEEKCONSOLEINPUTW,
2831                                  (ULONG)pirBuffer,
2832                                  (ULONG)cInRecords,
2833                                  (ULONG)lpcRead,
2834                                  0);
2835
2836  return fResult;
2837}
2838
2839
2840/*****************************************************************************
2841 * Name      :
2842 * Purpose   :
2843 * Parameters:
2844 * Variables :
2845 * Result    :
2846 * Remark    :
2847 * Status    :
2848 *
2849 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2850 *****************************************************************************/
2851
2852BOOL WIN32API PeekConsoleInputA(HANDLE        hConsoleInput,
2853                                PINPUT_RECORD pirBuffer,
2854                                DWORD         cInRecords,
2855                                LPDWORD       lpcRead)
2856{
2857  BOOL fResult;
2858
2859  fResult = (BOOL)HMDeviceRequest(hConsoleInput,
2860                                  DRQ_PEEKCONSOLEINPUTA,
2861                                  (ULONG)pirBuffer,
2862                                  (ULONG)cInRecords,
2863                                  (ULONG)lpcRead,
2864                                  0);
2865
2866  return fResult;
2867}
2868
2869
2870/*****************************************************************************
2871 * Name      :
2872 * Purpose   :
2873 * Parameters:
2874 * Variables :
2875 * Result    :
2876 * Remark    :
2877 * Status    :
2878 *
2879 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2880 *****************************************************************************/
2881
2882BOOL WIN32API ReadConsoleA(HANDLE  hConsoleInput,
2883                           LPVOID  lpvBuffer,
2884                           DWORD   cchToRead,
2885                           LPDWORD lpcchRead,
2886                           LPVOID  lpvReserved)
2887{
2888  BOOL fResult;
2889
2890  fResult = (BOOL)HMDeviceRequest(hConsoleInput,
2891                                  DRQ_READCONSOLEA,
2892                                  (ULONG)lpvBuffer,
2893                                  (ULONG)cchToRead,
2894                                  (ULONG)lpcchRead,
2895                                  (ULONG)lpvReserved);
2896
2897  return fResult;
2898}
2899
2900
2901/*****************************************************************************
2902 * Name      :
2903 * Purpose   :
2904 * Parameters:
2905 * Variables :
2906 * Result    :
2907 * Remark    :
2908 * Status    :
2909 *
2910 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2911 *****************************************************************************/
2912
2913BOOL WIN32API ReadConsoleW(HANDLE  hConsoleInput,
2914                           LPVOID  lpvBuffer,
2915                           DWORD   cchToRead,
2916                           LPDWORD lpcchRead,
2917                           LPVOID  lpvReserved)
2918{
2919  BOOL fResult;
2920
2921  fResult = (BOOL)HMDeviceRequest(hConsoleInput,
2922                                  DRQ_READCONSOLEW,
2923                                  (ULONG)lpvBuffer,
2924                                  (ULONG)cchToRead,
2925                                  (ULONG)lpcchRead,
2926                                  (ULONG)lpvReserved);
2927
2928  return fResult;
2929}
2930
2931
2932/*****************************************************************************
2933 * Name      :
2934 * Purpose   :
2935 * Parameters:
2936 * Variables :
2937 * Result    :
2938 * Remark    :
2939 * Status    :
2940 *
2941 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2942 *****************************************************************************/
2943
2944BOOL WIN32API ReadConsoleInputA(HANDLE        hConsoleInput,
2945                                PINPUT_RECORD pirBuffer,
2946                                DWORD         cInRecords,
2947                                LPDWORD       lpcRead)
2948{
2949  BOOL fResult;
2950
2951  fResult = (BOOL)HMDeviceRequest(hConsoleInput,
2952                                  DRQ_READCONSOLEINPUTA,
2953                                  (ULONG)pirBuffer,
2954                                  (ULONG)cInRecords,
2955                                  (ULONG)lpcRead,
2956                                  0);
2957
2958  return fResult;
2959}
2960
2961
2962/*****************************************************************************
2963 * Name      :
2964 * Purpose   :
2965 * Parameters:
2966 * Variables :
2967 * Result    :
2968 * Remark    :
2969 * Status    :
2970 *
2971 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
2972 *****************************************************************************/
2973
2974BOOL WIN32API ReadConsoleInputW(HANDLE        hConsoleInput,
2975                                PINPUT_RECORD pirBuffer,
2976                                DWORD         cInRecords,
2977                                LPDWORD       lpcRead)
2978{
2979  BOOL fResult;
2980
2981  fResult = (BOOL)HMDeviceRequest(hConsoleInput,
2982                                  DRQ_READCONSOLEINPUTW,
2983                                  (ULONG)pirBuffer,
2984                                  (ULONG)cInRecords,
2985                                  (ULONG)lpcRead,
2986                                  0);
2987
2988  return fResult;
2989}
2990
2991
2992/*****************************************************************************
2993 * Name      :
2994 * Purpose   :
2995 * Parameters:
2996 * Variables :
2997 * Result    :
2998 * Remark    :
2999 * Status    :
3000 *
3001 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3002 *****************************************************************************/
3003
3004BOOL WIN32API ReadConsoleOutputA(HANDLE      hConsoleOutput,
3005                                 PCHAR_INFO  pchiDestBuffer,
3006                                 COORD       coordDestBufferSize,
3007                                 COORD       coordDestBufferCoord,
3008                                 PSMALL_RECT psrctSourceRect)
3009{
3010  BOOL fResult;
3011
3012  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3013                                  DRQ_READCONSOLEOUTPUTA,
3014                                  (ULONG)pchiDestBuffer,
3015                                  COORD2ULONG(coordDestBufferSize),
3016                                  COORD2ULONG(coordDestBufferCoord),
3017                                  (ULONG)psrctSourceRect);
3018
3019  return fResult;
3020}
3021
3022
3023/*****************************************************************************
3024 * Name      :
3025 * Purpose   :
3026 * Parameters:
3027 * Variables :
3028 * Result    :
3029 * Remark    :
3030 * Status    :
3031 *
3032 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3033 *****************************************************************************/
3034
3035BOOL WIN32API ReadConsoleOutputW(HANDLE      hConsoleOutput,
3036                                 PCHAR_INFO  pchiDestBuffer,
3037                                 COORD       coordDestBufferSize,
3038                                 COORD       coordDestBufferCoord,
3039                                 PSMALL_RECT psrctSourceRect)
3040{
3041  BOOL fResult;
3042
3043  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3044                                  DRQ_READCONSOLEOUTPUTW,
3045                                  (ULONG)pchiDestBuffer,
3046                                  COORD2ULONG(coordDestBufferSize),
3047                                  COORD2ULONG(coordDestBufferCoord),
3048                                  (ULONG)psrctSourceRect);
3049
3050  return fResult;
3051}
3052
3053
3054/*****************************************************************************
3055 * Name      :
3056 * Purpose   :
3057 * Parameters:
3058 * Variables :
3059 * Result    :
3060 * Remark    :
3061 * Status    :
3062 *
3063 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3064 *****************************************************************************/
3065
3066BOOL WIN32API ReadConsoleOutputAttribute(HANDLE  hConsoleOutput,
3067                                         LPWORD  lpwAttribute,
3068                                         DWORD   cReadCells,
3069                                         COORD   coordReadCoord,
3070                                         LPDWORD lpcNumberRead)
3071{
3072  BOOL fResult;
3073
3074  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3075                                  DRQ_READCONSOLEOUTPUTATTRIBUTE,
3076                                  (ULONG)lpwAttribute,
3077                                  (ULONG)cReadCells,
3078                                  COORD2ULONG(coordReadCoord),
3079                                  (ULONG)lpcNumberRead);
3080
3081  return fResult;
3082}
3083
3084
3085/*****************************************************************************
3086 * Name      :
3087 * Purpose   :
3088 * Parameters:
3089 * Variables :
3090 * Result    :
3091 * Remark    :
3092 * Status    :
3093 *
3094 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3095 *****************************************************************************/
3096
3097BOOL WIN32API ReadConsoleOutputCharacterA(HANDLE  hConsoleOutput,
3098                                          LPTSTR  lpReadBuffer,
3099                                          DWORD   cchRead,
3100                                          COORD   coordReadCoord,
3101                                          LPDWORD lpcNumberRead)
3102{
3103  BOOL fResult;
3104
3105  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3106                                  DRQ_READCONSOLEOUTPUTCHARACTERA,
3107                                  (ULONG)lpReadBuffer,
3108                                  (ULONG)cchRead,
3109                                  COORD2ULONG(coordReadCoord),
3110                                  (ULONG)lpcNumberRead);
3111
3112  return fResult;
3113}
3114
3115
3116/*****************************************************************************
3117 * Name      :
3118 * Purpose   :
3119 * Parameters:
3120 * Variables :
3121 * Result    :
3122 * Remark    :
3123 * Status    :
3124 *
3125 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3126 *****************************************************************************/
3127
3128BOOL WIN32API ReadConsoleOutputCharacterW(HANDLE  hConsoleOutput,
3129                                          LPTSTR  lpReadBuffer,
3130                                          DWORD   cchRead,
3131                                          COORD   coordReadCoord,
3132                                          LPDWORD lpcNumberRead)
3133{
3134  BOOL fResult;
3135
3136  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3137                                  DRQ_READCONSOLEOUTPUTCHARACTERW,
3138                                  (ULONG)lpReadBuffer,
3139                                  (ULONG)cchRead,
3140                                  COORD2ULONG(coordReadCoord),
3141                                  (ULONG)lpcNumberRead);
3142
3143  return fResult;
3144}
3145
3146
3147/*****************************************************************************
3148 * Name      :
3149 * Purpose   :
3150 * Parameters:
3151 * Variables :
3152 * Result    :
3153 * Remark    :
3154 * Status    :
3155 *
3156 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3157 *****************************************************************************/
3158
3159BOOL WIN32API ScrollConsoleScreenBufferA(HANDLE      hConsoleOutput,
3160                                         PSMALL_RECT psrctSourceRect,
3161                                         PSMALL_RECT psrctClipRect,
3162                                         COORD       coordDestOrigin,
3163                                         PCHAR_INFO  pchiFill)
3164{
3165  BOOL fResult;
3166
3167  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3168                                  DRQ_SCROLLCONSOLESCREENBUFFERA,
3169                                  (ULONG)psrctSourceRect,
3170                                  (ULONG)psrctClipRect,
3171                                  COORD2ULONG(coordDestOrigin),
3172                                  (ULONG)pchiFill);
3173
3174  return fResult;
3175}
3176
3177
3178/*****************************************************************************
3179 * Name      :
3180 * Purpose   :
3181 * Parameters:
3182 * Variables :
3183 * Result    :
3184 * Remark    :
3185 * Status    :
3186 *
3187 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3188 *****************************************************************************/
3189
3190BOOL WIN32API ScrollConsoleScreenBufferW(HANDLE      hConsoleOutput,
3191                                         PSMALL_RECT psrctSourceRect,
3192                                         PSMALL_RECT psrctClipRect,
3193                                         COORD       coordDestOrigin,
3194                                         PCHAR_INFO  pchiFill)
3195{
3196  BOOL fResult;
3197
3198  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3199                                  DRQ_SCROLLCONSOLESCREENBUFFERW,
3200                                  (ULONG)psrctSourceRect,
3201                                  (ULONG)psrctClipRect,
3202                                  COORD2ULONG(coordDestOrigin),
3203                                  (ULONG)pchiFill);
3204
3205  return fResult;
3206}
3207
3208/*****************************************************************************
3209 * Name      :
3210 * Purpose   :
3211 * Parameters:
3212 * Variables :
3213 * Result    :
3214 * Remark    :
3215 * Status    :
3216 *
3217 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3218 *****************************************************************************/
3219
3220BOOL WIN32API SetConsoleActiveScreenBuffer(HANDLE hConsoleOutput)
3221{
3222  BOOL fResult;
3223
3224  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3225                                  DRQ_SETCONSOLEACTIVESCREENBUFFER,
3226                                  0,
3227                                  0,
3228                                  0,
3229                                  0);
3230
3231  return fResult;
3232}
3233
3234
3235/*****************************************************************************
3236 * Name      :
3237 * Purpose   :
3238 * Parameters:
3239 * Variables :
3240 * Result    :
3241 * Remark    :
3242 * Status    :
3243 *
3244 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3245 *****************************************************************************/
3246
3247BOOL WIN32API SetConsoleCP(UINT IDCodePage)
3248{
3249  dprintf(("KERNEL32/CONSOLE: SetConsoleCP(%08x) not implemented.\n",
3250           IDCodePage));
3251
3252  return TRUE;
3253}
3254
3255
3256/*****************************************************************************
3257 * Name      :
3258 * Purpose   :
3259 * Parameters:
3260 * Variables :
3261 * Result    :
3262 * Remark    :
3263 * Status    :
3264 *
3265 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3266 *****************************************************************************/
3267
3268BOOL WIN32API SetConsoleCursorInfo(HANDLE               hConsoleOutput,
3269                                      PCONSOLE_CURSOR_INFO lpConsoleCursorInfo)
3270{
3271  BOOL fResult;
3272
3273  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3274                                  DRQ_SETCONSOLECURSORINFO,
3275                                  (ULONG)lpConsoleCursorInfo,
3276                                  0,
3277                                  0,
3278                                  0);
3279
3280  return fResult;
3281}
3282
3283
3284/*****************************************************************************
3285 * Name      :
3286 * Purpose   :
3287 * Parameters:
3288 * Variables :
3289 * Result    :
3290 * Remark    :
3291 * Status    :
3292 *
3293 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3294
3295 *****************************************************************************/
3296
3297BOOL WIN32API SetConsoleCursorPosition(HANDLE hConsoleOutput,
3298                                          COORD  coordCursor)
3299{
3300  BOOL fResult;
3301
3302  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3303                                  DRQ_SETCONSOLECURSORPOSITION,
3304                                  COORD2ULONG(coordCursor),
3305                                  0,
3306                                  0,
3307                                  0);
3308
3309  return fResult;
3310}
3311
3312
3313/*****************************************************************************
3314 * Name      :
3315 * Purpose   :
3316 * Parameters:
3317 * Variables :
3318 * Result    :
3319 * Remark    :
3320 * Status    :
3321 *
3322 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3323 *****************************************************************************/
3324
3325BOOL WIN32API SetConsoleMode(HANDLE hConsole,
3326                                DWORD  fdwMode)
3327{
3328 BOOL fResult;
3329
3330  fResult = (BOOL)HMDeviceRequest(hConsole,
3331                                  DRQ_SETCONSOLEMODE,
3332                                  (ULONG)fdwMode,
3333                                  0,
3334                                  0,
3335                                  0);
3336
3337  return fResult;
3338}
3339
3340
3341/*****************************************************************************
3342 * Name      :
3343 * Purpose   :
3344 * Parameters:
3345 * Variables :
3346 * Result    :
3347 * Remark    :
3348 * Status    :
3349 *
3350 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3351 *****************************************************************************/
3352
3353BOOL WIN32API SetConsoleOutputCP(UINT IDCodePage)
3354{
3355  dprintf(("KERNEL32/CONSOLE: OS2SetConsoleOutputCP(%08x) not implemented.\n",
3356           IDCodePage));
3357
3358  return TRUE;
3359}
3360
3361
3362/*****************************************************************************
3363 * Name      :
3364 * Purpose   :
3365 * Parameters:
3366 * Variables :
3367 * Result    :
3368 * Remark    :
3369 * Status    :
3370 *
3371 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3372 *****************************************************************************/
3373
3374BOOL WIN32API SetConsoleScreenBufferSize(HANDLE hConsoleOutput,
3375                                            COORD  coordSize)
3376{
3377  BOOL fResult;
3378
3379  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3380                                  DRQ_SETCONSOLESCREENBUFFERSIZE,
3381                                  COORD2ULONG(coordSize),
3382                                  0,
3383                                  0,
3384                                  0);
3385
3386  return fResult;
3387}
3388
3389
3390/*****************************************************************************
3391 * Name      :
3392 * Purpose   :
3393 * Parameters:
3394 * Variables :
3395 * Result    :
3396 * Remark    :
3397 * Status    :
3398 *
3399 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3400 *****************************************************************************/
3401
3402BOOL WIN32API SetConsoleTextAttribute(HANDLE hConsoleOutput,
3403                                         WORD   wAttr)
3404{
3405  BOOL fResult;
3406
3407  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3408                                  DRQ_SETCONSOLETEXTATTRIBUTE,
3409                                  (ULONG)wAttr,
3410                                  0,
3411                                  0,
3412                                  0);
3413
3414  return fResult;
3415}
3416
3417
3418/*****************************************************************************
3419 * Name      : BOOL WIN32API SetConsoleTitleA
3420 * Purpose   : Set new title text for the console window
3421 * Parameters: LPTSTR lpszTitle
3422 * Variables :
3423 * Result    :
3424 * Remark    :
3425 * Status    : REWRITTEN UNTESTED
3426 *
3427 * Author    : Patrick Haller [Tue, 1998/02/12 23:28]
3428 *****************************************************************************/
3429
3430BOOL WIN32API SetConsoleTitleA(LPTSTR lpszTitle)
3431{
3432  if (ConsoleGlobals.pszWindowTitle != NULL)           /* previously set name */
3433    free (ConsoleGlobals.pszWindowTitle);                     /* then free it */
3434
3435  ConsoleGlobals.pszWindowTitle = strdup(lpszTitle);     /* copy the new name */
3436
3437  WinSetWindowText(ConsoleGlobals.hwndFrame,           /* set new title text */
3438                   ConsoleGlobals.pszWindowTitle);
3439
3440  return TRUE;
3441}
3442
3443
3444/*****************************************************************************
3445 * Name      : BOOL WIN32API SetConsoleTitleW
3446 * Purpose   : Set new title text for the console window
3447 * Parameters: LPTSTR lpszTitle
3448 * Variables :
3449 * Result    :
3450 * Remark    :
3451 * Status    : REWRITTEN UNTESTED
3452 *
3453 * Author    : Patrick Haller [Tue, 1998/02/12 23:28]
3454 *****************************************************************************/
3455
3456BOOL WIN32API SetConsoleTitleW(LPWSTR lpszTitle)
3457{
3458  int alen;
3459
3460  if (lpszTitle == NULL)                                 /* check parameters */
3461    return FALSE;
3462
3463  if (ConsoleGlobals.pszWindowTitle != NULL)           /* previously set name */
3464    free (ConsoleGlobals.pszWindowTitle);                     /* then free it */
3465
3466  alen = WideCharToMultiByte( GetConsoleCP(), 0, lpszTitle, -1, 0, 0, 0, 0 );
3467  /* create an ascii copy of the lpszTitle */
3468  ConsoleGlobals.pszWindowTitle = (PSZ)malloc( alen );
3469  WideCharToMultiByte( GetConsoleCP(), 0, lpszTitle, -1,
3470        ConsoleGlobals.pszWindowTitle, alen, 0, 0 );
3471
3472  WinSetWindowText(ConsoleGlobals.hwndFrame,           /* set new title text */
3473                   ConsoleGlobals.pszWindowTitle);
3474
3475  return TRUE;
3476}
3477
3478
3479/*****************************************************************************
3480 * Name      :
3481 * Purpose   :
3482 * Parameters:
3483 * Variables :
3484 * Result    :
3485 * Remark    :
3486 * Status    :
3487 *
3488 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3489 *****************************************************************************/
3490
3491BOOL WIN32API SetConsoleWindowInfo(HANDLE      hConsoleOutput,
3492                                   BOOL        fAbsolute,
3493                                   PSMALL_RECT psrctWindowRect)
3494{
3495  BOOL fResult;
3496
3497  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3498                                  DRQ_SETCONSOLEWINDOWINFO,
3499                                  (ULONG)fAbsolute,
3500                                  (ULONG)psrctWindowRect,
3501                                  0,
3502                                  0);
3503
3504  return fResult;
3505}
3506
3507
3508/*****************************************************************************
3509 * Name      :
3510 * Purpose   :
3511 * Parameters:
3512 * Variables :
3513 * Result    :
3514 * Remark    :
3515 * Status    :
3516 *
3517 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3518 *****************************************************************************/
3519
3520BOOL WIN32API WriteConsoleA(HANDLE      hConsoleOutput,
3521                            CONST VOID* lpvBuffer,
3522                            DWORD       cchToWrite,
3523                            LPDWORD     lpcchWritten,
3524                            LPVOID      lpvReserved)
3525{
3526  BOOL fResult;
3527
3528  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3529                                  DRQ_WRITECONSOLEA,
3530                                  (ULONG)lpvBuffer,
3531                                  (ULONG)cchToWrite,
3532                                  (ULONG)lpcchWritten,
3533                                  (ULONG)lpvReserved);
3534
3535  return fResult;
3536}
3537
3538
3539/*****************************************************************************
3540 * Name      :
3541 * Purpose   :
3542 * Parameters:
3543 * Variables :
3544 * Result    :
3545 * Remark    :
3546 * Status    :
3547 *
3548 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3549 *****************************************************************************/
3550
3551BOOL WIN32API WriteConsoleW(HANDLE      hConsoleOutput,
3552                            CONST VOID* lpvBuffer,
3553                            DWORD       cchToWrite,
3554                            LPDWORD     lpcchWritten,
3555                            LPVOID      lpvReserved)
3556{
3557  BOOL fResult;
3558
3559  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3560                                  DRQ_WRITECONSOLEW,
3561                                  (ULONG)lpvBuffer,
3562                                  (ULONG)cchToWrite,
3563                                  (ULONG)lpcchWritten,
3564                                  (ULONG)lpvReserved);
3565
3566  return fResult;
3567}
3568
3569
3570/*****************************************************************************
3571 * Name      :
3572 * Purpose   :
3573 * Parameters:
3574 * Variables :
3575 * Result    :
3576 * Remark    :
3577 * Status    :
3578 *
3579 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3580 *****************************************************************************/
3581
3582BOOL WIN32API WriteConsoleInputA(HANDLE        hConsoleInput,
3583                                 PINPUT_RECORD pirBuffer,
3584                                 DWORD         cInRecords,
3585                                 LPDWORD       lpcWritten)
3586{
3587  BOOL fResult;
3588
3589  fResult = (BOOL)HMDeviceRequest(hConsoleInput,
3590                                  DRQ_WRITECONSOLEINPUTA,
3591                                  (ULONG)pirBuffer,
3592                                  (ULONG)cInRecords,
3593                                  (ULONG)lpcWritten,
3594                                  0);
3595
3596  return fResult;
3597}
3598
3599
3600/*****************************************************************************
3601 * Name      :
3602 * Purpose   :
3603 * Parameters:
3604 * Variables :
3605 * Result    :
3606 * Remark    :
3607 * Status    :
3608 *
3609 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3610 *****************************************************************************/
3611
3612BOOL WIN32API WriteConsoleInputW(HANDLE        hConsoleInput,
3613                                 PINPUT_RECORD pirBuffer,
3614                                 DWORD         cInRecords,
3615                                 LPDWORD       lpcWritten)
3616{
3617  BOOL fResult;
3618
3619  fResult = (BOOL)HMDeviceRequest(hConsoleInput,
3620                                  DRQ_WRITECONSOLEINPUTW,
3621                                  (ULONG)pirBuffer,
3622                                  (ULONG)cInRecords,
3623                                  (ULONG)lpcWritten,
3624                                  0);
3625
3626  return fResult;
3627}
3628
3629
3630/*****************************************************************************
3631 * Name      :
3632 * Purpose   :
3633 * Parameters:
3634 * Variables :
3635 * Result    :
3636 * Remark    :
3637 * Status    :
3638 *
3639 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3640 *****************************************************************************/
3641
3642BOOL WIN32API WriteConsoleOutputA(HANDLE      hConsoleOutput,
3643                                  PCHAR_INFO  pchiSrcBuffer,
3644                                  COORD       coordSrcBufferSize,
3645                                  COORD       coordSrcBufferCoord,
3646                                  PSMALL_RECT psrctDestRect)
3647{
3648  BOOL fResult;
3649
3650  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3651                                  DRQ_WRITECONSOLEOUTPUTA,
3652                                  (ULONG)pchiSrcBuffer,
3653                                  COORD2ULONG(coordSrcBufferSize),
3654                                  COORD2ULONG(coordSrcBufferCoord),
3655                                  (ULONG)psrctDestRect);
3656
3657  return fResult;
3658}
3659
3660
3661/*****************************************************************************
3662 * Name      :
3663 * Purpose   :
3664 * Parameters:
3665 * Variables :
3666 * Result    :
3667 * Remark    :
3668 * Status    :
3669 *
3670 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3671 *****************************************************************************/
3672
3673BOOL WIN32API WriteConsoleOutputW(HANDLE      hConsoleOutput,
3674                                  PCHAR_INFO  pchiSrcBuffer,
3675                                  COORD       coordSrcBufferSize,
3676                                  COORD       coordSrcBufferCoord,
3677                                  PSMALL_RECT psrctDestRect)
3678{
3679  BOOL fResult;
3680
3681  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3682                                  DRQ_WRITECONSOLEOUTPUTW,
3683                                  (ULONG)pchiSrcBuffer,
3684                                  COORD2ULONG(coordSrcBufferSize),
3685                                  COORD2ULONG(coordSrcBufferCoord),
3686                                  (ULONG)psrctDestRect);
3687
3688  return fResult;
3689}
3690
3691/*****************************************************************************
3692 * Name      :
3693 * Purpose   :
3694 * Parameters:
3695 * Variables :
3696 * Result    :
3697 * Remark    :
3698 * Status    :
3699 *
3700 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3701 *****************************************************************************/
3702
3703BOOL WIN32API WriteConsoleOutputAttribute(HANDLE  hConsoleOutput,
3704                                          LPWORD  lpwAttribute,
3705                                          DWORD   cWriteCells,
3706                                          COORD   coordWriteCoord,
3707                                          LPDWORD lpcNumberWritten)
3708{
3709  BOOL fResult;
3710
3711  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3712                                  DRQ_WRITECONSOLEOUTPUTATTRIBUTE,
3713                                  (ULONG)lpwAttribute,
3714                                  (ULONG)cWriteCells,
3715                                  COORD2ULONG(coordWriteCoord),
3716                                  (ULONG)lpcNumberWritten);
3717
3718  return fResult;
3719}
3720
3721
3722/*****************************************************************************
3723 * Name      :
3724 * Purpose   :
3725 * Parameters:
3726 * Variables :
3727 * Result    :
3728 * Remark    :
3729 * Status    :
3730 *
3731 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3732 *****************************************************************************/
3733
3734BOOL WIN32API WriteConsoleOutputCharacterA(HANDLE  hConsoleOutput,
3735                                           LPTSTR  lpWriteBuffer,
3736                                           DWORD   cchWrite,
3737                                           COORD   coordWriteCoord,
3738                                           LPDWORD lpcWritten)
3739{
3740  BOOL fResult;
3741
3742  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3743                                  DRQ_WRITECONSOLEOUTPUTCHARACTERA,
3744                                  (ULONG)lpWriteBuffer,
3745                                  (ULONG)cchWrite,
3746                                  COORD2ULONG(coordWriteCoord),
3747                                  (ULONG)lpcWritten);
3748
3749  return fResult;
3750}
3751
3752
3753/*****************************************************************************
3754 * Name      :
3755 * Purpose   :
3756 * Parameters:
3757 * Variables :
3758 * Result    :
3759 * Remark    :
3760 * Status    :
3761 *
3762 * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
3763 *****************************************************************************/
3764
3765BOOL WIN32API WriteConsoleOutputCharacterW(HANDLE  hConsoleOutput,
3766                                           LPTSTR  lpWriteBuffer,
3767                                           DWORD   cchWrite,
3768                                           COORD   coordWriteCoord,
3769                                           LPDWORD lpcWritten)
3770{
3771  BOOL fResult;
3772
3773  fResult = (BOOL)HMDeviceRequest(hConsoleOutput,
3774                                  DRQ_WRITECONSOLEOUTPUTCHARACTERW,
3775                                  (ULONG)lpWriteBuffer,
3776                                  (ULONG)cchWrite,
3777                                  COORD2ULONG(coordWriteCoord),
3778                                  (ULONG)lpcWritten);
3779
3780  return fResult;
3781}
3782
3783} // extern "C"
Note: See TracBrowser for help on using the repository browser.