reactos/subsystems/win32/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 #define NDEBUG
  12 #include "w32csr.h"
  13 #include <debug.h>
  14
  15 /* Not defined in any header file */
  16 extern VOID WINAPI PrivateCsrssManualGuiCheck(LONG Check);
  17
  18 /* GLOBALS *******************************************************************/
  19
  20 typedef struct GUI_CONSOLE_DATA_TAG
  21 {
  22     HFONT Font;
  23     unsigned CharWidth;
  24     unsigned CharHeight;
  25     BOOL CursorBlinkOn;
  26     BOOL ForceCursorOff;
  27     CRITICAL_SECTION Lock;
  28     HMODULE ConsoleLibrary;
  29     HANDLE hGuiInitEvent;
  30     WCHAR FontName[LF_FACESIZE];
  31     DWORD FontSize;
  32     DWORD FontWeight;
  33     DWORD FullScreen;
  34     DWORD QuickEdit;
  35     DWORD InsertMode;
  36     DWORD WindowPosition;
  37     DWORD UseRasterFonts;
  38     COLORREF ScreenText;
  39     COLORREF ScreenBackground;
  40     COLORREF PopupBackground;
  41     COLORREF PopupText;
  42     COLORREF Colors[16];
  43     WCHAR szProcessName[MAX_PATH];
  44     BOOL WindowSizeLock;
  45     POINT OldCursor;
  46 } GUI_CONSOLE_DATA, *PGUI_CONSOLE_DATA;
  47
  48 #ifndef WM_APP
  49 #define WM_APP 0x8000
  50 #endif
  51 #define PM_CREATE_CONSOLE  (WM_APP + 1)
  52 #define PM_DESTROY_CONSOLE (WM_APP + 2)
  53
  54 #define CURSOR_BLINK_TIME 500
  55 #define DEFAULT_ATTRIB (FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED)
  56
  57 static BOOL ConsInitialized = FALSE;
  58 static HWND NotifyWnd;
  59
  60 typedef struct _GUICONSOLE_MENUITEM
  61 {
  62     UINT uID;
  63     const struct _GUICONSOLE_MENUITEM *SubMenu;
  64     WORD wCmdID;
  65 } GUICONSOLE_MENUITEM, *PGUICONSOLE_MENUITEM;
  66
  67 static const GUICONSOLE_MENUITEM GuiConsoleEditMenuItems[] =
  68 {
  69     { IDS_MARK, NULL, ID_SYSTEM_EDIT_MARK },
  70     { IDS_COPY, NULL, ID_SYSTEM_EDIT_COPY },
  71     { IDS_PASTE, NULL, ID_SYSTEM_EDIT_PASTE },
  72     { IDS_SELECTALL, NULL, ID_SYSTEM_EDIT_SELECTALL },
  73     { IDS_SCROLL, NULL, ID_SYSTEM_EDIT_SCROLL },
  74     { IDS_FIND, NULL, ID_SYSTEM_EDIT_FIND },
  75
  76     { 0, NULL, 0 } /* End of list */
  77 };
  78
  79 static const GUICONSOLE_MENUITEM GuiConsoleMainMenuItems[] =
  80 {
  81     { (UINT)-1, NULL, 0 }, /* Separator */
  82     { IDS_EDIT, GuiConsoleEditMenuItems, 0 },
  83     { IDS_DEFAULTS, NULL, ID_SYSTEM_DEFAULTS },
  84     { IDS_PROPERTIES, NULL, ID_SYSTEM_PROPERTIES },
  85
  86     { 0, NULL, 0 } /* End of list */
  87 };
  88
  89 static const COLORREF s_Colors[] =
  90 {
  91     RGB(0, 0, 0),
  92     RGB(0, 0, 128),
  93     RGB(0, 128, 0),
  94     RGB(0, 128, 128),
  95     RGB(128, 0, 0),
  96     RGB(128, 0, 128),
  97     RGB(128, 128, 0),
  98     RGB(192, 192, 192),
  99     RGB(128, 128, 128),
 100     RGB(0, 0, 255),
 101     RGB(0, 255, 0),
 102     RGB(0, 255, 255),
 103     RGB(255, 0, 0),
 104     RGB(255, 0, 255),
 105     RGB(255, 255, 0),
 106     RGB(255, 255, 255)
 107 };
 108
 109 #define GuiConsoleRGBFromAttribute(GuiData, Attribute) ((GuiData)->Colors[(Attribute) & 0xF])
 110
 111 /* FUNCTIONS *****************************************************************/
 112
 113 static VOID
 114 GuiConsoleAppendMenuItems(HMENU hMenu,
 115                           const GUICONSOLE_MENUITEM *Items)
 116 {
 117     UINT i = 0;
 118     WCHAR szMenuString[255];
 119     HMENU hSubMenu;
 120     HINSTANCE hInst = GetModuleHandleW(L"win32csr");
 121
 122     do
 123     {
 124         if (Items[i].uID != (UINT)-1)
 125         {
 126             if (LoadStringW(hInst,
 127                             Items[i].uID,
 128                             szMenuString,
 129                             sizeof(szMenuString) / sizeof(szMenuString[0])) > 0)
 130             {
 131                 if (Items[i].SubMenu != NULL)
 132                 {
 133                     hSubMenu = CreatePopupMenu();
 134                     if (hSubMenu != NULL)
 135                     {
 136                         GuiConsoleAppendMenuItems(hSubMenu,
 137                                                   Items[i].SubMenu);
 138
 139                         if (!AppendMenuW(hMenu,
 140                                          MF_STRING | MF_POPUP,
 141                                          (UINT_PTR)hSubMenu,
 142                                          szMenuString))
 143                         {
 144                             DestroyMenu(hSubMenu);
 145                         }
 146                     }
 147                 }
 148                 else
 149                 {
 150                     AppendMenuW(hMenu,
 151                                 MF_STRING,
 152                                 Items[i].wCmdID,
 153                                 szMenuString);
 154                 }
 155             }
 156         }
 157         else
 158         {
 159             AppendMenuW(hMenu,
 160                         MF_SEPARATOR,
 161                         0,
 162                         NULL);
 163         }
 164         i++;
 165     } while(!(Items[i].uID == 0 && Items[i].SubMenu == NULL && Items[i].wCmdID == 0));
 166 }
 167
 168 static VOID
 169 GuiConsoleCreateSysMenu(PCSRSS_CONSOLE Console)
 170 {
 171     HMENU hMenu;
 172     hMenu = GetSystemMenu(Console->hWindow,
 173                           FALSE);
 174     if (hMenu != NULL)
 175     {
 176         GuiConsoleAppendMenuItems(hMenu,
 177                                   GuiConsoleMainMenuItems);
 178         DrawMenuBar(Console->hWindow);
 179     }
 180 }
 181
 182 static VOID
 183 GuiConsoleGetDataPointers(HWND hWnd, PCSRSS_CONSOLE *Console, PGUI_CONSOLE_DATA *GuiData)
 184 {
 185     *Console = (PCSRSS_CONSOLE) GetWindowLongPtrW(hWnd, GWL_USERDATA);
 186     *GuiData = (NULL == *Console ? NULL : (*Console)->PrivateData);
 187 }
 188
 189 static BOOL
 190 GuiConsoleOpenUserRegistryPathPerProcessId(DWORD ProcessId, PHANDLE hProcHandle, PHKEY hResult, REGSAM samDesired)
 191 {
 192     HANDLE hProcessToken = NULL;
 193     HANDLE hProcess;
 194
 195     BYTE Buffer[256];
 196     DWORD Length = 0;
 197     UNICODE_STRING SidName;
 198     LONG res;
 199     PTOKEN_USER TokUser;
 200
 201     hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | READ_CONTROL, FALSE, ProcessId);
 202     if (!hProcess)
 203     {
 204         DPRINT("Error: OpenProcess failed(0x%x)\n", GetLastError());
 205         return FALSE;
 206     }
 207
 208     if (!OpenProcessToken(hProcess, TOKEN_QUERY, &hProcessToken))
 209     {
 210         DPRINT("Error: OpenProcessToken failed(0x%x)\n", GetLastError());
 211         CloseHandle(hProcess);
 212         return FALSE;
 213     }
 214
 215     if (!GetTokenInformation(hProcessToken, TokenUser, (PVOID)Buffer, sizeof(Buffer), &Length))
 216     {
 217         DPRINT("Error: GetTokenInformation failed(0x%x)\n",GetLastError());
 218         CloseHandle(hProcess);
 219         CloseHandle(hProcessToken);
 220         return FALSE;
 221     }
 222
 223     TokUser = ((PTOKEN_USER)Buffer)->User.Sid;
 224     if (!NT_SUCCESS(RtlConvertSidToUnicodeString(&SidName, TokUser, TRUE)))
 225     {
 226         DPRINT("Error: RtlConvertSidToUnicodeString failed(0x%x)\n", GetLastError());
 227         return FALSE;
 228     }
 229
 230     res = RegOpenKeyExW(HKEY_USERS, SidName.Buffer, 0, samDesired, hResult);
 231     RtlFreeUnicodeString(&SidName);
 232
 233     CloseHandle(hProcessToken);
 234     if (hProcHandle)
 235         *hProcHandle = hProcess;
 236     else
 237         CloseHandle(hProcess);
 238
 239     if (res != ERROR_SUCCESS)
 240         return FALSE;
 241     else
 242         return TRUE;
 243 }
 244
 245 static BOOL
 246 GuiConsoleOpenUserSettings(PGUI_CONSOLE_DATA GuiData, DWORD ProcessId, PHKEY hSubKey, REGSAM samDesired, BOOL bCreate)
 247 {
 248     WCHAR szProcessName[MAX_PATH];
 249     WCHAR szBuffer[MAX_PATH];
 250     UINT fLength, wLength;
 251     DWORD dwBitmask, dwLength;
 252     WCHAR CurDrive[] = { 'A',':', 0 };
 253     HANDLE hProcess;
 254     HKEY hKey;
 255     WCHAR * ptr;
 256
 257     /*
 258      * console properties are stored under
 259      * HKCU\Console\*
 260      *
 261      * There are 3 ways to store console properties
 262      *
 263      *  1. use console title as subkey name
 264      *    i.e. cmd.exe
 265      *
 266      *  2. use application name as subkey name
 267      *
 268      *  3. use unexpanded path to console application.
 269      *     i.e. %SystemRoot%_system32_cmd.exe
 270      */
 271
 272     DPRINT("GuiConsoleOpenUserSettings entered\n");
 273
 274     if (!GuiConsoleOpenUserRegistryPathPerProcessId(ProcessId, &hProcess, &hKey, samDesired))
 275     {
 276         DPRINT("GuiConsoleOpenUserRegistryPathPerProcessId failed\n");
 277         return FALSE;
 278     }
 279
 280     /* FIXME we do not getting the process name so no menu will be loading, why ?*/
 281     fLength = GetProcessImageFileNameW(hProcess, szProcessName, sizeof(GuiData->szProcessName) / sizeof(WCHAR));
 282     CloseHandle(hProcess);
 283
 284     //DPRINT1("szProcessName3 : %S\n",szProcessName);
 285
 286     if (!fLength)
 287     {
 288         DPRINT("GetProcessImageFileNameW failed(0x%x)ProcessId %d\n", GetLastError(),hProcess);
 289         return FALSE;
 290     }
 291     /*
 292      * try the process name as path
 293      */
 294
 295     ptr = wcsrchr(szProcessName, L'\\');
 296     wcscpy(GuiData->szProcessName, ptr);
 297
 298     swprintf(szBuffer, L"Console%s",ptr);
 299     DPRINT("#1 Path : %S\n", szBuffer);
 300
 301     if (bCreate)
 302     {
 303         if (RegCreateKeyW(hKey, szBuffer, hSubKey) == ERROR_SUCCESS)
 304         {
 305             RegCloseKey(hKey);
 306             return TRUE;
 307         }
 308         RegCloseKey(hKey);
 309         return FALSE;
 310     }
 311
 312     if (RegOpenKeyExW(hKey, szBuffer, 0, samDesired, hSubKey) == ERROR_SUCCESS)
 313     {
 314         RegCloseKey(hKey);
 315         return TRUE;
 316     }
 317
 318     /*
 319      * try the "Shortcut to processname" as path
 320      * FIXME: detect wheter the process was started as a shortcut
 321      */
 322
 323     swprintf(szBuffer, L"Console\\Shortcut to %S", ptr);
 324     DPRINT("#2 Path : %S\n", szBuffer);
 325     if (RegOpenKeyExW(hKey, szBuffer, 0, samDesired, hSubKey) == ERROR_SUCCESS)
 326     {
 327         swprintf(GuiData->szProcessName, L"Shortcut to %S", ptr);
 328         RegCloseKey(hKey);
 329         return TRUE;
 330     }
 331
 332     /*
 333      * if the path contains \\Device\\HarddiskVolume1\... remove it
 334      */
 335
 336     if (szProcessName[0] == L'\\')
 337     {
 338         dwBitmask = GetLogicalDrives();
 339         while(dwBitmask)
 340         {
 341             if (dwBitmask & 0x1)
 342             {
 343                 dwLength = QueryDosDeviceW(CurDrive, szBuffer, MAX_PATH);
 344                 if (dwLength)
 345                 {
 346                     if (!memcmp(szBuffer, szProcessName, (dwLength-2)*sizeof(WCHAR)))
 347                     {
 348                         wcscpy(szProcessName, CurDrive);
 349                         RtlMoveMemory(&szProcessName[2], &szProcessName[dwLength-1], fLength - dwLength -1);
 350                         break;
 351                     }
 352                 }
 353             }
 354             dwBitmask = (dwBitmask >> 1);
 355             CurDrive[0]++;
 356         }
 357     }
 358
 359     /*
 360      * last attempt: check whether the file is under %SystemRoot%
 361      * and use path like Console\%SystemRoot%_dir_dir2_file.exe
 362      */
 363
 364     wLength = GetWindowsDirectoryW(szBuffer, MAX_PATH);
 365     if (wLength)
 366     {
 367         if (!wcsncmp(szProcessName, szBuffer, wLength))
 368         {
 369             /* replace slashes by underscores */
 370             while((ptr = wcschr(szProcessName, L'\\')))
 371                 ptr[0] = L'_';
 372
 373             swprintf(szBuffer, L"Console\\%%SystemRoot%%%S", &szProcessName[wLength]);
 374             DPRINT("#3 Path : %S\n", szBuffer);
 375             if (RegOpenKeyExW(hKey, szBuffer, 0, samDesired, hSubKey) == ERROR_SUCCESS)
 376             {
 377                 swprintf(GuiData->szProcessName, L"%%SystemRoot%%%S", &szProcessName[wLength]);
 378                 RegCloseKey(hKey);
 379                 return TRUE;
 380             }
 381         }
 382     }
 383     RegCloseKey(hKey);
 384     return FALSE;
 385 }
 386
 387 static VOID
 388 GuiConsoleWriteUserSettings(PCSRSS_CONSOLE Console, PGUI_CONSOLE_DATA GuiData)
 389 {
 390     HKEY hKey;
 391     PCSRSS_PROCESS_DATA ProcessData;
 392
 393     if (Console->ProcessList.Flink == &Console->ProcessList)
 394     {
 395         DPRINT("GuiConsoleWriteUserSettings: No Process!!!\n");
 396         return;
 397     }
 398     ProcessData = CONTAINING_RECORD(Console->ProcessList.Flink, CSRSS_PROCESS_DATA, ProcessEntry);
 399     if (!GuiConsoleOpenUserSettings(GuiData, PtrToUlong(ProcessData->ProcessId), &hKey, KEY_READ | KEY_WRITE, TRUE))
 400     {
 401         return;
 402     }
 403
 404     if (Console->ActiveBuffer->CursorInfo.dwSize <= 1)
 405     {
 406         RegDeleteKeyW(hKey, L"CursorSize");
 407     }
 408     else
 409     {
 410         RegSetValueExW(hKey, L"CursorSize", 0, REG_DWORD, (const BYTE *)&Console->ActiveBuffer->CursorInfo.dwSize, sizeof(DWORD));
 411     }
 412
 413     if (Console->NumberOfHistoryBuffers == 5)
 414     {
 415         RegDeleteKeyW(hKey, L"NumberOfHistoryBuffers");
 416     }
 417     else
 418     {
 419         DWORD Temp = Console->NumberOfHistoryBuffers;
 420         RegSetValueExW(hKey, L"NumberOfHistoryBuffers", 0, REG_DWORD, (const BYTE *)&Temp, sizeof(DWORD));
 421     }
 422
 423     if (Console->HistoryBufferSize == 50)
 424     {
 425         RegDeleteKeyW(hKey, L"HistoryBufferSize");
 426     }
 427     else
 428     {
 429         DWORD Temp = Console->HistoryBufferSize;
 430         RegSetValueExW(hKey, L"HistoryBufferSize", 0, REG_DWORD, (const BYTE *)&Temp, sizeof(DWORD));
 431     }
 432
 433     if (GuiData->FullScreen == FALSE)
 434     {
 435         RegDeleteKeyW(hKey, L"FullScreen");
 436     }
 437     else
 438     {
 439         RegSetValueExW(hKey, L"FullScreen", 0, REG_DWORD, (const BYTE *)&GuiData->FullScreen, sizeof(DWORD));
 440     }
 441
 442     if ( GuiData->QuickEdit == FALSE)
 443     {
 444         RegDeleteKeyW(hKey, L"QuickEdit");
 445     }
 446     else
 447     {
 448         RegSetValueExW(hKey, L"QuickEdit", 0, REG_DWORD, (const BYTE *)&GuiData->QuickEdit, sizeof(DWORD));
 449     }
 450
 451     if (GuiData->InsertMode == TRUE)
 452     {
 453         RegDeleteKeyW(hKey, L"InsertMode");
 454     }
 455     else
 456     {
 457         RegSetValueExW(hKey, L"InsertMode", 0, REG_DWORD, (const BYTE *)&GuiData->InsertMode, sizeof(DWORD));
 458     }
 459
 460     if (Console->HistoryNoDup == FALSE)
 461     {
 462         RegDeleteKeyW(hKey, L"HistoryNoDup");
 463     }
 464     else
 465     {
 466         DWORD Temp = Console->HistoryNoDup;
 467         RegSetValueExW(hKey, L"HistoryNoDup", 0, REG_DWORD, (const BYTE *)&Temp, sizeof(DWORD));
 468     }
 469
 470     if (GuiData->ScreenText == RGB(192, 192, 192))
 471     {
 472         /*
 473          * MS uses console attributes instead of real color
 474          */
 475         RegDeleteKeyW(hKey, L"ScreenText");
 476     }
 477     else
 478     {
 479         RegSetValueExW(hKey, L"ScreenText", 0, REG_DWORD, (const BYTE *)&GuiData->ScreenText, sizeof(COLORREF));
 480     }
 481
 482     if (GuiData->ScreenBackground == RGB(0, 0, 0))
 483     {
 484         RegDeleteKeyW(hKey, L"ScreenBackground");
 485     }
 486     else
 487     {
 488         RegSetValueExW(hKey, L"ScreenBackground", 0, REG_DWORD, (const BYTE *)&GuiData->ScreenBackground, sizeof(COLORREF));
 489     }
 490
 491     RegCloseKey(hKey);
 492 }
 493
 494 static void
 495 GuiConsoleReadUserSettings(HKEY hKey, PCSRSS_CONSOLE Console, PGUI_CONSOLE_DATA GuiData, PCSRSS_SCREEN_BUFFER Buffer)
 496 {
 497     DWORD dwNumSubKeys = 0;
 498     DWORD dwIndex;
 499     DWORD dwValueName;
 500     DWORD dwValue;
 501     DWORD dwType;
 502     WCHAR szValueName[MAX_PATH];
 503     WCHAR szValue[LF_FACESIZE] = L"\0";
 504     DWORD Value;
 505
 506     if (RegQueryInfoKey(hKey, NULL, NULL, NULL, NULL, NULL, NULL, &dwNumSubKeys, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
 507     {
 508         DPRINT("GuiConsoleReadUserSettings: RegQueryInfoKey failed\n");
 509         return;
 510     }
 511
 512     DPRINT("GuiConsoleReadUserSettings entered dwNumSubKeys %d\n", dwNumSubKeys);
 513
 514     for (dwIndex = 0; dwIndex < dwNumSubKeys; dwIndex++)
 515     {
 516         dwValue = sizeof(Value);
 517         dwValueName = MAX_PATH;
 518
 519         if (RegEnumValueW(hKey, dwIndex, szValueName, &dwValueName, NULL, &dwType, (BYTE*)&Value, &dwValue) != ERROR_SUCCESS)
 520         {
 521             if (dwType == REG_SZ)
 522             {
 523                 /*
 524                  * retry in case of string value
 525                  */
 526                 dwValue = sizeof(szValue);
 527                 dwValueName = LF_FACESIZE;
 528                 if (RegEnumValueW(hKey, dwIndex, szValueName, &dwValueName, NULL, NULL, (BYTE*)szValue, &dwValue) != ERROR_SUCCESS)
 529                     break;
 530             }
 531             else
 532                 break;
 533         }
 534         if (!wcscmp(szValueName, L"CursorSize"))
 535         {
 536             if (Value == 0x32)
 537             {
 538                 Buffer->CursorInfo.dwSize = Value;
 539             }
 540             else if (Value == 0x64)
 541             {
 542                 Buffer->CursorInfo.dwSize = Value;
 543             }
 544         }
 545         else if (!wcscmp(szValueName, L"ScreenText"))
 546         {
 547             GuiData->ScreenText = Value;
 548         }
 549         else if (!wcscmp(szValueName, L"ScreenBackground"))
 550         {
 551             GuiData->ScreenBackground = Value;
 552         }
 553         else if (!wcscmp(szValueName, L"FaceName"))
 554         {
 555             wcscpy(GuiData->FontName, szValue);
 556         }
 557         else if (!wcscmp(szValueName, L"FontSize"))
 558         {
 559             GuiData->FontSize = Value;
 560         }
 561         else if (!wcscmp(szValueName, L"FontWeight"))
 562         {
 563             GuiData->FontWeight = Value;
 564         }
 565         else if (!wcscmp(szValueName, L"HistoryNoDup"))
 566         {
 567             Console->HistoryNoDup = Value;
 568         }
 569         else if (!wcscmp(szValueName, L"WindowSize"))
 570         {
 571             Console->Size.X = LOWORD(Value);
 572             Console->Size.Y = HIWORD(Value);
 573         }
 574         else if (!wcscmp(szValueName, L"ScreenBufferSize"))
 575         {
 576             if(Buffer)
 577             {
 578                 Buffer->MaxX = LOWORD(Value);
 579                 Buffer->MaxY = HIWORD(Value);
 580             }
 581         }
 582         else if (!wcscmp(szValueName, L"FullScreen"))
 583         {
 584             GuiData->FullScreen = Value;
 585         }
 586         else if (!wcscmp(szValueName, L"QuickEdit"))
 587         {
 588             GuiData->QuickEdit = Value;
 589         }
 590         else if (!wcscmp(szValueName, L"InsertMode"))
 591         {
 592             GuiData->InsertMode = Value;
 593         }
 594     }
 595 }
 596 static VOID
 597 GuiConsoleUseDefaults(PCSRSS_CONSOLE Console, PGUI_CONSOLE_DATA GuiData, PCSRSS_SCREEN_BUFFER Buffer)
 598 {
 599     /*
 600      * init guidata with default properties
 601      */
 602
 603     wcscpy(GuiData->FontName, L"DejaVu Sans Mono");
 604     GuiData->FontSize = 0x0008000C; // font is 8x12
 605     GuiData->FontWeight = FW_NORMAL;
 606     GuiData->FullScreen = FALSE;
 607     GuiData->QuickEdit = FALSE;
 608     GuiData->InsertMode = TRUE;
 609     GuiData->ScreenText = RGB(192, 192, 192);
 610     GuiData->ScreenBackground = RGB(0, 0, 0);
 611     GuiData->PopupText = RGB(128, 0, 128);
 612     GuiData->PopupBackground = RGB(255, 255, 255);
 613     GuiData->WindowPosition = UINT_MAX;
 614     GuiData->UseRasterFonts = TRUE;
 615     memcpy(GuiData->Colors, s_Colors, sizeof(s_Colors));
 616
 617     Console->HistoryBufferSize = 50;
 618     Console->NumberOfHistoryBuffers = 5;
 619     Console->HistoryNoDup = FALSE;
 620     Console->Size.X = 80;
 621     Console->Size.Y = 25;
 622
 623     if (Buffer)
 624     {
 625         Buffer->MaxX = 80;
 626         Buffer->MaxY = 300;
 627         Buffer->CursorInfo.bVisible = TRUE;
 628         Buffer->CursorInfo.dwSize = CSR_DEFAULT_CURSOR_SIZE;
 629     }
 630 }
 631
 632 VOID
 633 FASTCALL
 634 GuiConsoleInitScrollbar(PCSRSS_CONSOLE Console, HWND hwnd)
 635 {
 636     SCROLLINFO sInfo;
 637     PGUI_CONSOLE_DATA GuiData = Console->PrivateData;
 638
 639     DWORD Width = Console->Size.X * GuiData->CharWidth + 2 * (GetSystemMetrics(SM_CXFRAME) + GetSystemMetrics(SM_CXEDGE));
 640     DWORD Height = Console->Size.Y * GuiData->CharHeight + 2 * (GetSystemMetrics(SM_CYFRAME) + GetSystemMetrics(SM_CYEDGE)) + GetSystemMetrics(SM_CYCAPTION);
 641
 642     /* set scrollbar sizes */
 643     sInfo.cbSize = sizeof(SCROLLINFO);
 644     sInfo.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
 645     sInfo.nMin = 0;
 646     if (Console->ActiveBuffer->MaxY > Console->Size.Y)
 647     {
 648         sInfo.nMax = Console->ActiveBuffer->MaxY - 1;
 649         sInfo.nPage = Console->Size.Y;
 650         sInfo.nPos = Console->ActiveBuffer->ShowY;
 651         SetScrollInfo(hwnd, SB_VERT, &sInfo, TRUE);
 652         Width += GetSystemMetrics(SM_CXVSCROLL);
 653         ShowScrollBar(hwnd, SB_VERT, TRUE);
 654     }
 655     else
 656     {
 657         ShowScrollBar(hwnd, SB_VERT, FALSE);
 658     }
 659
 660     if (Console->ActiveBuffer->MaxX > Console->Size.X)
 661     {
 662         sInfo.nMax = Console->ActiveBuffer->MaxX - 1;
 663         sInfo.nPage = Console->Size.X;
 664         sInfo.nPos = Console->ActiveBuffer->ShowX;
 665         SetScrollInfo(hwnd, SB_HORZ, &sInfo, TRUE);
 666         Height += GetSystemMetrics(SM_CYHSCROLL);
 667         ShowScrollBar(hwnd, SB_HORZ, TRUE);
 668
 669     }
 670     else
 671     {
 672         ShowScrollBar(hwnd, SB_HORZ, FALSE);
 673     }
 674
 675     SetWindowPos(hwnd, NULL, 0, 0, Width, Height,
 676                  SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
 677 }
 678
 679 static BOOL
 680 GuiConsoleHandleNcCreate(HWND hWnd, CREATESTRUCTW *Create)
 681 {
 682     PCSRSS_CONSOLE Console = (PCSRSS_CONSOLE) Create->lpCreateParams;
 683     PGUI_CONSOLE_DATA GuiData = (PGUI_CONSOLE_DATA)Console->PrivateData;
 684     HDC Dc;
 685     HFONT OldFont;
 686     TEXTMETRICW Metrics;
 687     SIZE CharSize;
 688     PCSRSS_PROCESS_DATA ProcessData;
 689     HKEY hKey;
 690
 691     Console->hWindow = hWnd;
 692
 693     if (NULL == GuiData)
 694     {
 695         DPRINT1("GuiConsoleNcCreate: HeapAlloc failed\n");
 696         return FALSE;
 697     }
 698
 699     GuiConsoleUseDefaults(Console, GuiData, Console->ActiveBuffer);
 700     if (Console->ProcessList.Flink != &Console->ProcessList)
 701     {
 702         ProcessData = CONTAINING_RECORD(Console->ProcessList.Flink, CSRSS_PROCESS_DATA, ProcessEntry);
 703         if (GuiConsoleOpenUserSettings(GuiData, PtrToUlong(ProcessData->ProcessId), &hKey, KEY_READ, FALSE))
 704         {
 705             GuiConsoleReadUserSettings(hKey, Console, GuiData, Console->ActiveBuffer);
 706             RegCloseKey(hKey);
 707         }
 708     }
 709
 710     InitializeCriticalSection(&GuiData->Lock);
 711
 712     GuiData->Font = CreateFontW(LOWORD(GuiData->FontSize),
 713                                 0, //HIWORD(GuiData->FontSize),
 714                                 0,
 715                                 TA_BASELINE,
 716                                 GuiData->FontWeight,
 717                                 FALSE,
 718                                 FALSE,
 719                                 FALSE,
 720                                 OEM_CHARSET,
 721                                 OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
 722                                 NONANTIALIASED_QUALITY, FIXED_PITCH | FF_DONTCARE,
 723                                 GuiData->FontName);
 724     if (NULL == GuiData->Font)
 725     {
 726         DPRINT1("GuiConsoleNcCreate: CreateFont failed\n");
 727         DeleteCriticalSection(&GuiData->Lock);
 728         HeapFree(Win32CsrApiHeap, 0, GuiData);
 729         return FALSE;
 730     }
 731     Dc = GetDC(hWnd);
 732     if (NULL == Dc)
 733     {
 734         DPRINT1("GuiConsoleNcCreate: GetDC failed\n");
 735         DeleteObject(GuiData->Font);
 736         DeleteCriticalSection(&GuiData->Lock);
 737         HeapFree(Win32CsrApiHeap, 0, GuiData);
 738         return FALSE;
 739     }
 740     OldFont = SelectObject(Dc, GuiData->Font);
 741     if (NULL == OldFont)
 742     {
 743         DPRINT1("GuiConsoleNcCreate: SelectObject failed\n");
 744         ReleaseDC(hWnd, Dc);
 745         DeleteObject(GuiData->Font);
 746         DeleteCriticalSection(&GuiData->Lock);
 747         HeapFree(Win32CsrApiHeap, 0, GuiData);
 748         return FALSE;
 749     }
 750     if (! GetTextMetricsW(Dc, &Metrics))
 751     {
 752         DPRINT1("GuiConsoleNcCreate: GetTextMetrics failed\n");
 753         SelectObject(Dc, OldFont);
 754         ReleaseDC(hWnd, Dc);
 755         DeleteObject(GuiData->Font);
 756         DeleteCriticalSection(&GuiData->Lock);
 757         HeapFree(Win32CsrApiHeap, 0, GuiData);
 758         return FALSE;
 759     }
 760     GuiData->CharWidth = Metrics.tmMaxCharWidth;
 761     GuiData->CharHeight = Metrics.tmHeight + Metrics.tmExternalLeading;
 762
 763     /* Measure real char width more precisely if possible. */
 764     if (GetTextExtentPoint32W(Dc, L"R", 1, &CharSize))
 765         GuiData->CharWidth = CharSize.cx;
 766
 767     SelectObject(Dc, OldFont);
 768
 769     ReleaseDC(hWnd, Dc);
 770     GuiData->CursorBlinkOn = TRUE;
 771     GuiData->ForceCursorOff = FALSE;
 772
 773     DPRINT("Console %p GuiData %p\n", Console, GuiData);
 774     Console->PrivateData = GuiData;
 775     SetWindowLongPtrW(hWnd, GWL_USERDATA, (DWORD_PTR) Console);
 776
 777     SetTimer(hWnd, CONGUI_UPDATE_TIMER, CONGUI_UPDATE_TIME, NULL);
 778     GuiConsoleCreateSysMenu(Console);
 779
 780     GuiData->WindowSizeLock = TRUE;
 781     GuiConsoleInitScrollbar(Console, hWnd);
 782     GuiData->WindowSizeLock = FALSE;
 783
 784     SetEvent(GuiData->hGuiInitEvent);
 785
 786     return (BOOL) DefWindowProcW(hWnd, WM_NCCREATE, 0, (LPARAM) Create);
 787 }
 788
 789 static VOID
 790 SmallRectToRect(PCSRSS_CONSOLE Console, PRECT Rect, PSMALL_RECT SmallRect)
 791 {
 792     PCSRSS_SCREEN_BUFFER Buffer = Console->ActiveBuffer;
 793     PGUI_CONSOLE_DATA GuiData = Console->PrivateData;
 794     Rect->left   = (SmallRect->Left       - Buffer->ShowX) * GuiData->CharWidth;
 795     Rect->top    = (SmallRect->Top        - Buffer->ShowY) * GuiData->CharHeight;
 796     Rect->right  = (SmallRect->Right  + 1 - Buffer->ShowX) * GuiData->CharWidth;
 797     Rect->bottom = (SmallRect->Bottom + 1 - Buffer->ShowY) * GuiData->CharHeight;
 798 }
 799
 800 static VOID
 801 GuiConsoleUpdateSelection(PCSRSS_CONSOLE Console, PCOORD coord)
 802 {
 803     RECT oldRect, newRect;
 804     HWND hWnd = Console->hWindow;
 805
 806     SmallRectToRect(Console, &oldRect, &Console->Selection.srSelection);
 807
 808     if(coord != NULL)
 809     {
 810         SMALL_RECT rc;
 811         /* exchange left/top with right/bottom if required */
 812         rc.Left   = min(Console->Selection.dwSelectionAnchor.X, coord->X);
 813         rc.Top    = min(Console->Selection.dwSelectionAnchor.Y, coord->Y);
 814         rc.Right  = max(Console->Selection.dwSelectionAnchor.X, coord->X);
 815         rc.Bottom = max(Console->Selection.dwSelectionAnchor.Y, coord->Y);
 816
 817         SmallRectToRect(Console, &newRect, &rc);
 818
 819         if (Console->Selection.dwFlags & CONSOLE_SELECTION_NOT_EMPTY)
 820         {
 821             if (memcmp(&rc, &Console->Selection.srSelection, sizeof(SMALL_RECT)) != 0)
 822             {
 823                 HRGN rgn1, rgn2;
 824
 825                 /* calculate the region that needs to be updated */
 826                 if((rgn1 = CreateRectRgnIndirect(&oldRect)))
 827                 {
 828                     if((rgn2 = CreateRectRgnIndirect(&newRect)))
 829                     {
 830                         if(CombineRgn(rgn1, rgn2, rgn1, RGN_XOR) != ERROR)
 831                         {
 832                             InvalidateRgn(hWnd, rgn1, FALSE);
 833                         }
 834
 835                         DeleteObject(rgn2);
 836                     }
 837                     DeleteObject(rgn1);
 838                 }
 839             }
 840         }
 841         else
 842         {
 843             InvalidateRect(hWnd, &newRect, FALSE);
 844         }
 845         Console->Selection.dwFlags |= CONSOLE_SELECTION_NOT_EMPTY;
 846         Console->Selection.srSelection = rc;
 847         ConioPause(Console, PAUSED_FROM_SELECTION);
 848     }
 849     else
 850     {
 851         /* clear the selection */
 852         if (Console->Selection.dwFlags & CONSOLE_SELECTION_NOT_EMPTY)
 853         {
 854             InvalidateRect(hWnd, &oldRect, FALSE);
 855         }
 856         Console->Selection.dwFlags = CONSOLE_NO_SELECTION;
 857         ConioUnpause(Console, PAUSED_FROM_SELECTION);
 858     }
 859 }
 860
 861
 862 static VOID
 863 GuiConsolePaint(PCSRSS_CONSOLE Console,
 864                 PGUI_CONSOLE_DATA GuiData,
 865                 HDC hDC,
 866                 PRECT rc)
 867 {
 868     PCSRSS_SCREEN_BUFFER Buff;
 869     ULONG TopLine, BottomLine, LeftChar, RightChar;
 870     ULONG Line, Char, Start;
 871     PBYTE From;
 872     PWCHAR To;
 873     BYTE LastAttribute, Attribute;
 874     ULONG CursorX, CursorY, CursorHeight;
 875     HBRUSH CursorBrush, OldBrush;
 876     HFONT OldFont;
 877
 878     Buff = Console->ActiveBuffer;
 879
 880     EnterCriticalSection(&Buff->Header.Console->Lock);
 881
 882     TopLine = rc->top / GuiData->CharHeight + Buff->ShowY;
 883     BottomLine = (rc->bottom + (GuiData->CharHeight - 1)) / GuiData->CharHeight - 1 + Buff->ShowY;
 884     LeftChar = rc->left / GuiData->CharWidth + Buff->ShowX;
 885     RightChar = (rc->right + (GuiData->CharWidth - 1)) / GuiData->CharWidth - 1 + Buff->ShowX;
 886     LastAttribute = ConioCoordToPointer(Buff, LeftChar, TopLine)[1];
 887
 888     SetTextColor(hDC, GuiConsoleRGBFromAttribute(GuiData, LastAttribute));
 889     SetBkColor(hDC, GuiConsoleRGBFromAttribute(GuiData, LastAttribute >> 4));
 890
 891     if (BottomLine >= Buff->MaxY) BottomLine = Buff->MaxY - 1;
 892     if (RightChar >= Buff->MaxX) RightChar = Buff->MaxX - 1;
 893
 894     OldFont = SelectObject(hDC,
 895                            GuiData->Font);
 896
 897     for (Line = TopLine; Line <= BottomLine; Line++)
 898     {
 899         WCHAR LineBuffer[80];
 900         From = ConioCoordToPointer(Buff, LeftChar, Line);
 901         Start = LeftChar;
 902         To = LineBuffer;
 903
 904         for (Char = LeftChar; Char <= RightChar; Char++)
 905         {
 906             if (*(From + 1) != LastAttribute || (Char - Start == sizeof(LineBuffer) / sizeof(WCHAR)))
 907             {
 908                 TextOutW(hDC,
 909                          (Start - Buff->ShowX) * GuiData->CharWidth,
 910                          (Line - Buff->ShowY) * GuiData->CharHeight,
 911                          LineBuffer,
 912                          Char - Start);
 913                 Start = Char;
 914                 To = LineBuffer;
 915                 Attribute = *(From + 1);
 916                 if (Attribute != LastAttribute)
 917                 {
 918                     SetTextColor(hDC, GuiConsoleRGBFromAttribute(GuiData, Attribute));
 919                     SetBkColor(hDC, GuiConsoleRGBFromAttribute(GuiData, Attribute >> 4));
 920                     LastAttribute = Attribute;
 921                 }
 922             }
 923
 924             MultiByteToWideChar(Console->OutputCodePage,
 925                                 0,
 926                                 (PCHAR)From,
 927                                 1,
 928                                 To,
 929                                 1);
 930             To++;
 931             From += 2;
 932         }
 933
 934         TextOutW(hDC,
 935                  (Start - Buff->ShowX) * GuiData->CharWidth,
 936                  (Line - Buff->ShowY) * GuiData->CharHeight,
 937                  LineBuffer,
 938                  RightChar - Start + 1);
 939     }
 940
 941     if (Buff->CursorInfo.bVisible && GuiData->CursorBlinkOn &&
 942             !GuiData->ForceCursorOff)
 943     {
 944         CursorX = Buff->CurrentX;
 945         CursorY = Buff->CurrentY;
 946         if (LeftChar <= CursorX && CursorX <= RightChar &&
 947                 TopLine <= CursorY && CursorY <= BottomLine)
 948         {
 949             CursorHeight = ConioEffectiveCursorSize(Console, GuiData->CharHeight);
 950             From = ConioCoordToPointer(Buff, Buff->CurrentX, Buff->CurrentY) + 1;
 951
 952             if (*From != DEFAULT_ATTRIB)
 953             {
 954                 CursorBrush = CreateSolidBrush(GuiConsoleRGBFromAttribute(GuiData, *From));
 955             }
 956             else
 957             {
 958                 CursorBrush = CreateSolidBrush(GuiData->ScreenText);
 959             }
 960
 961             OldBrush = SelectObject(hDC,
 962                                     CursorBrush);
 963             PatBlt(hDC,
 964                    (CursorX - Buff->ShowX) * GuiData->CharWidth,
 965                    (CursorY - Buff->ShowY) * GuiData->CharHeight + (GuiData->CharHeight - CursorHeight),
 966                    GuiData->CharWidth,
 967                    CursorHeight,
 968                    PATCOPY);
 969             SelectObject(hDC,
 970                          OldBrush);
 971             DeleteObject(CursorBrush);
 972         }
 973     }
 974
 975     LeaveCriticalSection(&Buff->Header.Console->Lock);
 976
 977     SelectObject(hDC,
 978                  OldFont);
 979 }
 980
 981 static VOID
 982 GuiConsoleHandlePaint(HWND hWnd, HDC hDCPaint)
 983 {
 984     HDC hDC;
 985     PAINTSTRUCT ps;
 986     PCSRSS_CONSOLE Console;
 987     PGUI_CONSOLE_DATA GuiData;
 988
 989     hDC = BeginPaint(hWnd, &ps);
 990     if (hDC != NULL &&
 991             ps.rcPaint.left < ps.rcPaint.right &&
 992             ps.rcPaint.top < ps.rcPaint.bottom)
 993     {
 994         GuiConsoleGetDataPointers(hWnd,
 995                                   &Console,
 996                                   &GuiData);
 997         if (Console != NULL && GuiData != NULL &&
 998                 Console->ActiveBuffer != NULL)
 999         {
1000             if (Console->ActiveBuffer->Buffer != NULL)
1001             {
1002                 EnterCriticalSection(&GuiData->Lock);
1003
1004                 GuiConsolePaint(Console,
1005                                 GuiData,
1006                                 hDC,
1007                                 &ps.rcPaint);
1008
1009                 if (Console->Selection.dwFlags & CONSOLE_SELECTION_NOT_EMPTY)
1010                 {
1011                     RECT rc;
1012                     SmallRectToRect(Console, &rc, &Console->Selection.srSelection);
1013
1014                     /* invert the selection */
1015                     if (IntersectRect(&rc,
1016                                       &ps.rcPaint,
1017                                       &rc))
1018                     {
1019                         PatBlt(hDC,
1020                                rc.left,
1021                                rc.top,
1022                                rc.right - rc.left,
1023                                rc.bottom - rc.top,
1024                                DSTINVERT);
1025                     }
1026                 }
1027
1028                 LeaveCriticalSection(&GuiData->Lock);
1029             }
1030         }
1031
1032     }
1033     EndPaint(hWnd, &ps);
1034 }
1035
1036 static VOID
1037 GuiConsoleHandleKey(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1038 {
1039     PCSRSS_CONSOLE Console;
1040     PGUI_CONSOLE_DATA GuiData;
1041     MSG Message;
1042
1043     GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
1044     Message.hwnd = hWnd;
1045     Message.message = msg;
1046     Message.wParam = wParam;
1047     Message.lParam = lParam;
1048
1049     if(msg == WM_CHAR || msg == WM_SYSKEYDOWN)
1050     {
1051         /* clear the selection */
1052         GuiConsoleUpdateSelection(Console, NULL);
1053     }
1054
1055     ConioProcessKey(&Message, Console, FALSE);
1056 }
1057
1058 static VOID WINAPI
1059 GuiDrawRegion(PCSRSS_CONSOLE Console, SMALL_RECT *Region)
1060 {
1061     RECT RegionRect;
1062     SmallRectToRect(Console, &RegionRect, Region);
1063     InvalidateRect(Console->hWindow, &RegionRect, FALSE);
1064 }
1065
1066 static VOID
1067 GuiInvalidateCell(PCSRSS_CONSOLE Console, UINT x, UINT y)
1068 {
1069     SMALL_RECT CellRect = { x, y, x, y };
1070     GuiDrawRegion(Console, &CellRect);
1071 }
1072
1073 static VOID WINAPI
1074 GuiWriteStream(PCSRSS_CONSOLE Console, SMALL_RECT *Region, LONG CursorStartX, LONG CursorStartY,
1075                UINT ScrolledLines, CHAR *Buffer, UINT Length)
1076 {
1077     PGUI_CONSOLE_DATA GuiData = (PGUI_CONSOLE_DATA) Console->PrivateData;
1078     PCSRSS_SCREEN_BUFFER Buff = Console->ActiveBuffer;
1079     LONG CursorEndX, CursorEndY;
1080     RECT ScrollRect;
1081
1082     if (NULL == Console->hWindow || NULL == GuiData)
1083     {
1084         return;
1085     }
1086
1087     if (0 != ScrolledLines)
1088     {
1089         ScrollRect.left = 0;
1090         ScrollRect.top = 0;
1091         ScrollRect.right = Console->Size.X * GuiData->CharWidth;
1092         ScrollRect.bottom = Region->Top * GuiData->CharHeight;
1093
1094         ScrollWindowEx(Console->hWindow,
1095                        0,
1096                        -(ScrolledLines * GuiData->CharHeight),
1097                        &ScrollRect,
1098                        NULL,
1099                        NULL,
1100                        NULL,
1101                        SW_INVALIDATE);
1102     }
1103
1104     GuiDrawRegion(Console, Region);
1105
1106     if (CursorStartX < Region->Left || Region->Right < CursorStartX
1107             || CursorStartY < Region->Top || Region->Bottom < CursorStartY)
1108     {
1109         GuiInvalidateCell(Console, CursorStartX, CursorStartY);
1110     }
1111
1112     CursorEndX = Buff->CurrentX;
1113     CursorEndY = Buff->CurrentY;
1114     if ((CursorEndX < Region->Left || Region->Right < CursorEndX
1115             || CursorEndY < Region->Top || Region->Bottom < CursorEndY)
1116             && (CursorEndX != CursorStartX || CursorEndY != CursorStartY))
1117     {
1118         GuiInvalidateCell(Console, CursorEndX, CursorEndY);
1119     }
1120
1121     // Set up the update timer (very short interval) - this is a "hack" for getting the OS to
1122     // repaint the window without having it just freeze up and stay on the screen permanently.
1123     GuiData->CursorBlinkOn = TRUE;
1124     SetTimer(Console->hWindow, CONGUI_UPDATE_TIMER, CONGUI_UPDATE_TIME, NULL);
1125 }
1126
1127 static BOOL WINAPI
1128 GuiSetCursorInfo(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buff)
1129 {
1130     if (Console->ActiveBuffer == Buff)
1131     {
1132         GuiInvalidateCell(Console, Buff->CurrentX, Buff->CurrentY);
1133     }
1134
1135     return TRUE;
1136 }
1137
1138 static BOOL WINAPI
1139 GuiSetScreenInfo(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buff, UINT OldCursorX, UINT OldCursorY)
1140 {
1141     if (Console->ActiveBuffer == Buff)
1142     {
1143         /* Redraw char at old position (removes cursor) */
1144         GuiInvalidateCell(Console, OldCursorX, OldCursorY);
1145         /* Redraw char at new position (shows cursor) */
1146         GuiInvalidateCell(Console, Buff->CurrentX, Buff->CurrentY);
1147     }
1148
1149     return TRUE;
1150 }
1151
1152 static BOOL WINAPI
1153 GuiUpdateScreenInfo(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buff)
1154 {
1155     PGUI_CONSOLE_DATA GuiData = (PGUI_CONSOLE_DATA) Console->PrivateData;
1156
1157     if (Console->ActiveBuffer == Buff)
1158     {
1159         GuiData->ScreenText = GuiConsoleRGBFromAttribute(GuiData, Buff->DefaultAttrib);
1160         GuiData->ScreenBackground = GuiConsoleRGBFromAttribute(GuiData, Buff->DefaultAttrib >> 4);
1161     }
1162
1163     return TRUE;
1164 }
1165
1166 static VOID
1167 GuiConsoleHandleTimer(HWND hWnd)
1168 {
1169     PCSRSS_CONSOLE Console;
1170     PGUI_CONSOLE_DATA GuiData;
1171     PCSRSS_SCREEN_BUFFER Buff;
1172
1173     SetTimer(hWnd, CONGUI_UPDATE_TIMER, CURSOR_BLINK_TIME, NULL);
1174
1175     GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
1176
1177     Buff = Console->ActiveBuffer;
1178     GuiInvalidateCell(Console, Buff->CurrentX, Buff->CurrentY);
1179     GuiData->CursorBlinkOn = ! GuiData->CursorBlinkOn;
1180
1181     if((GuiData->OldCursor.x != Buff->CurrentX) || (GuiData->OldCursor.y != Buff->CurrentY))
1182     {
1183         SCROLLINFO xScroll;
1184         int OldScrollX = -1, OldScrollY = -1;
1185         int NewScrollX = -1, NewScrollY = -1;
1186
1187         xScroll.cbSize = sizeof(SCROLLINFO);
1188         xScroll.fMask = SIF_POS;
1189         // Capture the original position of the scroll bars and save them.
1190         if(GetScrollInfo(hWnd, SB_HORZ, &xScroll))OldScrollX = xScroll.nPos;
1191         if(GetScrollInfo(hWnd, SB_VERT, &xScroll))OldScrollY = xScroll.nPos;
1192
1193         // If we successfully got the info for the horizontal scrollbar
1194         if(OldScrollX >= 0)
1195         {
1196             if((Buff->CurrentX < Buff->ShowX)||(Buff->CurrentX >= (Buff->ShowX + Console->Size.X)))
1197             {
1198                 // Handle the horizontal scroll bar
1199                 if(Buff->CurrentX >= Console->Size.X) NewScrollX = Buff->CurrentX - Console->Size.X + 1;
1200                 else NewScrollX = 0;
1201             }
1202             else
1203             {
1204                 NewScrollX = OldScrollX;
1205             }
1206         }
1207         // If we successfully got the info for the vertical scrollbar
1208         if(OldScrollY >= 0)
1209         {
1210             if((Buff->CurrentY < Buff->ShowY) || (Buff->CurrentY >= (Buff->ShowY + Console->Size.Y)))
1211             {
1212                 // Handle the vertical scroll bar
1213                 if(Buff->CurrentY >= Console->Size.Y) NewScrollY = Buff->CurrentY - Console->Size.Y + 1;
1214                 else NewScrollY = 0;
1215             }
1216             else
1217             {
1218                 NewScrollY = OldScrollY;
1219             }
1220         }
1221
1222         // Adjust scroll bars and refresh the window if the cursor has moved outside the visible area
1223         // NOTE: OldScroll# and NewScroll# will both be -1 (initial value) if the info for the respective scrollbar
1224         //       was not obtained successfully in the previous steps. This means their difference is 0 (no scrolling)
1225         //       and their associated scrollbar is left alone.
1226         if((OldScrollX != NewScrollX) || (OldScrollY != NewScrollY))
1227         {
1228             Buff->ShowX = NewScrollX;
1229             Buff->ShowY = NewScrollY;
1230             ScrollWindowEx(hWnd,
1231                            (OldScrollX - NewScrollX) * GuiData->CharWidth,
1232                            (OldScrollY - NewScrollY) * GuiData->CharHeight,
1233                            NULL,
1234                            NULL,
1235                            NULL,
1236                            NULL,
1237                            SW_INVALIDATE);
1238             if(NewScrollX >= 0)
1239             {
1240                 xScroll.nPos = NewScrollX;
1241                 SetScrollInfo(hWnd, SB_HORZ, &xScroll, TRUE);
1242             }
1243             if(NewScrollY >= 0)
1244             {
1245                 xScroll.nPos = NewScrollY;
1246                 SetScrollInfo(hWnd, SB_VERT, &xScroll, TRUE);
1247             }
1248             UpdateWindow(hWnd);
1249             GuiData->OldCursor.x = Buff->CurrentX;
1250             GuiData->OldCursor.y = Buff->CurrentY;
1251         }
1252     }
1253 }
1254
1255 static VOID
1256 GuiConsoleHandleClose(HWND hWnd)
1257 {
1258     PCSRSS_CONSOLE Console;
1259     PGUI_CONSOLE_DATA GuiData;
1260     PLIST_ENTRY current_entry;
1261     PCSRSS_PROCESS_DATA current;
1262
1263     GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
1264
1265     EnterCriticalSection(&Console->Lock);
1266
1267     current_entry = Console->ProcessList.Flink;
1268     while (current_entry != &Console->ProcessList)
1269     {
1270         current = CONTAINING_RECORD(current_entry, CSRSS_PROCESS_DATA, ProcessEntry);
1271         current_entry = current_entry->Flink;
1272
1273         /* FIXME: Windows will wait up to 5 seconds for the thread to exit.
1274          * We shouldn't wait here, though, since the console lock is entered.
1275          * A copy of the thread list probably needs to be made. */
1276         ConioConsoleCtrlEvent(CTRL_CLOSE_EVENT, current);
1277     }
1278
1279     LeaveCriticalSection(&Console->Lock);
1280 }
1281
1282 static VOID
1283 GuiConsoleHandleNcDestroy(HWND hWnd)
1284 {
1285     PCSRSS_CONSOLE Console;
1286     PGUI_CONSOLE_DATA GuiData;
1287
1288
1289     GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
1290     KillTimer(hWnd, 1);
1291     Console->PrivateData = NULL;
1292     DeleteCriticalSection(&GuiData->Lock);
1293     GetSystemMenu(hWnd, TRUE);
1294     if (GuiData->ConsoleLibrary)
1295         FreeLibrary(GuiData->ConsoleLibrary);
1296
1297     HeapFree(Win32CsrApiHeap, 0, GuiData);
1298 }
1299
1300 static COORD
1301 PointToCoord(PCSRSS_CONSOLE Console, LPARAM lParam)
1302 {
1303     PCSRSS_SCREEN_BUFFER Buffer = Console->ActiveBuffer;
1304     PGUI_CONSOLE_DATA GuiData = Console->PrivateData;
1305     COORD Coord;
1306     Coord.X = Buffer->ShowX + ((short)LOWORD(lParam) / (int)GuiData->CharWidth);
1307     Coord.Y = Buffer->ShowY + ((short)HIWORD(lParam) / (int)GuiData->CharHeight);
1308
1309     /* Clip coordinate to ensure it's inside buffer */
1310     if (Coord.X < 0)                  Coord.X = 0;
1311     else if (Coord.X >= Buffer->MaxX) Coord.X = Buffer->MaxX - 1;
1312     if (Coord.Y < 0)                  Coord.Y = 0;
1313     else if (Coord.Y >= Buffer->MaxY) Coord.Y = Buffer->MaxY - 1;
1314     return Coord;
1315 }
1316
1317 static VOID
1318 GuiConsoleLeftMouseDown(HWND hWnd, LPARAM lParam)
1319 {
1320     PCSRSS_CONSOLE Console;
1321     PGUI_CONSOLE_DATA GuiData;
1322
1323     GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
1324     if (Console == NULL || GuiData == NULL) return;
1325
1326     Console->Selection.dwSelectionAnchor = PointToCoord(Console, lParam);
1327
1328     SetCapture(hWnd);
1329
1330     Console->Selection.dwFlags |= CONSOLE_SELECTION_IN_PROGRESS | CONSOLE_MOUSE_SELECTION | CONSOLE_MOUSE_DOWN;
1331
1332     GuiConsoleUpdateSelection(Console, &Console->Selection.dwSelectionAnchor);
1333 }
1334
1335 static VOID
1336 GuiConsoleLeftMouseUp(HWND hWnd, LPARAM lParam)
1337 {
1338     PCSRSS_CONSOLE Console;
1339     PGUI_CONSOLE_DATA GuiData;
1340     COORD c;
1341
1342     GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
1343     if (Console == NULL || GuiData == NULL) return;
1344     if (!(Console->Selection.dwFlags & CONSOLE_MOUSE_DOWN)) return;
1345
1346     c = PointToCoord(Console, lParam);
1347
1348     Console->Selection.dwFlags &= ~CONSOLE_MOUSE_DOWN;
1349
1350     GuiConsoleUpdateSelection(Console, &c);
1351
1352     ReleaseCapture();
1353 }
1354
1355 static VOID
1356 GuiConsoleMouseMove(HWND hWnd, WPARAM wParam, LPARAM lParam)
1357 {
1358     PCSRSS_CONSOLE Console;
1359     PGUI_CONSOLE_DATA GuiData;
1360     COORD c;
1361
1362     if (!(wParam & MK_LBUTTON)) return;
1363
1364     GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
1365     if (Console == NULL || GuiData == NULL) return;
1366     if (!(Console->Selection.dwFlags & CONSOLE_MOUSE_DOWN)) return;
1367
1368     c = PointToCoord(Console, lParam); /* TODO: Scroll buffer to bring c into view */
1369
1370     GuiConsoleUpdateSelection(Console, &c);
1371 }
1372
1373 static VOID
1374 GuiConsoleCopy(HWND hWnd, PCSRSS_CONSOLE Console)
1375 {
1376     if (OpenClipboard(hWnd) == TRUE)
1377     {
1378         HANDLE hData;
1379         PBYTE ptr;
1380         LPSTR data, dstPos;
1381         ULONG selWidth, selHeight;
1382         ULONG xPos, yPos, size;
1383
1384         selWidth = Console->Selection.srSelection.Right - Console->Selection.srSelection.Left + 1;
1385         selHeight = Console->Selection.srSelection.Bottom - Console->Selection.srSelection.Top + 1;
1386         DPRINT("Selection is (%d|%d) to (%d|%d)\n",
1387                Console->Selection.srSelection.Left,
1388                Console->Selection.srSelection.Top,
1389                Console->Selection.srSelection.Right,
1390                Console->Selection.srSelection.Bottom);
1391
1392         /* Basic size for one line and termination */
1393         size = selWidth + 1;
1394         if (selHeight > 0)
1395         {
1396             /* Multiple line selections have to get \r\n appended */
1397             size += ((selWidth + 2) * (selHeight - 1));
1398         }
1399
1400         /* Allocate memory, it will be passed to the system and may not be freed here */
1401         hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, size);
1402         if (hData == NULL)
1403         {
1404             CloseClipboard();
1405             return;
1406         }
1407         data = GlobalLock(hData);
1408         if (data == NULL)
1409         {
1410             CloseClipboard();
1411             return;
1412         }
1413
1414         DPRINT("Copying %dx%d selection\n", selWidth, selHeight);
1415         dstPos = data;
1416
1417         for (yPos = 0; yPos < selHeight; yPos++)
1418         {
1419             ptr = ConioCoordToPointer(Console->ActiveBuffer,
1420                                       Console->Selection.srSelection.Left,
1421                                       yPos + Console->Selection.srSelection.Top);
1422             /* Copy only the characters, leave attributes alone */
1423             for (xPos = 0; xPos < selWidth; xPos++)
1424             {
1425                 dstPos[xPos] = ptr[xPos * 2];
1426             }
1427             dstPos += selWidth;
1428             if (yPos != (selHeight - 1))
1429             {
1430                 strcat(data, "\r\n");
1431                 dstPos += 2;
1432             }
1433         }
1434
1435         DPRINT("Setting data <%s> to clipboard\n", data);
1436         GlobalUnlock(hData);
1437
1438         EmptyClipboard();
1439         SetClipboardData(CF_TEXT, hData);
1440         CloseClipboard();
1441     }
1442 }
1443
1444 static VOID
1445 GuiConsolePaste(HWND hWnd, PCSRSS_CONSOLE Console)
1446 {
1447     if (OpenClipboard(hWnd) == TRUE)
1448     {
1449         HANDLE hData;
1450         LPSTR str;
1451         size_t len;
1452
1453         hData = GetClipboardData(CF_TEXT);
1454         if (hData == NULL)
1455         {
1456             CloseClipboard();
1457             return;
1458         }
1459
1460         str = GlobalLock(hData);
1461         if (str == NULL)
1462         {
1463             CloseClipboard();
1464             return;
1465         }
1466         DPRINT("Got data <%s> from clipboard\n", str);
1467         len = strlen(str);
1468
1469         ConioWriteConsole(Console, Console->ActiveBuffer, str, len, TRUE);
1470
1471         GlobalUnlock(hData);
1472         CloseClipboard();
1473     }
1474 }
1475
1476 static VOID
1477 GuiConsoleRightMouseDown(HWND hWnd)
1478 {
1479     PCSRSS_CONSOLE Console;
1480     PGUI_CONSOLE_DATA GuiData;
1481
1482     GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
1483     if (Console == NULL || GuiData == NULL) return;
1484
1485     if (!(Console->Selection.dwFlags & CONSOLE_SELECTION_NOT_EMPTY))
1486     {
1487         GuiConsolePaste(hWnd, Console);
1488     }
1489     else
1490     {
1491         GuiConsoleCopy(hWnd, Console);
1492
1493         /* Clear the selection */
1494         GuiConsoleUpdateSelection(Console, NULL);
1495     }
1496
1497 }
1498
1499
1500 static VOID
1501 GuiConsoleShowConsoleProperties(HWND hWnd, BOOL Defaults, PGUI_CONSOLE_DATA GuiData)
1502 {
1503     PCSRSS_CONSOLE Console;
1504     APPLET_PROC CPLFunc;
1505     TCHAR szBuffer[MAX_PATH];
1506     ConsoleInfo SharedInfo;
1507
1508     DPRINT("GuiConsoleShowConsoleProperties entered\n");
1509
1510     GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
1511
1512     if (GuiData == NULL)
1513     {
1514         DPRINT("GuiConsoleGetDataPointers failed\n");
1515         return;
1516     }
1517
1518     if (GuiData->ConsoleLibrary == NULL)
1519     {
1520         GetWindowsDirectory(szBuffer,MAX_PATH);
1521         _tcscat(szBuffer, _T("\\system32\\console.dll"));
1522         GuiData->ConsoleLibrary = LoadLibrary(szBuffer);
1523
1524         if (GuiData->ConsoleLibrary == NULL)
1525         {
1526             DPRINT1("failed to load console.dll");
1527             return;
1528         }
1529     }
1530
1531     CPLFunc = (APPLET_PROC) GetProcAddress(GuiData->ConsoleLibrary, _T("CPlApplet"));
1532     if (!CPLFunc)
1533     {
1534         DPRINT("Error: Console.dll misses CPlApplet export\n");
1535         return;
1536     }
1537
1538     /* setup struct */
1539     SharedInfo.InsertMode = GuiData->InsertMode;
1540     SharedInfo.HistoryBufferSize = Console->HistoryBufferSize;
1541     SharedInfo.NumberOfHistoryBuffers = Console->NumberOfHistoryBuffers;
1542     SharedInfo.ScreenText = GuiData->ScreenText;
1543     SharedInfo.ScreenBackground = GuiData->ScreenBackground;
1544     SharedInfo.PopupText = GuiData->PopupText;
1545     SharedInfo.PopupBackground = GuiData->PopupBackground;
1546     SharedInfo.WindowSize = (DWORD)MAKELONG(Console->Size.X, Console->Size.Y);
1547     SharedInfo.WindowPosition = GuiData->WindowPosition;
1548     SharedInfo.ScreenBuffer = (DWORD)MAKELONG(Console->ActiveBuffer->MaxX, Console->ActiveBuffer->MaxY);
1549     SharedInfo.UseRasterFonts = GuiData->UseRasterFonts;
1550     SharedInfo.FontSize = (DWORD)GuiData->FontSize;
1551     SharedInfo.FontWeight = GuiData->FontWeight;
1552     SharedInfo.CursorSize = Console->ActiveBuffer->CursorInfo.dwSize;
1553     SharedInfo.HistoryNoDup = Console->HistoryNoDup;
1554     SharedInfo.FullScreen = GuiData->FullScreen;
1555     SharedInfo.QuickEdit = GuiData->QuickEdit;
1556     memcpy(&SharedInfo.Colors[0], GuiData->Colors, sizeof(s_Colors));
1557
1558     if (!CPLFunc(hWnd, CPL_INIT, 0, 0))
1559     {
1560         DPRINT("Error: failed to initialize console.dll\n");
1561         return;
1562     }
1563
1564     if (CPLFunc(hWnd, CPL_GETCOUNT, 0, 0) != 1)
1565     {
1566         DPRINT("Error: console.dll returned unexpected CPL count\n");
1567         return;
1568     }
1569
1570     CPLFunc(hWnd, CPL_DBLCLK, (LPARAM)&SharedInfo, Defaults);
1571 }
1572 static LRESULT
1573 GuiConsoleHandleSysMenuCommand(HWND hWnd, WPARAM wParam, LPARAM lParam)
1574 {
1575     LRESULT Ret = TRUE;
1576     PCSRSS_CONSOLE Console;
1577     PGUI_CONSOLE_DATA GuiData;
1578     COORD bottomRight = { 0, 0 };
1579
1580     GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
1581
1582     switch(wParam)
1583     {
1584     case ID_SYSTEM_EDIT_MARK:
1585         DPRINT1("Marking not handled yet\n");
1586         break;
1587
1588     case ID_SYSTEM_EDIT_COPY:
1589         GuiConsoleCopy(hWnd, Console);
1590         break;
1591
1592     case ID_SYSTEM_EDIT_PASTE:
1593         GuiConsolePaste(hWnd, Console);
1594         break;
1595
1596     case ID_SYSTEM_EDIT_SELECTALL:
1597         bottomRight.X = Console->Size.X - 1;
1598         bottomRight.Y = Console->Size.Y - 1;
1599         GuiConsoleUpdateSelection(Console, &bottomRight);
1600         break;
1601
1602     case ID_SYSTEM_EDIT_SCROLL:
1603         DPRINT1("Scrolling is not handled yet\n");
1604         break;
1605
1606     case ID_SYSTEM_EDIT_FIND:
1607         DPRINT1("Finding is not handled yet\n");
1608         break;
1609
1610     case ID_SYSTEM_DEFAULTS:
1611         GuiConsoleShowConsoleProperties(hWnd, TRUE, GuiData);
1612         break;
1613
1614     case ID_SYSTEM_PROPERTIES:
1615         GuiConsoleShowConsoleProperties(hWnd, FALSE, GuiData);
1616         break;
1617
1618     default:
1619         Ret = DefWindowProcW(hWnd, WM_SYSCOMMAND, wParam, lParam);
1620         break;
1621     }
1622     return Ret;
1623 }
1624
1625 static VOID
1626 GuiConsoleGetMinMaxInfo(HWND hWnd, PMINMAXINFO minMaxInfo)
1627 {
1628     PCSRSS_CONSOLE Console;
1629     PGUI_CONSOLE_DATA GuiData;
1630     DWORD windx, windy;
1631
1632     GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
1633     if((Console == NULL)|| (GuiData == NULL)) return;
1634
1635     windx = CONGUI_MIN_WIDTH * GuiData->CharWidth + 2 * (GetSystemMetrics(SM_CXFRAME) + GetSystemMetrics(SM_CXEDGE));
1636     windy = CONGUI_MIN_HEIGHT * GuiData->CharHeight + 2 * (GetSystemMetrics(SM_CYFRAME) + GetSystemMetrics(SM_CYEDGE)) + GetSystemMetrics(SM_CYCAPTION);
1637
1638     minMaxInfo->ptMinTrackSize.x = windx;
1639     minMaxInfo->ptMinTrackSize.y = windy;
1640
1641     windx = (Console->ActiveBuffer->MaxX) * GuiData->CharWidth + 2 * (GetSystemMetrics(SM_CXFRAME) + GetSystemMetrics(SM_CXEDGE));
1642     windy = (Console->ActiveBuffer->MaxY) * GuiData->CharHeight + 2 * (GetSystemMetrics(SM_CYFRAME) + GetSystemMetrics(SM_CYEDGE)) + GetSystemMetrics(SM_CYCAPTION);
1643
1644     if(Console->Size.X < Console->ActiveBuffer->MaxX) windy += GetSystemMetrics(SM_CYHSCROLL);    // window currently has a horizontal scrollbar
1645     if(Console->Size.Y < Console->ActiveBuffer->MaxY) windx += GetSystemMetrics(SM_CXVSCROLL);    // window currently has a vertical scrollbar
1646
1647     minMaxInfo->ptMaxTrackSize.x = windx;
1648     minMaxInfo->ptMaxTrackSize.y = windy;
1649 }
1650 static VOID
1651 GuiConsoleResize(HWND hWnd, WPARAM wParam, LPARAM lParam)
1652 {
1653     PCSRSS_CONSOLE Console;
1654     PGUI_CONSOLE_DATA GuiData;
1655     GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
1656     if((Console == NULL) || (GuiData == NULL)) return;
1657
1658     if ((GuiData->WindowSizeLock == FALSE) && (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED || wParam == SIZE_MINIMIZED))
1659     {
1660         PCSRSS_SCREEN_BUFFER Buff = Console->ActiveBuffer;
1661         DWORD windx, windy, charx, chary;
1662
1663         GuiData->WindowSizeLock = TRUE;
1664
1665         windx = LOWORD(lParam);
1666         windy = HIWORD(lParam);
1667
1668         // Compensate for existing scroll bars (because lParam values do not accommodate scroll bar)
1669         if(Console->Size.X < Buff->MaxX) windy += GetSystemMetrics(SM_CYHSCROLL);    // window currently has a horizontal scrollbar
1670         if(Console->Size.Y < Buff->MaxY) windx += GetSystemMetrics(SM_CXVSCROLL);    // window currently has a vertical scrollbar
1671
1672         charx = windx / GuiData->CharWidth;
1673         chary = windy / GuiData->CharHeight;
1674
1675         // Character alignment (round size up or down)
1676         if((windx % GuiData->CharWidth) >= (GuiData->CharWidth / 2)) ++charx;
1677         if((windy % GuiData->CharHeight) >= (GuiData->CharHeight / 2)) ++chary;
1678
1679         // Compensate for added scroll bars in new window
1680         if(charx < Buff->MaxX)windy -= GetSystemMetrics(SM_CYHSCROLL);    // new window will have a horizontal scroll bar
1681         if(chary < Buff->MaxY)windx -= GetSystemMetrics(SM_CXVSCROLL);    // new window will have a vertical scroll bar
1682
1683         charx = windx / GuiData->CharWidth;
1684         chary = windy / GuiData->CharHeight;
1685
1686         // Character alignment (round size up or down)
1687         if((windx % GuiData->CharWidth) >= (GuiData->CharWidth / 2)) ++charx;
1688         if((windy % GuiData->CharHeight) >= (GuiData->CharHeight / 2)) ++chary;
1689
1690         // Resize window
1691         if((charx != Console->Size.X) || (chary != Console->Size.Y))
1692         {
1693             Console->Size.X = (charx <= Buff->MaxX) ? charx : Buff->MaxX;
1694             Console->Size.Y = (chary <= Buff->MaxY) ? chary : Buff->MaxY;
1695         }
1696
1697         GuiConsoleInitScrollbar(Console, hWnd);
1698
1699         // Adjust the start of the visible area if we are attempting to show nonexistent areas
1700         if((Buff->MaxX - Buff->ShowX) < Console->Size.X) Buff->ShowX = Buff->MaxX - Console->Size.X;
1701         if((Buff->MaxY - Buff->ShowY) < Console->Size.Y) Buff->ShowY = Buff->MaxY - Console->Size.Y;
1702         InvalidateRect(hWnd, NULL, TRUE);
1703
1704         GuiData->WindowSizeLock = FALSE;
1705     }
1706 }
1707
1708 VOID
1709 FASTCALL
1710 GuiConsoleHandleScrollbarMenu()
1711 {
1712     HMENU hMenu;
1713
1714     hMenu = CreatePopupMenu();
1715     if (hMenu == NULL)
1716     {
1717         DPRINT("CreatePopupMenu failed\n");
1718         return;
1719     }
1720     //InsertItem(hMenu, MIIM_STRING, MIIM_ID | MIIM_FTYPE | MIIM_STRING, 0, NULL, IDS_SCROLLHERE);
1721     //InsertItem(hMenu, MFT_SEPARATOR, MIIM_FTYPE, 0, NULL, -1);
1722     //InsertItem(hMenu, MIIM_STRING, MIIM_ID | MIIM_FTYPE | MIIM_STRING, 0, NULL, IDS_SCROLLTOP);
1723     //InsertItem(hMenu, MIIM_STRING, MIIM_ID | MIIM_FTYPE | MIIM_STRING, 0, NULL, IDS_SCROLLBOTTOM);
1724     //InsertItem(hMenu, MFT_SEPARATOR, MIIM_FTYPE, 0, NULL, -1);
1725     //InsertItem(hMenu, MIIM_STRING, MIIM_ID | MIIM_FTYPE | MIIM_STRING, 0, NULL, IDS_SCROLLPAGE_UP);
1726     //InsertItem(hMenu, MIIM_STRING, MIIM_ID | MIIM_FTYPE | MIIM_STRING, 0, NULL, IDS_SCROLLPAGE_DOWN);
1727     //InsertItem(hMenu, MFT_SEPARATOR, MIIM_FTYPE, 0, NULL, -1);
1728     //InsertItem(hMenu, MIIM_STRING, MIIM_ID | MIIM_FTYPE | MIIM_STRING, 0, NULL, IDS_SCROLLUP);
1729     //InsertItem(hMenu, MIIM_STRING, MIIM_ID | MIIM_FTYPE | MIIM_STRING, 0, NULL, IDS_SCROLLDOWN);
1730
1731 }
1732
1733 static NTSTATUS WINAPI
1734 GuiResizeBuffer(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER ScreenBuffer, COORD Size)
1735 {
1736     BYTE * Buffer;
1737     DWORD Offset = 0;
1738     BYTE * OldPtr;
1739     USHORT CurrentY;
1740     BYTE * OldBuffer;
1741 #if HAVE_WMEMSET
1742     USHORT value = MAKEWORD(' ', ScreenBuffer->DefaultAttrib);
1743 #endif
1744     DWORD diff;
1745     DWORD i;
1746
1747     /* Buffer size is not allowed to be smaller than window size */
1748     if (Size.X < Console->Size.X || Size.Y < Console->Size.Y)
1749         return STATUS_INVALID_PARAMETER;
1750
1751     if (Size.X == ScreenBuffer->MaxX && Size.Y == ScreenBuffer->MaxY)
1752         return STATUS_SUCCESS;
1753
1754     Buffer = HeapAlloc(Win32CsrApiHeap, 0, Size.X * Size.Y * 2);
1755     if (!Buffer)
1756         return STATUS_NO_MEMORY;
1757
1758     DPRINT1("Resizing (%d,%d) to (%d,%d)\n", ScreenBuffer->MaxX, ScreenBuffer->MaxY, Size.X, Size.Y);
1759     OldBuffer = ScreenBuffer->Buffer;
1760
1761     for (CurrentY = 0; CurrentY < ScreenBuffer->MaxY && CurrentY < Size.Y; CurrentY++)
1762     {
1763         OldPtr = ConioCoordToPointer(ScreenBuffer, 0, CurrentY);
1764         if (Size.X <= ScreenBuffer->MaxX)
1765         {
1766             /* reduce size */
1767             RtlCopyMemory(&Buffer[Offset], OldPtr, Size.X * 2);
1768             Offset += (Size.X * 2);
1769         }
1770         else
1771         {
1772             /* enlarge size */
1773             RtlCopyMemory(&Buffer[Offset], OldPtr, ScreenBuffer->MaxX * 2);
1774             Offset += (ScreenBuffer->MaxX * 2);
1775
1776             diff = Size.X - ScreenBuffer->MaxX;
1777             /* zero new part of it */
1778 #if HAVE_WMEMSET
1779             wmemset((WCHAR*)&Buffer[Offset], value, diff);
1780 #else
1781             for (i = 0; i < diff; i++)
1782             {
1783                 Buffer[Offset++] = ' ';
1784                 Buffer[Offset++] = ScreenBuffer->DefaultAttrib;
1785             }
1786 #endif
1787         }
1788     }
1789
1790     if (Size.Y > ScreenBuffer->MaxY)
1791     {
1792         diff = Size.X * (Size.Y - ScreenBuffer->MaxY);
1793 #if HAVE_WMEMSET
1794         wmemset((WCHAR*)&Buffer[Offset], value, diff);
1795 #else
1796         for (i = 0; i < diff; i++)
1797         {
1798             Buffer[Offset++] = ' ';
1799             Buffer[Offset++] = ScreenBuffer->DefaultAttrib;
1800         }
1801 #endif
1802     }
1803
1804     (void)InterlockedExchangePointer((PVOID volatile  *)&ScreenBuffer->Buffer, Buffer);
1805     HeapFree(Win32CsrApiHeap, 0, OldBuffer);
1806     ScreenBuffer->MaxX = Size.X;
1807     ScreenBuffer->MaxY = Size.Y;
1808     ScreenBuffer->VirtualY = 0;
1809
1810     /* Ensure cursor and window are within buffer */
1811     if (ScreenBuffer->CurrentX >= Size.X)
1812         ScreenBuffer->CurrentX = Size.X - 1;
1813     if (ScreenBuffer->CurrentY >= Size.Y)
1814         ScreenBuffer->CurrentY = Size.Y - 1;
1815     if (ScreenBuffer->ShowX > Size.X - Console->Size.X)
1816         ScreenBuffer->ShowX = Size.X - Console->Size.X;
1817     if (ScreenBuffer->ShowY > Size.Y - Console->Size.Y)
1818         ScreenBuffer->ShowY = Size.Y - Console->Size.Y;
1819
1820     /* TODO: Should update scrollbar, but can't use anything that
1821      * calls SendMessage or it could cause deadlock */
1822
1823     return STATUS_SUCCESS;
1824 }
1825
1826 static VOID
1827 GuiApplyUserSettings(PCSRSS_CONSOLE Console, PGUI_CONSOLE_DATA GuiData, PConsoleInfo pConInfo)
1828 {
1829     DWORD windx, windy;
1830     PCSRSS_SCREEN_BUFFER ActiveBuffer = Console->ActiveBuffer;
1831     COORD BufSize;
1832     BOOL SizeChanged = FALSE;
1833
1834     EnterCriticalSection(&Console->Lock);
1835
1836     /* apply text / background color */
1837     GuiData->ScreenText = pConInfo->ScreenText;
1838     GuiData->ScreenBackground = pConInfo->ScreenBackground;
1839
1840     /* apply cursor size */
1841     ActiveBuffer->CursorInfo.dwSize = min(max(pConInfo->CursorSize, 1), 100);
1842
1843     windx = LOWORD(pConInfo->WindowSize);
1844     windy = HIWORD(pConInfo->WindowSize);
1845
1846     if (windx != Console->Size.X || windy != Console->Size.Y)
1847     {
1848         /* resize window */
1849         Console->Size.X = windx;
1850         Console->Size.Y = windy;
1851         SizeChanged = TRUE;
1852     }
1853
1854     BufSize.X = LOWORD(pConInfo->ScreenBuffer);
1855     BufSize.Y = HIWORD(pConInfo->ScreenBuffer);
1856     if (BufSize.X != ActiveBuffer->MaxX || BufSize.Y != ActiveBuffer->MaxY)
1857     {
1858         if (NT_SUCCESS(GuiResizeBuffer(Console, ActiveBuffer, BufSize)))
1859             SizeChanged = TRUE;
1860     }
1861
1862     if (SizeChanged)
1863     {
1864         GuiData->WindowSizeLock = TRUE;
1865         GuiConsoleInitScrollbar(Console, pConInfo->hConsoleWindow);
1866         GuiData->WindowSizeLock = FALSE;
1867     }
1868
1869     LeaveCriticalSection(&Console->Lock);
1870     InvalidateRect(pConInfo->hConsoleWindow, NULL, TRUE);
1871 }
1872
1873 static
1874 LRESULT
1875 GuiConsoleHandleScroll(HWND hwnd, UINT uMsg, WPARAM wParam)
1876 {
1877     PCSRSS_CONSOLE Console;
1878     PCSRSS_SCREEN_BUFFER Buff;
1879     PGUI_CONSOLE_DATA GuiData;
1880     SCROLLINFO sInfo;
1881     int fnBar;
1882     int old_pos, Maximum;
1883     PUSHORT pShowXY;
1884
1885     GuiConsoleGetDataPointers(hwnd, &Console, &GuiData);
1886     if (Console == NULL || GuiData == NULL)
1887         return FALSE;
1888     Buff = Console->ActiveBuffer;
1889
1890     if (uMsg == WM_HSCROLL)
1891     {
1892         fnBar = SB_HORZ;
1893         Maximum = Buff->MaxX - Console->Size.X;
1894         pShowXY = &Buff->ShowX;
1895     }
1896     else
1897     {
1898         fnBar = SB_VERT;
1899         Maximum = Buff->MaxY - Console->Size.Y;
1900         pShowXY = &Buff->ShowY;
1901     }
1902
1903     /* set scrollbar sizes */
1904     sInfo.cbSize = sizeof(SCROLLINFO);
1905     sInfo.fMask = SIF_RANGE | SIF_POS | SIF_PAGE | SIF_TRACKPOS;
1906
1907     if (!GetScrollInfo(hwnd, fnBar, &sInfo))
1908     {
1909         return FALSE;
1910     }
1911
1912     old_pos = sInfo.nPos;
1913
1914     switch(LOWORD(wParam))
1915     {
1916     case SB_LINELEFT:
1917         sInfo.nPos -= 1;
1918         break;
1919
1920     case SB_LINERIGHT:
1921         sInfo.nPos += 1;
1922         break;
1923
1924     case SB_PAGELEFT:
1925         sInfo.nPos -= sInfo.nPage;
1926         break;
1927
1928     case SB_PAGERIGHT:
1929         sInfo.nPos += sInfo.nPage;
1930         break;
1931
1932     case SB_THUMBTRACK:
1933         sInfo.nPos = sInfo.nTrackPos;
1934         ConioPause(Console, PAUSED_FROM_SCROLLBAR);
1935         break;
1936
1937     case SB_THUMBPOSITION:
1938         ConioUnpause(Console, PAUSED_FROM_SCROLLBAR);
1939         break;
1940
1941     case SB_TOP:
1942         sInfo.nPos = sInfo.nMin;
1943         break;
1944
1945     case SB_BOTTOM:
1946         sInfo.nPos = sInfo.nMax;
1947         break;
1948
1949     default:
1950         break;
1951     }
1952
1953     sInfo.nPos = max(sInfo.nPos, 0);
1954     sInfo.nPos = min(sInfo.nPos, Maximum);
1955
1956     if (old_pos != sInfo.nPos)
1957     {
1958         USHORT OldX = Buff->ShowX;
1959         USHORT OldY = Buff->ShowY;
1960         *pShowXY = sInfo.nPos;
1961
1962         ScrollWindowEx(hwnd,
1963                        (OldX - Buff->ShowX) * GuiData->CharWidth,
1964                        (OldY - Buff->ShowY) * GuiData->CharHeight,
1965                        NULL,
1966                        NULL,
1967                        NULL,
1968                        NULL,
1969                        SW_INVALIDATE);
1970
1971         sInfo.fMask = SIF_POS;
1972         SetScrollInfo(hwnd, fnBar, &sInfo, TRUE);
1973
1974         UpdateWindow(hwnd);
1975     }
1976     return 0;
1977 }
1978
1979 static LRESULT CALLBACK
1980 GuiConsoleWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1981 {
1982     LRESULT Result = 0;
1983     PGUI_CONSOLE_DATA GuiData = NULL;
1984     PCSRSS_CONSOLE Console = NULL;
1985
1986     GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
1987
1988     switch(msg)
1989     {
1990     case WM_NCCREATE:
1991         Result = (LRESULT) GuiConsoleHandleNcCreate(hWnd, (CREATESTRUCTW *) lParam);
1992         break;
1993     case WM_PAINT:
1994         GuiConsoleHandlePaint(hWnd, (HDC)wParam);
1995         break;
1996     case WM_KEYDOWN:
1997     case WM_KEYUP:
1998     case WM_SYSKEYDOWN:
1999     case WM_SYSKEYUP:
2000     case WM_CHAR:
2001         GuiConsoleHandleKey(hWnd, msg, wParam, lParam);
2002         break;
2003     case WM_TIMER:
2004         GuiConsoleHandleTimer(hWnd);
2005         break;
2006     case WM_CLOSE:
2007         GuiConsoleHandleClose(hWnd);
2008         break;
2009     case WM_NCDESTROY:
2010         GuiConsoleHandleNcDestroy(hWnd);
2011         break;
2012     case WM_LBUTTONDOWN:
2013         GuiConsoleLeftMouseDown(hWnd, lParam);
2014         break;
2015     case WM_LBUTTONUP:
2016         GuiConsoleLeftMouseUp(hWnd, lParam);
2017         break;
2018     case WM_RBUTTONDOWN:
2019         GuiConsoleRightMouseDown(hWnd);
2020         break;
2021     case WM_MOUSEMOVE:
2022         GuiConsoleMouseMove(hWnd, wParam, lParam);
2023         break;
2024     case WM_SYSCOMMAND:
2025         Result = GuiConsoleHandleSysMenuCommand(hWnd, wParam, lParam);
2026         break;
2027     case WM_HSCROLL:
2028     case WM_VSCROLL:
2029         Result = GuiConsoleHandleScroll(hWnd, msg, wParam);
2030         break;
2031     case WM_GETMINMAXINFO:
2032         GuiConsoleGetMinMaxInfo(hWnd, (PMINMAXINFO)lParam);
2033         break;
2034     case WM_SIZE:
2035         GuiConsoleResize(hWnd, wParam, lParam);
2036         break;
2037     case PM_APPLY_CONSOLE_INFO:
2038         GuiApplyUserSettings(Console, GuiData, (PConsoleInfo)wParam);
2039         if (lParam)
2040         {
2041             GuiConsoleWriteUserSettings(Console, GuiData);
2042         }
2043         break;
2044     default:
2045         Result = DefWindowProcW(hWnd, msg, wParam, lParam);
2046         break;
2047     }
2048
2049     return Result;
2050 }
2051
2052 static LRESULT CALLBACK
2053 GuiConsoleNotifyWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
2054 {
2055     HWND NewWindow;
2056     LONG WindowCount;
2057     MSG Msg;
2058     PWCHAR Buffer, Title;
2059     PCSRSS_CONSOLE Console = (PCSRSS_CONSOLE) lParam;
2060
2061
2062
2063     switch(msg)
2064     {
2065     case WM_CREATE:
2066         SetWindowLongW(hWnd, GWL_USERDATA, 0);
2067         return 0;
2068     case PM_CREATE_CONSOLE:
2069         Buffer = HeapAlloc(Win32CsrApiHeap, 0,
2070                            Console->Title.Length + sizeof(WCHAR));
2071         if (NULL != Buffer)
2072         {
2073             memcpy(Buffer, Console->Title.Buffer, Console->Title.Length);
2074             Buffer[Console->Title.Length / sizeof(WCHAR)] = L'\0';
2075             Title = Buffer;
2076         }
2077         else
2078         {
2079             Title = L"";
2080         }
2081         NewWindow = CreateWindowExW(WS_EX_CLIENTEDGE,
2082                                     L"ConsoleWindowClass",
2083                                     Title,
2084                                     WS_OVERLAPPEDWINDOW | WS_HSCROLL | WS_VSCROLL,
2085                                     CW_USEDEFAULT,
2086                                     CW_USEDEFAULT,
2087                                     CW_USEDEFAULT,
2088                                     CW_USEDEFAULT,
2089                                     NULL,
2090                                     NULL,
2091                                     (HINSTANCE) GetModuleHandleW(NULL),
2092                                     (PVOID) Console);
2093         if (NULL != Buffer)
2094         {
2095             HeapFree(Win32CsrApiHeap, 0, Buffer);
2096         }
2097         if (NULL != NewWindow)
2098         {
2099             SetWindowLongW(hWnd, GWL_USERDATA, GetWindowLongW(hWnd, GWL_USERDATA) + 1);
2100             if (wParam)
2101               {
2102                 ShowWindow(NewWindow, SW_SHOW);
2103               }
2104         }
2105         return (LRESULT) NewWindow;
2106     case PM_DESTROY_CONSOLE:
2107         /* Window creation is done using a PostMessage(), so it's possible that the
2108          * window that we want to destroy doesn't exist yet. So first empty the message
2109          * queue */
2110         while(PeekMessageW(&Msg, NULL, 0, 0, PM_REMOVE))
2111         {
2112             TranslateMessage(&Msg);
2113             DispatchMessageW(&Msg);
2114         }
2115         DestroyWindow(Console->hWindow);
2116         Console->hWindow = NULL;
2117         WindowCount = GetWindowLongW(hWnd, GWL_USERDATA);
2118         WindowCount--;
2119         SetWindowLongW(hWnd, GWL_USERDATA, WindowCount);
2120         if (0 == WindowCount)
2121         {
2122             NotifyWnd = NULL;
2123             DestroyWindow(hWnd);
2124             PrivateCsrssManualGuiCheck(-1);
2125             PostQuitMessage(0);
2126         }
2127         return 0;
2128     default:
2129         return DefWindowProcW(hWnd, msg, wParam, lParam);
2130     }
2131 }
2132
2133 static DWORD WINAPI
2134 GuiConsoleGuiThread(PVOID Data)
2135 {
2136     MSG msg;
2137     PHANDLE GraphicsStartupEvent = (PHANDLE) Data;
2138
2139     NotifyWnd = CreateWindowW(L"Win32CsrCreateNotify",
2140                               L"",
2141                               WS_OVERLAPPEDWINDOW,
2142                               CW_USEDEFAULT,
2143                               CW_USEDEFAULT,
2144                               CW_USEDEFAULT,
2145                               CW_USEDEFAULT,
2146                               NULL,
2147                               NULL,
2148                               (HINSTANCE) GetModuleHandleW(NULL),
2149                               NULL);
2150     if (NULL == NotifyWnd)
2151     {
2152         PrivateCsrssManualGuiCheck(-1);
2153         SetEvent(*GraphicsStartupEvent);
2154         return 1;
2155     }
2156
2157     SetEvent(*GraphicsStartupEvent);
2158
2159     while(GetMessageW(&msg, NULL, 0, 0))
2160     {
2161         TranslateMessage(&msg);
2162         DispatchMessageW(&msg);
2163     }
2164
2165     return 1;
2166 }
2167
2168 static BOOL
2169 GuiInit(VOID)
2170 {
2171     WNDCLASSEXW wc;
2172
2173     if (NULL == NotifyWnd)
2174     {
2175         PrivateCsrssManualGuiCheck(+1);
2176     }
2177
2178     wc.cbSize = sizeof(WNDCLASSEXW);
2179     wc.lpszClassName = L"Win32CsrCreateNotify";
2180     wc.lpfnWndProc = GuiConsoleNotifyWndProc;
2181     wc.style = 0;
2182     wc.hInstance = (HINSTANCE) GetModuleHandleW(NULL);
2183     wc.hIcon = NULL;
2184     wc.hCursor = NULL;
2185     wc.hbrBackground = NULL;
2186     wc.lpszMenuName = NULL;
2187     wc.cbClsExtra = 0;
2188     wc.cbWndExtra = 0;
2189     wc.hIconSm = NULL;
2190     if (RegisterClassExW(&wc) == 0)
2191     {
2192         DPRINT1("Failed to register notify wndproc\n");
2193         return FALSE;
2194     }
2195
2196     wc.cbSize = sizeof(WNDCLASSEXW);
2197     wc.lpszClassName = L"ConsoleWindowClass";
2198     wc.lpfnWndProc = GuiConsoleWndProc;
2199     wc.style = 0;
2200     wc.hInstance = (HINSTANCE) GetModuleHandleW(NULL);
2201     wc.hIcon = LoadIconW(GetModuleHandleW(L"win32csr"), MAKEINTRESOURCEW(1));
2202     wc.hCursor = LoadCursorW(NULL, (LPCWSTR) IDC_ARROW);
2203     wc.hbrBackground = CreateSolidBrush(RGB(0,0,0));
2204     wc.lpszMenuName = NULL;
2205     wc.cbClsExtra = 0;
2206     wc.cbWndExtra = 0;
2207     wc.hIconSm = LoadImageW(GetModuleHandleW(L"win32csr"), MAKEINTRESOURCEW(1), IMAGE_ICON,
2208                             GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON),
2209                             LR_SHARED);
2210     if (RegisterClassExW(&wc) == 0)
2211     {
2212         DPRINT1("Failed to register console wndproc\n");
2213         return FALSE;
2214     }
2215
2216     return TRUE;
2217 }
2218
2219 static VOID WINAPI
2220 GuiInitScreenBuffer(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buffer)
2221 {
2222     Buffer->DefaultAttrib = DEFAULT_ATTRIB;
2223 }
2224
2225 static BOOL WINAPI
2226 GuiChangeTitle(PCSRSS_CONSOLE Console)
2227 {
2228     PWCHAR Buffer, Title;
2229
2230     Buffer = HeapAlloc(Win32CsrApiHeap, 0,
2231                        Console->Title.Length + sizeof(WCHAR));
2232     if (NULL != Buffer)
2233     {
2234         memcpy(Buffer, Console->Title.Buffer, Console->Title.Length);
2235         Buffer[Console->Title.Length / sizeof(WCHAR)] = L'\0';
2236         Title = Buffer;
2237     }
2238     else
2239     {
2240         Title = L"";
2241     }
2242
2243     SendMessageW(Console->hWindow, WM_SETTEXT, 0, (LPARAM) Title);
2244
2245     if (NULL != Buffer)
2246     {
2247         HeapFree(Win32CsrApiHeap, 0, Buffer);
2248     }
2249
2250     return TRUE;
2251 }
2252
2253 static BOOL WINAPI
2254 GuiChangeIcon(PCSRSS_CONSOLE Console, HICON hWindowIcon)
2255 {
2256     SendMessageW(Console->hWindow, WM_SETICON, ICON_BIG, (LPARAM)hWindowIcon);
2257     SendMessageW(Console->hWindow, WM_SETICON, ICON_SMALL, (LPARAM)hWindowIcon);
2258
2259     return TRUE;
2260 }
2261
2262 static VOID WINAPI
2263 GuiCleanupConsole(PCSRSS_CONSOLE Console)
2264 {
2265     SendMessageW(NotifyWnd, PM_DESTROY_CONSOLE, 0, (LPARAM) Console);
2266 }
2267
2268 static CSRSS_CONSOLE_VTBL GuiVtbl =
2269 {
2270     GuiInitScreenBuffer,
2271     GuiWriteStream,
2272     GuiDrawRegion,
2273     GuiSetCursorInfo,
2274     GuiSetScreenInfo,
2275     GuiUpdateScreenInfo,
2276     GuiChangeTitle,
2277     GuiCleanupConsole,
2278     GuiChangeIcon,
2279     GuiResizeBuffer,
2280 };
2281
2282 NTSTATUS FASTCALL
2283 GuiInitConsole(PCSRSS_CONSOLE Console, BOOL Visible)
2284 {
2285     HANDLE GraphicsStartupEvent;
2286     HANDLE ThreadHandle;
2287     PGUI_CONSOLE_DATA GuiData;
2288
2289     if (! ConsInitialized)
2290     {
2291         ConsInitialized = TRUE;
2292         if (! GuiInit())
2293         {
2294             ConsInitialized = FALSE;
2295             return STATUS_UNSUCCESSFUL;
2296         }
2297     }
2298
2299     Console->Vtbl = &GuiVtbl;
2300     if (NULL == NotifyWnd)
2301     {
2302         GraphicsStartupEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
2303         if (NULL == GraphicsStartupEvent)
2304         {
2305             return STATUS_UNSUCCESSFUL;
2306         }
2307
2308         ThreadHandle = CreateThread(NULL,
2309                                     0,
2310                                     GuiConsoleGuiThread,
2311                                     (PVOID) &GraphicsStartupEvent,
2312                                     0,
2313                                     NULL);
2314         if (NULL == ThreadHandle)
2315         {
2316             NtClose(GraphicsStartupEvent);
2317             DPRINT1("Win32Csr: Failed to create graphics console thread. Expect problems\n");
2318             return STATUS_UNSUCCESSFUL;
2319         }
2320         SetThreadPriority(ThreadHandle, THREAD_PRIORITY_HIGHEST);
2321         CloseHandle(ThreadHandle);
2322
2323         WaitForSingleObject(GraphicsStartupEvent, INFINITE);
2324         CloseHandle(GraphicsStartupEvent);
2325
2326         if (NULL == NotifyWnd)
2327         {
2328             DPRINT1("Win32Csr: Failed to create notification window.\n");
2329             return STATUS_UNSUCCESSFUL;
2330         }
2331     }
2332     GuiData = HeapAlloc(Win32CsrApiHeap, HEAP_ZERO_MEMORY,
2333                         sizeof(GUI_CONSOLE_DATA));
2334     if (!GuiData)
2335     {
2336         DPRINT1("Win32Csr: Failed to create GUI_CONSOLE_DATA\n");
2337         return STATUS_UNSUCCESSFUL;
2338     }
2339
2340     Console->PrivateData = (PVOID) GuiData;
2341     /*
2342      * we need to wait untill the GUI has been fully initialized
2343      * to retrieve custom settings i.e. WindowSize etc..
2344      * Ideally we could use SendNotifyMessage for this but its not
2345      * yet implemented.
2346      *
2347      */
2348     GuiData->hGuiInitEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
2349     /* create console */
2350     PostMessageW(NotifyWnd, PM_CREATE_CONSOLE, Visible, (LPARAM) Console);
2351
2352     /* wait untill initialization has finished */
2353     WaitForSingleObject(GuiData->hGuiInitEvent, INFINITE);
2354     DPRINT("received event Console %p GuiData %p X %d Y %d\n", Console, Console->PrivateData, Console->Size.X, Console->Size.Y);
2355     CloseHandle(GuiData->hGuiInitEvent);
2356     GuiData->hGuiInitEvent = NULL;
2357
2358     return STATUS_SUCCESS;
2359 }
2360
2361 /* EOF */