24945526539acb1b7ac3e909d9ebd78e3d39910a
[reactos.git] / reactos / subsys / csrss / win32csr / guiconsole.c
1 /* $Id$
2 *
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS system libraries
5 * FILE: subsys/csrss/win32csr/guiconsole.c
6 * PURPOSE: Implementation of gui-mode consoles
7 */
8
9 /* INCLUDES ******************************************************************/
10
11 #include "w32csr.h"
12
13 #define NDEBUG
14 #include <debug.h>
15
16 /* Not defined in any header file */
17 extern VOID STDCALL PrivateCsrssManualGuiCheck(LONG Check);
18
19 /* GLOBALS *******************************************************************/
20
21 typedef struct GUI_CONSOLE_DATA_TAG
22 {
23 HFONT Font;
24 unsigned CharWidth;
25 unsigned CharHeight;
26 PWCHAR LineBuffer;
27 BOOL CursorBlinkOn;
28 BOOL ForceCursorOff;
29 CRITICAL_SECTION Lock;
30 HDC MemoryDC;
31 HBITMAP MemoryBitmap;
32 RECT Selection;
33 POINT SelectionStart;
34 BOOL MouseDown;
35 } GUI_CONSOLE_DATA, *PGUI_CONSOLE_DATA;
36
37 #ifndef WM_APP
38 #define WM_APP 0x8000
39 #endif
40 #define PM_CREATE_CONSOLE (WM_APP + 1)
41 #define PM_DESTROY_CONSOLE (WM_APP + 2)
42
43 #define CURSOR_BLINK_TIME 500
44
45 static BOOL ConsInitialized = FALSE;
46 static HWND NotifyWnd;
47
48 /* FUNCTIONS *****************************************************************/
49
50 static VOID FASTCALL
51 GuiConsoleGetDataPointers(HWND hWnd, PCSRSS_CONSOLE *Console, PGUI_CONSOLE_DATA *GuiData)
52 {
53 *Console = (PCSRSS_CONSOLE) GetWindowLongPtrW(hWnd, GWL_USERDATA);
54 *GuiData = (NULL == *Console ? NULL : (*Console)->PrivateData);
55 }
56
57 static BOOL FASTCALL
58 GuiConsoleHandleNcCreate(HWND hWnd, CREATESTRUCTW *Create)
59 {
60 RECT Rect;
61 PCSRSS_CONSOLE Console = (PCSRSS_CONSOLE) Create->lpCreateParams;
62 PGUI_CONSOLE_DATA GuiData;
63 HDC Dc;
64 HFONT OldFont;
65 TEXTMETRICW Metrics;
66
67 GuiData = HeapAlloc(Win32CsrApiHeap, HEAP_ZERO_MEMORY,
68 sizeof(GUI_CONSOLE_DATA) +
69 (Console->Size.X + 1) * sizeof(WCHAR));
70 if (NULL == GuiData)
71 {
72 DPRINT1("GuiConsoleNcCreate: HeapAlloc failed\n");
73 return FALSE;
74 }
75
76 InitializeCriticalSection(&GuiData->Lock);
77
78 GuiData->LineBuffer = (PWCHAR)(GuiData + 1);
79
80 GuiData->Font = CreateFontW(12, 0, 0, TA_BASELINE, FW_NORMAL,
81 FALSE, FALSE, FALSE, OEM_CHARSET,
82 OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
83 NONANTIALIASED_QUALITY, FIXED_PITCH | FF_DONTCARE,
84 L"Bitstream Vera Sans Mono");
85 if (NULL == GuiData->Font)
86 {
87 DPRINT1("GuiConsoleNcCreate: CreateFont failed\n");
88 DeleteCriticalSection(&GuiData->Lock);
89 HeapFree(Win32CsrApiHeap, 0, GuiData);
90 return FALSE;
91 }
92 Dc = GetDC(hWnd);
93 if (NULL == Dc)
94 {
95 DPRINT1("GuiConsoleNcCreate: GetDC failed\n");
96 DeleteObject(GuiData->Font);
97 DeleteCriticalSection(&GuiData->Lock);
98 HeapFree(Win32CsrApiHeap, 0, GuiData);
99 return FALSE;
100 }
101 OldFont = SelectObject(Dc, GuiData->Font);
102 if (NULL == OldFont)
103 {
104 DPRINT1("GuiConsoleNcCreate: SelectObject failed\n");
105 ReleaseDC(hWnd, Dc);
106 DeleteObject(GuiData->Font);
107 DeleteCriticalSection(&GuiData->Lock);
108 HeapFree(Win32CsrApiHeap, 0, GuiData);
109 return FALSE;
110 }
111 if (! GetTextMetricsW(Dc, &Metrics))
112 {
113 DPRINT1("GuiConsoleNcCreate: GetTextMetrics failed\n");
114 SelectObject(Dc, OldFont);
115 ReleaseDC(hWnd, Dc);
116 DeleteObject(GuiData->Font);
117 DeleteCriticalSection(&GuiData->Lock);
118 HeapFree(Win32CsrApiHeap, 0, GuiData);
119 return FALSE;
120 }
121 GuiData->CharWidth = Metrics.tmMaxCharWidth;
122 GuiData->CharHeight = Metrics.tmHeight + Metrics.tmExternalLeading;
123 SelectObject(Dc, OldFont);
124
125 GuiData->MemoryDC = CreateCompatibleDC(Dc);
126 GuiData->MemoryBitmap = CreateCompatibleBitmap(Dc,
127 Console->Size.X * GuiData->CharWidth,
128 Console->Size.Y * GuiData->CharHeight);
129 /* NOTE: Don't delete the "first bitmap", it's done in DeleteDC. */
130 SelectObject(GuiData->MemoryDC, GuiData->MemoryBitmap);
131 /* NOTE: Don't delete stock font. */
132 SelectObject(GuiData->MemoryDC, GuiData->Font);
133
134 ReleaseDC(hWnd, Dc);
135 GuiData->CursorBlinkOn = TRUE;
136 GuiData->ForceCursorOff = FALSE;
137
138 GuiData->Selection.left = -1;
139
140 Console->PrivateData = GuiData;
141 SetWindowLongPtrW(hWnd, GWL_USERDATA, (DWORD_PTR) Console);
142
143 GetWindowRect(hWnd, &Rect);
144 Rect.right = Rect.left + Console->Size.X * GuiData->CharWidth +
145 2 * GetSystemMetrics(SM_CXFIXEDFRAME);
146 Rect.bottom = Rect.top + Console->Size.Y * GuiData->CharHeight +
147 2 * GetSystemMetrics(SM_CYFIXEDFRAME) + GetSystemMetrics(SM_CYCAPTION);
148 MoveWindow(hWnd, Rect.left, Rect.top, Rect.right - Rect.left,
149 Rect.bottom - Rect.top, FALSE);
150
151 SetTimer(hWnd, 1, CURSOR_BLINK_TIME, NULL);
152
153 return (BOOL) DefWindowProcW(hWnd, WM_NCCREATE, 0, (LPARAM) Create);
154 }
155
156 static COLORREF FASTCALL
157 GuiConsoleRGBFromAttribute(BYTE Attribute)
158 {
159 int Red = (Attribute & 0x04 ? (Attribute & 0x08 ? 0xff : 0x80) : 0x00);
160 int Green = (Attribute & 0x02 ? (Attribute & 0x08 ? 0xff : 0x80) : 0x00);
161 int Blue = (Attribute & 0x01 ? (Attribute & 0x08 ? 0xff : 0x80) : 0x00);
162
163 return RGB(Red, Green, Blue);
164 }
165
166 static VOID FASTCALL
167 GuiConsoleSetTextColors(HDC Dc, BYTE Attribute)
168 {
169 SetTextColor(Dc, GuiConsoleRGBFromAttribute(Attribute & 0x0f));
170 SetBkColor(Dc, GuiConsoleRGBFromAttribute((Attribute & 0xf0) >> 4));
171 }
172
173 static VOID FASTCALL
174 GuiConsoleGetLogicalCursorPos(PCSRSS_SCREEN_BUFFER Buff, ULONG *CursorX, ULONG *CursorY)
175 {
176 *CursorX = Buff->CurrentX;
177 if (Buff->CurrentY < Buff->ShowY)
178 {
179 *CursorY = Buff->MaxY - Buff->ShowY + Buff->CurrentY;
180 }
181 else
182 {
183 *CursorY = Buff->CurrentY - Buff->ShowY;
184 }
185 }
186
187
188 static VOID FASTCALL
189 GuiConsoleUpdateSelection(HWND hWnd, PRECT rc, PGUI_CONSOLE_DATA GuiData)
190 {
191 RECT oldRect = GuiData->Selection;
192
193 if(rc != NULL)
194 {
195 RECT changeRect = *rc;
196
197 GuiData->Selection = *rc;
198
199 changeRect.left *= GuiData->CharWidth;
200 changeRect.top *= GuiData->CharHeight;
201 changeRect.right *= GuiData->CharWidth;
202 changeRect.bottom *= GuiData->CharHeight;
203
204 if(rc->left != oldRect.left ||
205 rc->top != oldRect.top ||
206 rc->right != oldRect.right ||
207 rc->bottom != oldRect.bottom)
208 {
209 if(oldRect.left != -1)
210 {
211 HRGN rgn1, rgn2;
212
213 oldRect.left *= GuiData->CharWidth;
214 oldRect.top *= GuiData->CharHeight;
215 oldRect.right *= GuiData->CharWidth;
216 oldRect.bottom *= GuiData->CharHeight;
217
218 /* calculate the region that needs to be updated */
219 if((rgn1 = CreateRectRgnIndirect(&oldRect)))
220 {
221 if((rgn2 = CreateRectRgnIndirect(&changeRect)))
222 {
223 if(CombineRgn(rgn1, rgn2, rgn1, RGN_XOR) != ERROR)
224 {
225 InvalidateRgn(hWnd, rgn1, FALSE);
226 }
227
228 DeleteObject(rgn2);
229 }
230 DeleteObject(rgn1);
231 }
232 }
233 else
234 {
235 InvalidateRect(hWnd, &changeRect, FALSE);
236 }
237 }
238 }
239 else if(oldRect.left != -1)
240 {
241 /* clear the selection */
242 GuiData->Selection.left = -1;
243 oldRect.left *= GuiData->CharWidth;
244 oldRect.top *= GuiData->CharHeight;
245 oldRect.right *= GuiData->CharWidth;
246 oldRect.bottom *= GuiData->CharHeight;
247 InvalidateRect(hWnd, &oldRect, FALSE);
248 }
249 }
250
251
252 VOID FASTCALL
253 GuiConsoleUpdateBitmap(HWND hWnd, RECT rc)
254 {
255 PCSRSS_CONSOLE Console;
256 PGUI_CONSOLE_DATA GuiData;
257 PCSRSS_SCREEN_BUFFER Buff;
258 HDC Dc;
259 ULONG TopLine, BottomLine, LeftChar, RightChar;
260 ULONG Line, Char, Start;
261 PBYTE From;
262 PWCHAR To;
263 BYTE LastAttribute, Attribute;
264 ULONG CursorX, CursorY, CursorHeight;
265 HBRUSH CursorBrush, OldBrush;
266
267 GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
268 if (NULL != Console && NULL != GuiData && NULL != Console->ActiveBuffer)
269 {
270 Buff = Console->ActiveBuffer;
271 EnterCriticalSection(&Buff->Header.Lock);
272 Dc = GetDC(hWnd);
273 if (rc.right <= rc.left || rc.bottom <= rc.top)
274 {
275 ReleaseDC(hWnd, Dc);
276 LeaveCriticalSection(&Buff->Header.Lock);
277 return;
278 }
279
280 EnterCriticalSection(&GuiData->Lock);
281
282 TopLine = rc.top / GuiData->CharHeight;
283 BottomLine = (rc.bottom + (GuiData->CharHeight - 1)) / GuiData->CharHeight - 1;
284 LeftChar = rc.left / GuiData->CharWidth;
285 RightChar = (rc.right + (GuiData->CharWidth - 1)) / GuiData->CharWidth - 1;
286 LastAttribute = Buff->Buffer[(TopLine * Buff->MaxX + LeftChar) * 2 + 1];
287 GuiConsoleSetTextColors(GuiData->MemoryDC, LastAttribute);
288
289 for (Line = TopLine; Line <= BottomLine; Line++)
290 {
291 if (Line + Buff->ShowY < Buff->MaxY)
292 {
293 From = Buff->Buffer + ((Line + Buff->ShowY) * Buff->MaxX + LeftChar) * 2;
294 }
295 else
296 {
297 From = Buff->Buffer +
298 ((Line - (Buff->MaxY - Buff->ShowY)) * Buff->MaxX + LeftChar) * 2;
299 }
300 Start = LeftChar;
301 To = GuiData->LineBuffer;
302 for (Char = LeftChar; Char <= RightChar; Char++)
303 {
304 if (*(From + 1) != LastAttribute)
305 {
306 TextOutW(GuiData->MemoryDC, Start * GuiData->CharWidth, Line * GuiData->CharHeight,
307 GuiData->LineBuffer, Char - Start);
308 Start = Char;
309 To = GuiData->LineBuffer;
310 Attribute = *(From + 1);
311 if (Attribute != LastAttribute)
312 {
313 GuiConsoleSetTextColors(GuiData->MemoryDC, Attribute);
314 LastAttribute = Attribute;
315 }
316 }
317 MultiByteToWideChar(Console->OutputCodePage, 0, (PCHAR)From, 1, To, 1);
318 To++;
319 From += 2;
320 }
321 TextOutW(GuiData->MemoryDC, Start * GuiData->CharWidth, Line * GuiData->CharHeight,
322 GuiData->LineBuffer, RightChar - Start + 1);
323 }
324
325 if (Buff->CursorInfo.bVisible && GuiData->CursorBlinkOn
326 &&! GuiData->ForceCursorOff)
327 {
328 GuiConsoleGetLogicalCursorPos(Buff, &CursorX, &CursorY);
329 if (LeftChar <= CursorX && CursorX <= RightChar &&
330 TopLine <= CursorY && CursorY <= BottomLine)
331 {
332 CursorHeight = (GuiData->CharHeight * Buff->CursorInfo.dwSize) / 100;
333 if (CursorHeight < 1)
334 {
335 CursorHeight = 1;
336 }
337 From = Buff->Buffer + (Buff->CurrentY * Buff->MaxX + Buff->CurrentX) * 2 + 1;
338 CursorBrush = CreateSolidBrush(GuiConsoleRGBFromAttribute(*From));
339 OldBrush = SelectObject(GuiData->MemoryDC, CursorBrush);
340 PatBlt(GuiData->MemoryDC, CursorX * GuiData->CharWidth,
341 CursorY * GuiData->CharHeight + (GuiData->CharHeight - CursorHeight),
342 GuiData->CharWidth, CursorHeight, PATCOPY);
343 SelectObject(GuiData->MemoryDC, OldBrush);
344 DeleteObject(CursorBrush);
345 }
346 }
347
348 LeaveCriticalSection(&GuiData->Lock);
349 ReleaseDC(hWnd, Dc);
350 LeaveCriticalSection(&Buff->Header.Lock);
351 InvalidateRect(hWnd, &rc, FALSE);
352 }
353 }
354
355 VOID FASTCALL
356 GuiConsoleHandlePaint(HWND hWnd)
357 {
358 PAINTSTRUCT Ps;
359 HDC Dc;
360 PCSRSS_CONSOLE Console;
361 PGUI_CONSOLE_DATA GuiData;
362
363 GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
364 if (NULL != Console && NULL != GuiData)
365 {
366 EnterCriticalSection(&GuiData->Lock);
367 Dc = BeginPaint (hWnd, &Ps);
368 BitBlt(Dc, Ps.rcPaint.left, Ps.rcPaint.top,
369 Ps.rcPaint.right - Ps.rcPaint.left + 1,
370 Ps.rcPaint.bottom - Ps.rcPaint.top + 1, GuiData->MemoryDC,
371 Ps.rcPaint.left, Ps.rcPaint.top, SRCCOPY);
372
373 if (GuiData->Selection.left != -1)
374 {
375 RECT rc = GuiData->Selection;
376
377 rc.left *= GuiData->CharWidth;
378 rc.top *= GuiData->CharHeight;
379 rc.right *= GuiData->CharWidth;
380 rc.bottom *= GuiData->CharHeight;
381
382 if (IntersectRect(&rc, &Ps.rcPaint, &rc))
383 {
384 PatBlt(Dc, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, DSTINVERT);
385 }
386 }
387
388 EndPaint (hWnd, &Ps);
389 LeaveCriticalSection(&GuiData->Lock);
390 }
391 else
392 {
393 Dc = BeginPaint (hWnd, &Ps);
394 EndPaint (hWnd, &Ps);
395 }
396 }
397
398 static VOID FASTCALL
399 GuiConsoleHandleKey(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
400 {
401 PCSRSS_CONSOLE Console;
402 PGUI_CONSOLE_DATA GuiData;
403 MSG Message;
404
405 GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
406 Message.hwnd = hWnd;
407 Message.message = msg;
408 Message.wParam = wParam;
409 Message.lParam = lParam;
410
411 if(msg == WM_CHAR || msg == WM_SYSKEYDOWN)
412 {
413 /* clear the selection */
414 GuiConsoleUpdateSelection(hWnd, NULL, GuiData);
415 }
416
417 ConioProcessKey(&Message, Console, FALSE);
418 }
419
420 static VOID FASTCALL
421 GuiIntDrawRegion(PGUI_CONSOLE_DATA GuiData, HWND Wnd, RECT *Region)
422 {
423 RECT RegionRect;
424
425 RegionRect.left = Region->left * GuiData->CharWidth;
426 RegionRect.top = Region->top * GuiData->CharHeight;
427 RegionRect.right = (Region->right + 1) * GuiData->CharWidth;
428 RegionRect.bottom = (Region->bottom + 1) * GuiData->CharHeight;
429
430 GuiConsoleUpdateBitmap(Wnd, RegionRect);
431 }
432
433 static VOID STDCALL
434 GuiDrawRegion(PCSRSS_CONSOLE Console, RECT *Region)
435 {
436 PGUI_CONSOLE_DATA GuiData = (PGUI_CONSOLE_DATA) Console->PrivateData;
437
438 if (NULL == Console->hWindow || NULL == GuiData)
439 {
440 return;
441 }
442
443 GuiIntDrawRegion(GuiData, Console->hWindow, Region);
444 }
445
446 static VOID FASTCALL
447 GuiInvalidateCell(PGUI_CONSOLE_DATA GuiData, HWND Wnd, UINT x, UINT y)
448 {
449 RECT CellRect;
450
451 CellRect.left = x;
452 CellRect.top = y;
453 CellRect.right = x;
454 CellRect.bottom = y;
455
456 GuiIntDrawRegion(GuiData, Wnd, &CellRect);
457 }
458
459 static VOID STDCALL
460 GuiWriteStream(PCSRSS_CONSOLE Console, RECT *Region, LONG CursorStartX, LONG CursorStartY,
461 UINT ScrolledLines, CHAR *Buffer, UINT Length)
462 {
463 PGUI_CONSOLE_DATA GuiData = (PGUI_CONSOLE_DATA) Console->PrivateData;
464 PCSRSS_SCREEN_BUFFER Buff = Console->ActiveBuffer;
465 LONG CursorEndX, CursorEndY;
466 RECT Source, Dest;
467
468 if (NULL == Console->hWindow || NULL == GuiData)
469 {
470 return;
471 }
472
473 if (0 != ScrolledLines)
474 {
475 Source.left = 0;
476 Source.top = ScrolledLines;
477 Source.right = Console->Size.X - 1;
478 Source.bottom = ScrolledLines + Region->top - 1;
479 Dest.left = 0;
480 Dest.top = 0;
481 Dest.right = Console->Size.X - 1;
482 Dest.bottom = Region->top - 1;
483
484 GuiConsoleCopyRegion(Console->hWindow, &Source, &Dest);
485 }
486
487 GuiIntDrawRegion(GuiData, Console->hWindow, Region);
488
489 if (CursorStartX < Region->left || Region->right < CursorStartX
490 || CursorStartY < Region->top || Region->bottom < CursorStartY)
491 {
492 GuiInvalidateCell(GuiData, Console->hWindow, CursorStartX, CursorStartY);
493 }
494
495 ConioPhysicalToLogical(Buff, Buff->CurrentX, Buff->CurrentY,
496 &CursorEndX, &CursorEndY);
497 if ((CursorEndX < Region->left || Region->right < CursorEndX
498 || CursorEndY < Region->top || Region->bottom < CursorEndY)
499 && (CursorEndX != CursorStartX || CursorEndY != CursorStartY))
500 {
501 GuiInvalidateCell(GuiData, Console->hWindow, CursorEndX, CursorEndY);
502 }
503 }
504
505 static BOOL STDCALL
506 GuiSetCursorInfo(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buff)
507 {
508 RECT UpdateRect;
509
510 if (Console->ActiveBuffer == Buff)
511 {
512 ConioPhysicalToLogical(Buff, Buff->CurrentX, Buff->CurrentY,
513 &UpdateRect.left, &UpdateRect.top);
514 UpdateRect.right = UpdateRect.left;
515 UpdateRect.bottom = UpdateRect.top;
516 ConioDrawRegion(Console, &UpdateRect);
517 }
518
519 return TRUE;
520 }
521
522 static BOOL STDCALL
523 GuiSetScreenInfo(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buff, UINT OldCursorX, UINT OldCursorY)
524 {
525 RECT UpdateRect;
526
527 if (Console->ActiveBuffer == Buff)
528 {
529 /* Redraw char at old position (removes cursor) */
530 UpdateRect.left = OldCursorX;
531 UpdateRect.top = OldCursorY;
532 UpdateRect.right = OldCursorX;
533 UpdateRect.bottom = OldCursorY;
534 ConioDrawRegion(Console, &UpdateRect);
535 /* Redraw char at new position (shows cursor) */
536 ConioPhysicalToLogical(Buff, Buff->CurrentX, Buff->CurrentY,
537 &(UpdateRect.left), &(UpdateRect.top));
538 UpdateRect.right = UpdateRect.left;
539 UpdateRect.bottom = UpdateRect.top;
540 ConioDrawRegion(Console, &UpdateRect);
541 }
542
543 return TRUE;
544 }
545
546 static VOID FASTCALL
547 GuiConsoleHandleTimer(HWND hWnd)
548 {
549 PCSRSS_CONSOLE Console;
550 PGUI_CONSOLE_DATA GuiData;
551 RECT CursorRect;
552 ULONG CursorX, CursorY;
553
554 GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
555 GuiData->CursorBlinkOn = ! GuiData->CursorBlinkOn;
556
557 GuiConsoleGetLogicalCursorPos(Console->ActiveBuffer, &CursorX, &CursorY);
558 CursorRect.left = CursorX;
559 CursorRect.top = CursorY;
560 CursorRect.right = CursorX;
561 CursorRect.bottom = CursorY;
562 GuiDrawRegion(Console, &CursorRect);
563 }
564
565 static VOID FASTCALL
566 GuiConsoleHandleClose(HWND hWnd)
567 {
568 PCSRSS_CONSOLE Console;
569 PGUI_CONSOLE_DATA GuiData;
570 PLIST_ENTRY current_entry;
571 PCSRSS_PROCESS_DATA current;
572
573 GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
574
575 EnterCriticalSection(&Console->Header.Lock);
576
577 current_entry = Console->ProcessList.Flink;
578 while (current_entry != &Console->ProcessList)
579 {
580 current = CONTAINING_RECORD(current_entry, CSRSS_PROCESS_DATA, ProcessEntry);
581 current_entry = current_entry->Flink;
582
583 ConioConsoleCtrlEvent(CTRL_CLOSE_EVENT, current);
584 }
585
586 LeaveCriticalSection(&Console->Header.Lock);
587 }
588
589 static VOID FASTCALL
590 GuiConsoleHandleNcDestroy(HWND hWnd)
591 {
592 PCSRSS_CONSOLE Console;
593 PGUI_CONSOLE_DATA GuiData;
594
595 GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
596 KillTimer(hWnd, 1);
597 Console->PrivateData = NULL;
598 DeleteDC(GuiData->MemoryDC);
599 DeleteCriticalSection(&GuiData->Lock);
600 HeapFree(Win32CsrApiHeap, 0, GuiData);
601 }
602
603 static VOID FASTCALL
604 GuiConsoleLeftMouseDown(HWND hWnd, LPARAM lParam)
605 {
606 PCSRSS_CONSOLE Console;
607 PGUI_CONSOLE_DATA GuiData;
608 POINTS pt;
609 RECT rc;
610
611 GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
612 if (Console == NULL || GuiData == NULL) return;
613
614 pt = MAKEPOINTS(lParam);
615
616 rc.left = pt.x / GuiData->CharWidth;
617 rc.top = pt.y / GuiData->CharHeight;
618 rc.right = rc.left + 1;
619 rc.bottom = rc.top + 1;
620
621 GuiData->SelectionStart.x = rc.left;
622 GuiData->SelectionStart.y = rc.top;
623
624 SetCapture(hWnd);
625
626 GuiData->MouseDown = TRUE;
627
628 GuiConsoleUpdateSelection(hWnd, &rc, GuiData);
629 }
630
631 static VOID FASTCALL
632 GuiConsoleLeftMouseUp(HWND hWnd, LPARAM lParam)
633 {
634 PCSRSS_CONSOLE Console;
635 PGUI_CONSOLE_DATA GuiData;
636 RECT rc;
637 POINTS pt;
638
639 GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
640 if (Console == NULL || GuiData == NULL) return;
641 if (GuiData->Selection.left == -1 || !GuiData->MouseDown) return;
642
643 pt = MAKEPOINTS(lParam);
644
645 rc.left = GuiData->SelectionStart.x;
646 rc.top = GuiData->SelectionStart.y;
647 rc.right = (pt.x >= 0 ? (pt.x / GuiData->CharWidth) + 1 : 0);
648 rc.bottom = (pt.y >= 0 ? (pt.y / GuiData->CharHeight) + 1 : 0);
649
650 /* exchange left/top with right/bottom if required */
651 if(rc.left >= rc.right)
652 {
653 LONG tmp;
654 tmp = rc.left;
655 rc.left = max(rc.right - 1, 0);
656 rc.right = tmp + 1;
657 }
658 if(rc.top >= rc.bottom)
659 {
660 LONG tmp;
661 tmp = rc.top;
662 rc.top = max(rc.bottom - 1, 0);
663 rc.bottom = tmp + 1;
664 }
665
666 GuiData->MouseDown = FALSE;
667
668 GuiConsoleUpdateSelection(hWnd, &rc, GuiData);
669
670 ReleaseCapture();
671 }
672
673 static VOID FASTCALL
674 GuiConsoleMouseMove(HWND hWnd, WPARAM wParam, LPARAM lParam)
675 {
676 PCSRSS_CONSOLE Console;
677 PGUI_CONSOLE_DATA GuiData;
678 RECT rc;
679 POINTS pt;
680
681 if (!(wParam & MK_LBUTTON)) return;
682
683 GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
684 if (Console == NULL || GuiData == NULL || !GuiData->MouseDown) return;
685
686 pt = MAKEPOINTS(lParam);
687
688 rc.left = GuiData->SelectionStart.x;
689 rc.top = GuiData->SelectionStart.y;
690 rc.right = (pt.x >= 0 ? (pt.x / GuiData->CharWidth) + 1 : 0);
691 rc.bottom = (pt.y >= 0 ? (pt.y / GuiData->CharHeight) + 1 : 0);
692
693 /* exchange left/top with right/bottom if required */
694 if(rc.left >= rc.right)
695 {
696 LONG tmp;
697 tmp = rc.left;
698 rc.left = max(rc.right - 1, 0);
699 rc.right = tmp + 1;
700 }
701 if(rc.top >= rc.bottom)
702 {
703 LONG tmp;
704 tmp = rc.top;
705 rc.top = max(rc.bottom - 1, 0);
706 rc.bottom = tmp + 1;
707 }
708
709 GuiConsoleUpdateSelection(hWnd, &rc, GuiData);
710 }
711
712 static VOID FASTCALL
713 GuiConsoleRightMouseDown(HWND hWnd)
714 {
715 PCSRSS_CONSOLE Console;
716 PGUI_CONSOLE_DATA GuiData;
717
718 GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
719 if (Console == NULL || GuiData == NULL) return;
720
721 if (GuiData->Selection.left == -1)
722 {
723 /* FIXME - paste text from clipboard */
724 }
725 else
726 {
727 /* FIXME - copy selection to clipboard */
728
729 GuiConsoleUpdateSelection(hWnd, NULL, GuiData);
730 }
731
732 }
733
734 static LRESULT CALLBACK
735 GuiConsoleWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
736 {
737 LRESULT Result = 0;
738
739 switch(msg)
740 {
741 case WM_NCCREATE:
742 Result = (LRESULT) GuiConsoleHandleNcCreate(hWnd, (CREATESTRUCTW *) lParam);
743 break;
744 case WM_PAINT:
745 GuiConsoleHandlePaint(hWnd);
746 break;
747 case WM_KEYDOWN:
748 case WM_KEYUP:
749 case WM_SYSKEYDOWN:
750 case WM_SYSKEYUP:
751 case WM_CHAR:
752 GuiConsoleHandleKey(hWnd, msg, wParam, lParam);
753 break;
754 case WM_TIMER:
755 GuiConsoleHandleTimer(hWnd);
756 break;
757 case WM_CLOSE:
758 GuiConsoleHandleClose(hWnd);
759 break;
760 case WM_NCDESTROY:
761 GuiConsoleHandleNcDestroy(hWnd);
762 break;
763 case WM_LBUTTONDOWN:
764 GuiConsoleLeftMouseDown(hWnd, lParam);
765 break;
766 case WM_LBUTTONUP:
767 GuiConsoleLeftMouseUp(hWnd, lParam);
768 break;
769 case WM_RBUTTONDOWN:
770 GuiConsoleRightMouseDown(hWnd);
771 break;
772 case WM_MOUSEMOVE:
773 GuiConsoleMouseMove(hWnd, wParam, lParam);
774 break;
775 default:
776 Result = DefWindowProcW(hWnd, msg, wParam, lParam);
777 break;
778 }
779
780 return Result;
781 }
782
783 static LRESULT CALLBACK
784 GuiConsoleNotifyWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
785 {
786 HWND NewWindow;
787 LONG WindowCount;
788 MSG Msg;
789 PWCHAR Buffer, Title;
790 PCSRSS_CONSOLE Console = (PCSRSS_CONSOLE) lParam;
791
792 switch(msg)
793 {
794 case WM_CREATE:
795 SetWindowLongW(hWnd, GWL_USERDATA, 0);
796 return 0;
797 case PM_CREATE_CONSOLE:
798 Buffer = HeapAlloc(Win32CsrApiHeap, 0,
799 Console->Title.Length + sizeof(WCHAR));
800 if (NULL != Buffer)
801 {
802 memcpy(Buffer, Console->Title.Buffer, Console->Title.Length);
803 Buffer[Console->Title.Length / sizeof(WCHAR)] = L'\0';
804 Title = Buffer;
805 }
806 else
807 {
808 Title = L"";
809 }
810 NewWindow = CreateWindowW(L"ConsoleWindowClass",
811 Title,
812 WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
813 CW_USEDEFAULT,
814 CW_USEDEFAULT,
815 CW_USEDEFAULT,
816 CW_USEDEFAULT,
817 NULL,
818 NULL,
819 (HINSTANCE) GetModuleHandleW(NULL),
820 (PVOID) Console);
821 if (NULL != Buffer)
822 {
823 HeapFree(Win32CsrApiHeap, 0, Buffer);
824 }
825 Console->hWindow = NewWindow;
826 if (NULL != NewWindow)
827 {
828 SetWindowLongW(hWnd, GWL_USERDATA, GetWindowLongW(hWnd, GWL_USERDATA) + 1);
829 ShowWindow(NewWindow, SW_SHOW);
830 }
831 return (LRESULT) NewWindow;
832 case PM_DESTROY_CONSOLE:
833 /* Window creation is done using a PostMessage(), so it's possible that the
834 * window that we want to destroy doesn't exist yet. So first empty the message
835 * queue */
836 while(PeekMessageW(&Msg, NULL, 0, 0, PM_REMOVE))
837 {
838 TranslateMessage(&Msg);
839 DispatchMessageW(&Msg);
840 }
841 DestroyWindow(Console->hWindow);
842 Console->hWindow = NULL;
843 WindowCount = GetWindowLongW(hWnd, GWL_USERDATA);
844 WindowCount--;
845 SetWindowLongW(hWnd, GWL_USERDATA, WindowCount);
846 if (0 == WindowCount)
847 {
848 NotifyWnd = NULL;
849 DestroyWindow(hWnd);
850 PrivateCsrssManualGuiCheck(-1);
851 PostQuitMessage(0);
852 }
853 return 0;
854 default:
855 return DefWindowProcW(hWnd, msg, wParam, lParam);
856 }
857 }
858
859 static DWORD STDCALL
860 GuiConsoleGuiThread(PVOID Data)
861 {
862 MSG msg;
863 PHANDLE GraphicsStartupEvent = (PHANDLE) Data;
864
865 NotifyWnd = CreateWindowW(L"Win32CsrCreateNotify",
866 L"",
867 WS_OVERLAPPEDWINDOW,
868 CW_USEDEFAULT,
869 CW_USEDEFAULT,
870 CW_USEDEFAULT,
871 CW_USEDEFAULT,
872 NULL,
873 NULL,
874 (HINSTANCE) GetModuleHandleW(NULL),
875 NULL);
876 if (NULL == NotifyWnd)
877 {
878 PrivateCsrssManualGuiCheck(-1);
879 SetEvent(*GraphicsStartupEvent);
880 return 1;
881 }
882
883 SetEvent(*GraphicsStartupEvent);
884
885 while(GetMessageW(&msg, NULL, 0, 0))
886 {
887 TranslateMessage(&msg);
888 DispatchMessageW(&msg);
889 }
890
891 return 1;
892 }
893
894 static BOOL FASTCALL
895 GuiInit(VOID)
896 {
897 WNDCLASSEXW wc;
898
899 if (NULL == NotifyWnd)
900 {
901 PrivateCsrssManualGuiCheck(+1);
902 }
903
904 wc.cbSize = sizeof(WNDCLASSEXW);
905 wc.lpszClassName = L"Win32CsrCreateNotify";
906 wc.lpfnWndProc = GuiConsoleNotifyWndProc;
907 wc.style = 0;
908 wc.hInstance = (HINSTANCE) GetModuleHandleW(NULL);
909 wc.hIcon = NULL;
910 wc.hCursor = NULL;
911 wc.hbrBackground = NULL;
912 wc.lpszMenuName = NULL;
913 wc.cbClsExtra = 0;
914 wc.cbWndExtra = 0;
915 wc.hIconSm = NULL;
916 if (RegisterClassExW(&wc) == 0)
917 {
918 DPRINT1("Failed to register notify wndproc\n");
919 return FALSE;
920 }
921
922 wc.cbSize = sizeof(WNDCLASSEXW);
923 wc.lpszClassName = L"ConsoleWindowClass";
924 wc.lpfnWndProc = GuiConsoleWndProc;
925 wc.style = 0;
926 wc.hInstance = (HINSTANCE) GetModuleHandleW(NULL);
927 wc.hIcon = LoadIconW(Win32CsrDllHandle, MAKEINTRESOURCEW(1));
928 wc.hCursor = LoadCursorW(NULL, MAKEINTRESOURCEW(IDC_ARROW));
929 wc.hbrBackground = NULL;
930 wc.lpszMenuName = NULL;
931 wc.cbClsExtra = 0;
932 wc.cbWndExtra = 0;
933 wc.hIconSm = LoadImageW(Win32CsrDllHandle, MAKEINTRESOURCEW(1), IMAGE_ICON,
934 GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON),
935 LR_SHARED);
936 if (RegisterClassExW(&wc) == 0)
937 {
938 DPRINT1("Failed to register console wndproc\n");
939 return FALSE;
940 }
941
942 return TRUE;
943 }
944
945 static VOID STDCALL
946 GuiInitScreenBuffer(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buffer)
947 {
948 Buffer->DefaultAttrib = 0x0f;
949 }
950
951 STATIC BOOL STDCALL
952 GuiChangeTitle(PCSRSS_CONSOLE Console)
953 {
954 PWCHAR Buffer, Title;
955
956 Buffer = HeapAlloc(Win32CsrApiHeap, 0,
957 Console->Title.Length + sizeof(WCHAR));
958 if (NULL != Buffer)
959 {
960 memcpy(Buffer, Console->Title.Buffer, Console->Title.Length);
961 Buffer[Console->Title.Length / sizeof(WCHAR)] = L'\0';
962 Title = Buffer;
963 }
964 else
965 {
966 Title = L"";
967 }
968 SendMessageW(Console->hWindow, WM_SETTEXT, 0, (LPARAM) Title);
969 if (NULL != Buffer)
970 {
971 HeapFree(Win32CsrApiHeap, 0, Buffer);
972 }
973
974 return TRUE;
975 }
976
977 STATIC BOOL STDCALL
978 GuiChangeIcon(PCSRSS_CONSOLE Console)
979 {
980 SendMessageW(Console->hWindow, WM_SETICON, ICON_BIG, (LPARAM)Console->hWindowIcon);
981 SendMessageW(Console->hWindow, WM_SETICON, ICON_SMALL, (LPARAM)Console->hWindowIcon);
982
983 return TRUE;
984 }
985
986 static VOID STDCALL
987 GuiCleanupConsole(PCSRSS_CONSOLE Console)
988 {
989 SendMessageW(NotifyWnd, PM_DESTROY_CONSOLE, 0, (LPARAM) Console);
990 }
991
992 static CSRSS_CONSOLE_VTBL GuiVtbl =
993 {
994 GuiInitScreenBuffer,
995 GuiWriteStream,
996 GuiDrawRegion,
997 GuiSetCursorInfo,
998 GuiSetScreenInfo,
999 GuiChangeTitle,
1000 GuiCleanupConsole,
1001 GuiChangeIcon
1002 };
1003
1004 NTSTATUS FASTCALL
1005 GuiInitConsole(PCSRSS_CONSOLE Console)
1006 {
1007 HANDLE GraphicsStartupEvent;
1008 HANDLE ThreadHandle;
1009
1010 if (! ConsInitialized)
1011 {
1012 ConsInitialized = TRUE;
1013 if (! GuiInit())
1014 {
1015 ConsInitialized = FALSE;
1016 return STATUS_UNSUCCESSFUL;
1017 }
1018 }
1019
1020 Console->Vtbl = &GuiVtbl;
1021 Console->Size.X = 80;
1022 Console->Size.Y = 25;
1023 if (NULL == NotifyWnd)
1024 {
1025 GraphicsStartupEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
1026 if (NULL == GraphicsStartupEvent)
1027 {
1028 return STATUS_UNSUCCESSFUL;
1029 }
1030
1031 ThreadHandle = CreateThread(NULL,
1032 0,
1033 GuiConsoleGuiThread,
1034 (PVOID) &GraphicsStartupEvent,
1035 0,
1036 NULL);
1037 if (NULL == ThreadHandle)
1038 {
1039 NtClose(GraphicsStartupEvent);
1040 DPRINT1("Win32Csr: Failed to create graphics console thread. Expect problems\n");
1041 return STATUS_UNSUCCESSFUL;
1042 }
1043 SetThreadPriority(ThreadHandle, THREAD_PRIORITY_HIGHEST);
1044 CloseHandle(ThreadHandle);
1045
1046 WaitForSingleObject(GraphicsStartupEvent, INFINITE);
1047 CloseHandle(GraphicsStartupEvent);
1048
1049 if (NULL == NotifyWnd)
1050 {
1051 DPRINT1("Win32Csr: Failed to create notification window.\n");
1052 return STATUS_UNSUCCESSFUL;
1053 }
1054 }
1055
1056 PostMessageW(NotifyWnd, PM_CREATE_CONSOLE, 0, (LPARAM) Console);
1057
1058 return STATUS_SUCCESS;
1059 }
1060
1061 VOID STDCALL
1062 GuiConsoleCopyRegion(HWND hWnd,
1063 RECT *Source,
1064 RECT *Dest)
1065 {
1066 RECT ScrollRect;
1067 PGUI_CONSOLE_DATA GuiData;
1068 PCSRSS_CONSOLE Console;
1069
1070
1071 GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
1072
1073 ScrollRect.left = Dest->left * GuiData->CharWidth;
1074 ScrollRect.right = (Dest->right + 1) * GuiData->CharWidth;
1075 ScrollRect.top = Dest->top * GuiData->CharHeight;
1076 ScrollRect.bottom = (Dest->bottom + 1) * GuiData->CharHeight;
1077 EnterCriticalSection(&GuiData->Lock);
1078 BitBlt(GuiData->MemoryDC, ScrollRect.left, ScrollRect.top,
1079 ScrollRect.right - ScrollRect.left, ScrollRect.bottom - ScrollRect.top,
1080 GuiData->MemoryDC, Source->left * GuiData->CharWidth, Source->top * GuiData->CharHeight, SRCCOPY);
1081
1082 LeaveCriticalSection(&GuiData->Lock);
1083
1084 InvalidateRect(hWnd, &ScrollRect, FALSE);
1085 }
1086
1087 /* EOF */