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

Last change on this file since 120 was 120, checked in by sandervl, 26 years ago

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