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

Last change on this file since 5057 was 5034, checked in by bird, 25 years ago

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