[ACPPAGE] Make use of the PCH.
[reactos.git] / dll / cpl / console / layout.c
1 /*
2 * PROJECT: ReactOS Console Configuration DLL
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: dll/cpl/console/layout.c
5 * PURPOSE: Layout dialog
6 * PROGRAMMERS: Johannes Anderwald (johannes.anderwald@reactos.org)
7 * Hermes Belusca-Maito (hermes.belusca@sfr.fr)
8 */
9
10 #include "console.h"
11
12 #define NDEBUG
13 #include <debug.h>
14
15 /* CONSOLE WINDOW PREVIEW Control *********************************************/
16
17 #define WIN_PREVIEW_CLASS L"WinPreview"
18
19 typedef struct _WINPREV_DATA
20 {
21 HWND hWnd; // The window which this structure refers to
22 RECT rcMaxArea; // Maximum rectangle in which the preview window can be sized
23 SIZE siPreview; // Actual size of the preview window
24 SIZE siVirtScr; // Width and Height of the virtual screen
25 PVOID pData; // Private data
26 } WINPREV_DATA, *PWINPREV_DATA;
27
28 static LRESULT CALLBACK
29 WinPrevProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
30
31 BOOL
32 RegisterWinPrevClass(
33 IN HINSTANCE hInstance)
34 {
35 WNDCLASSW WndClass;
36
37 WndClass.lpszClassName = WIN_PREVIEW_CLASS;
38 WndClass.lpfnWndProc = WinPrevProc;
39 WndClass.style = 0;
40 WndClass.hInstance = hInstance;
41 WndClass.hIcon = NULL;
42 WndClass.hCursor = LoadCursorW(NULL, MAKEINTRESOURCEW(IDC_ARROW));
43 WndClass.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1);
44 WndClass.lpszMenuName = NULL;
45 WndClass.cbClsExtra = 0;
46 WndClass.cbWndExtra = 0; // sizeof(PWINPREV_DATA);
47
48 return (RegisterClassW(&WndClass) != 0);
49 }
50
51 BOOL
52 UnRegisterWinPrevClass(
53 IN HINSTANCE hInstance)
54 {
55 return UnregisterClassW(WIN_PREVIEW_CLASS, hInstance);
56 }
57
58 static VOID
59 WinPrev_OnDisplayChange(
60 IN PWINPREV_DATA pData)
61 {
62 // RECT rcNew;
63
64 pData->siVirtScr.cx = GetSystemMetrics(SM_CXVIRTUALSCREEN);
65 pData->siVirtScr.cy = GetSystemMetrics(SM_CYVIRTUALSCREEN);
66
67 /*
68 * The rescaling factor "siPreview / siVirtScr" should be the minimum of the ratios
69 * pData->rcMaxArea.right / pData->siVirtScr.cx , and
70 * pData->rcMaxArea.bottom / pData->siVirtScr.cy ,
71 * or equivalently, the maximum of the inverse of these ratios.
72 * This condition is equivalent to the following inequality being tested.
73 */
74 // if (pData->siVirtScr.cx / pData->rcMaxArea.right >= pData->siVirtScr.cy / pData->rcMaxArea.bottom)
75 if (pData->siVirtScr.cx * pData->rcMaxArea.bottom >= pData->siVirtScr.cy * pData->rcMaxArea.right)
76 {
77 pData->siPreview.cx = MulDiv(pData->siVirtScr.cx, pData->rcMaxArea.right, pData->siVirtScr.cx);
78 pData->siPreview.cy = MulDiv(pData->siVirtScr.cy, pData->rcMaxArea.right, pData->siVirtScr.cx);
79 }
80 else
81 {
82 pData->siPreview.cx = MulDiv(pData->siVirtScr.cx, pData->rcMaxArea.bottom, pData->siVirtScr.cy);
83 pData->siPreview.cy = MulDiv(pData->siVirtScr.cy, pData->rcMaxArea.bottom, pData->siVirtScr.cy);
84 }
85
86 /*
87 * Now, the lengths in screen-units can be rescaled into preview-units with:
88 * MulDiv(cx, pData->siPreview.cx, pData->siVirtScr.cx);
89 * and:
90 * MulDiv(cy, pData->siPreview.cy, pData->siVirtScr.cy);
91 */
92
93 #if 0 // TODO: Investigate!
94 /*
95 * Since both rcMaxArea and siPreview are client window area sizes,
96 * transform them into window sizes.
97 */
98 SetRect(&rcNew, 0, 0, pData->siPreview.cx, pData->siPreview.cy);
99 AdjustWindowRect(&rcNew,
100 WS_BORDER,
101 // GetWindowLongPtrW(pData->hWnd, GWL_STYLE) & ~WS_OVERLAPPED,
102 FALSE);
103 OffsetRect(&rcNew, -rcNew.left, -rcNew.top);
104 rcNew.right += 2;
105 rcNew.bottom += 2;
106 #endif
107
108 SetWindowPos(pData->hWnd,
109 0 /* HWND_TOP */,
110 0, 0,
111 pData->siPreview.cx, pData->siPreview.cy,
112 // rcNew.right, rcNew.bottom,
113 SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
114 }
115
116 #define RescaleCX(pData, len) \
117 MulDiv((len), (pData)->siPreview.cx, (pData)->siVirtScr.cx)
118
119 #define RescaleCY(pData, len) \
120 MulDiv((len), (pData)->siPreview.cy, (pData)->siVirtScr.cy)
121
122 #define RescaleRect(pData, rect) \
123 do { \
124 (rect).left = RescaleCX((pData), (rect).left); \
125 (rect).right = RescaleCX((pData), (rect).right); \
126 (rect).top = RescaleCY((pData), (rect).top); \
127 (rect).bottom = RescaleCY((pData), (rect).bottom); \
128 } while (0)
129
130 #if 0
131 static VOID
132 WinPrev_OnSize(VOID)
133 {
134 }
135 #endif
136
137 static VOID
138 WinPrev_OnDraw(
139 IN HDC hDC,
140 IN PWINPREV_DATA pData)
141 {
142 PCONSOLE_STATE_INFO pConInfo = (PCONSOLE_STATE_INFO)pData->pData;
143 HBRUSH hBrush;
144 RECT rcWin, fRect;
145 SIZE /*siBorder,*/ siFrame, siButton, siScroll;
146 SIZE resize;
147
148 RECT rcItem;
149
150 GetClientRect(pData->hWnd, &rcItem);
151
152 /*
153 * Retrieve some system metrics and rescale them.
154 * They will be added separately, so that to always round the sizes up.
155 */
156
157 /* Don't care about border as it is almost always 1 and <= frame size */
158 /* Example: Frame = 4, or 13 ... while Border = 1 */
159 // siBorder.cx = GetSystemMetrics(SM_CXBORDER);
160 // siBorder.cy = GetSystemMetrics(SM_CYBORDER);
161
162 /* Window frame size */
163 siFrame.cx = GetSystemMetrics(SM_CXFRAME);
164 if (siFrame.cx > 0)
165 {
166 siFrame.cx = RescaleCX(pData, siFrame.cx);
167 siFrame.cx = max(1, siFrame.cx);
168 }
169 siFrame.cy = GetSystemMetrics(SM_CYFRAME);
170 if (siFrame.cy > 0)
171 {
172 siFrame.cy = RescaleCY(pData, siFrame.cy);
173 siFrame.cy = max(1, siFrame.cy);
174 }
175
176 /* Window caption buttons */
177 siButton.cx = GetSystemMetrics(SM_CXSIZE);
178 siButton.cx = RescaleCX(pData, siButton.cx);
179 siButton.cx = max(1, siButton.cx);
180
181 siButton.cy = GetSystemMetrics(SM_CYSIZE);
182 siButton.cy = RescaleCY(pData, siButton.cy);
183 siButton.cy = max(1, siButton.cy);
184
185 /* Enlarge them for improving their appearance */
186 // siButton.cx *= 2;
187 siButton.cy *= 2;
188
189 /* Dimensions of the scrollbars */
190 siScroll.cx = GetSystemMetrics(SM_CXVSCROLL);
191 siScroll.cx = RescaleCX(pData, siScroll.cx);
192 siScroll.cx = max(1, siScroll.cx);
193
194 siScroll.cy = GetSystemMetrics(SM_CYHSCROLL);
195 siScroll.cy = RescaleCY(pData, siScroll.cy);
196 siScroll.cy = max(1, siScroll.cy);
197
198
199 // FIXME: Use SM_CXMIN, SM_CYMIN ??
200
201
202 /*
203 * Compute the console window layout
204 */
205
206 /* We start with the console client area, rescaled for the preview */
207 SetRect(&rcWin, 0, 0,
208 pConInfo->WindowSize.X * pConInfo->FontSize.X,
209 pConInfo->WindowSize.Y * pConInfo->FontSize.Y);
210 RescaleRect(pData, rcWin);
211
212 /* Add the scrollbars if needed (does not account for any frame) */
213 if (pConInfo->WindowSize.X < pConInfo->ScreenBufferSize.X)
214 {
215 /* Horizontal scrollbar */
216 rcWin.bottom += siScroll.cy;
217 // NOTE: If an additional exterior frame is needed, add +1
218 }
219 else
220 {
221 /* No scrollbar */
222 siScroll.cy = 0;
223 }
224 if (pConInfo->WindowSize.Y < pConInfo->ScreenBufferSize.Y)
225 {
226 /* Vertical scrollbar */
227 rcWin.right += siScroll.cx;
228 // NOTE: If an additional exterior frame is needed, add +1
229 }
230 else
231 {
232 /* No scrollbar */
233 siScroll.cx = 0;
234 }
235
236 /* Add the title bar, taking into account the frames */
237 rcWin.top -= siButton.cy - 1;
238
239 /* If we have a non-zero window frame size, add an interior border and the frame */
240 resize.cx = (siFrame.cx > 0 ? 1 + siFrame.cx : 0);
241 resize.cy = (siFrame.cy > 0 ? 1 + siFrame.cy : 0);
242
243 /* Add the outer border */
244 ++resize.cx, ++resize.cy;
245
246 InflateRect(&rcWin, resize.cx, resize.cy);
247
248 /* Finally, move the window rectangle back to its correct origin */
249 OffsetRect(&rcWin, -rcWin.left, -rcWin.top);
250
251 if ( pConInfo->WindowPosition.x == MAXDWORD &&
252 pConInfo->WindowPosition.y == MAXDWORD )
253 {
254 // OffsetRect(&rcWin, (rcItem.right - rcItem.left) / 3, (rcItem.bottom - rcItem.top) / 3);
255 OffsetRect(&rcWin, 0, 0);
256 }
257 else
258 {
259 OffsetRect(&rcWin,
260 RescaleCX(pData, pConInfo->WindowPosition.x),
261 RescaleCY(pData, pConInfo->WindowPosition.y));
262 }
263
264
265 /*
266 * Paint the preview window
267 */
268
269 /* Fill the background with desktop colour */
270 FillRect(hDC, &rcItem, GetSysColorBrush(COLOR_BACKGROUND));
271
272 /*
273 * Draw the exterior frame. Use 'FillRect' instead of 'FrameRect'
274 * so that, when we want to draw frames around other elements,
275 * we can just instead separate them with space instead of redrawing
276 * a frame with 'FrameRect'.
277 */
278 FillRect(hDC, &rcWin, GetSysColorBrush(COLOR_WINDOWFRAME));
279 InflateRect(&rcWin, -1, -1);
280
281 /* Draw the border */
282 hBrush = GetSysColorBrush(COLOR_ACTIVEBORDER);
283 if (siFrame.cx > 0)
284 {
285 SetRect(&fRect, rcWin.left, rcWin.top, rcWin.left + siFrame.cx, rcWin.bottom);
286 FillRect(hDC, &fRect, hBrush);
287 SetRect(&fRect, rcWin.right - siFrame.cx, rcWin.top, rcWin.right, rcWin.bottom);
288 FillRect(hDC, &fRect, hBrush);
289
290 InflateRect(&rcWin, -siFrame.cx, 0);
291 }
292 if (siFrame.cy > 0)
293 {
294 SetRect(&fRect, rcWin.left, rcWin.top, rcWin.right, rcWin.top + siFrame.cy);
295 FillRect(hDC, &fRect, hBrush);
296 SetRect(&fRect, rcWin.left, rcWin.bottom - siFrame.cy, rcWin.right, rcWin.bottom);
297 FillRect(hDC, &fRect, hBrush);
298
299 InflateRect(&rcWin, 0, -siFrame.cy);
300 }
301
302 /* Draw the interior frame if we had a border */
303 if (siFrame.cx > 0 || siFrame.cy > 0)
304 {
305 #if 0 // See the remark above
306 SetRect(&fRect, rcWin.left, rcWin.top, rcWin.right, rcWin.bottom);
307 FrameRect(hDC, &fRect, GetSysColorBrush(COLOR_WINDOWFRAME));
308 #endif
309 InflateRect(&rcWin, (siFrame.cx > 0 ? -1 : 0), (siFrame.cy > 0 ? -1 : 0));
310 }
311
312 /* Draw the console window title bar */
313 hBrush = GetSysColorBrush(COLOR_BTNFACE);
314
315 /* Draw the system menu (left button) */
316 SetRect(&fRect, rcWin.left, rcWin.top, rcWin.left + siButton.cx, rcWin.top + siButton.cy - 2);
317 // DrawFrameControl(hDC, &fRect, DFC_CAPTION, DFCS_CAPTIONCLOSE);
318 FillRect(hDC, &fRect, hBrush);
319 fRect.right++; // Separation
320
321 /* Draw the caption bar */
322 SetRect(&fRect, fRect.right, fRect.top, rcWin.right - 2 * (siButton.cx + 1), fRect.bottom);
323 FillRect(hDC, &fRect, GetSysColorBrush(COLOR_ACTIVECAPTION));
324 fRect.right++; // Separation
325
326 /* Draw the minimize menu (first right button) */
327 SetRect(&fRect, fRect.right, fRect.top, fRect.right + siButton.cx, fRect.bottom);
328 // DrawFrameControl(hDC, &fRect, DFC_CAPTION, DFCS_CAPTIONMIN);
329 FillRect(hDC, &fRect, hBrush);
330 fRect.right++; // Separation
331
332 /* Draw the maximize menu (second right button) */
333 SetRect(&fRect, fRect.right, fRect.top, fRect.right + siButton.cx, fRect.bottom);
334 // DrawFrameControl(hDC, &fRect, DFC_CAPTION, DFCS_CAPTIONMAX);
335 FillRect(hDC, &fRect, hBrush);
336
337 rcWin.top += siButton.cy - 1;
338
339 /* Add the scrollbars if needed */
340 if (siScroll.cy > 0 || siScroll.cx > 0)
341 {
342 LONG right, bottom;
343
344 right = rcWin.right;
345 bottom = rcWin.bottom;
346
347 /*
348 * If both the horizontal and vertical scrollbars are present,
349 * reserve some space for the "dead square" at the bottom right.
350 */
351 if (siScroll.cy > 0 && siScroll.cx > 0)
352 {
353 right -= (1 + siScroll.cx);
354 bottom -= (1 + siScroll.cy);
355 }
356
357 hBrush = GetSysColorBrush(COLOR_SCROLLBAR);
358
359 /* Horizontal scrollbar */
360 if (siScroll.cy > 0)
361 {
362 SetRect(&fRect, rcWin.left, rcWin.bottom - siScroll.cy, right, rcWin.bottom);
363 FillRect(hDC, &fRect, hBrush);
364 }
365
366 /* Vertical scrollbar */
367 if (siScroll.cx > 0)
368 {
369 SetRect(&fRect, rcWin.right - siScroll.cx, rcWin.top, rcWin.right, bottom);
370 FillRect(hDC, &fRect, hBrush);
371 }
372
373 /*
374 * If both the horizontal and vertical scrollbars are present,
375 * draw the "dead square" at the bottom right.
376 */
377 if (siScroll.cy > 0 && siScroll.cx > 0)
378 {
379 SetRect(&fRect, rcWin.right - siScroll.cx, rcWin.bottom - siScroll.cy, rcWin.right, rcWin.bottom);
380 FillRect(hDC, &fRect, hBrush);
381 }
382
383 // NOTE: If an additional exterior frame is needed, remove +1 for each direction
384 rcWin.right -= siScroll.cx;
385 rcWin.bottom -= siScroll.cy;
386 }
387
388 /* Draw the console background */
389 hBrush = CreateSolidBrush(pConInfo->ColorTable[BkgdAttribFromAttrib(pConInfo->ScreenAttributes)]);
390 FillRect(hDC, &rcWin, hBrush);
391 DeleteObject(hBrush);
392 }
393
394 static LRESULT CALLBACK
395 WinPrevProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
396 {
397 PWINPREV_DATA pData;
398
399 pData = (PWINPREV_DATA)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
400
401 switch (msg)
402 {
403 case WM_CREATE:
404 {
405 pData = (PWINPREV_DATA)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pData));
406 if (!pData)
407 {
408 /* We failed to allocate our private data, halt the window creation */
409 return (LRESULT)-1;
410 }
411 pData->hWnd = hWnd;
412 pData->pData = ConInfo;
413 GetClientRect(pData->hWnd, &pData->rcMaxArea);
414 // LPCREATESTRUCT::cx and cy give window (not client) size
415 WinPrev_OnDisplayChange(pData);
416 SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)pData);
417 break;
418 }
419
420 case WM_DESTROY:
421 {
422 if (pData)
423 HeapFree(GetProcessHeap(), 0, pData);
424 break;
425 }
426
427 case WM_DISPLAYCHANGE:
428 {
429 WinPrev_OnDisplayChange(pData);
430 UpdateWindow(hWnd);
431 // InvalidateRect(hWnd, NULL, FALSE);
432 break;
433 }
434
435 case WM_SIZE:
436 break;
437
438 case WM_ERASEBKGND:
439 return 1;
440
441 case WM_PAINT:
442 {
443 PAINTSTRUCT ps;
444 BeginPaint(hWnd, &ps);
445 WinPrev_OnDraw(ps.hdc, pData);
446 EndPaint(hWnd, &ps);
447 return 0;
448 }
449 }
450
451 return DefWindowProcW(hWnd, msg, wParam, lParam);
452 }
453
454
455 /* CONSOLE TEXT PREVIEW *******************************************************/
456
457 const WCHAR szPreviewText[] =
458 L"C:\\ReactOS> dir \n" \
459 L"SYSTEM <DIR> 13-04-15 5:00a\n" \
460 L"SYSTEM32 <DIR> 13-04-15 5:00a\n" \
461 L"readme txt 1739 13-04-15 5:00a\n" \
462 L"explorer exe 3329536 13-04-15 5:00a\n" \
463 L"vgafonts cab 18736 13-04-15 5:00a\n" \
464 L"setuplog txt 313 13-04-15 5:00a\n" \
465 L"win ini 7005 13-04-15 5:00a\n" ;
466
467 VOID
468 PaintText(
469 IN LPDRAWITEMSTRUCT drawItem,
470 IN PCONSOLE_STATE_INFO pConInfo,
471 IN TEXT_TYPE TextMode)
472 {
473 USHORT CurrentAttrib;
474 COLORREF pbkColor, ptColor;
475 COLORREF nbkColor, ntColor;
476 HBRUSH hBrush;
477 HFONT hOldFont;
478
479 if (TextMode == Screen)
480 CurrentAttrib = pConInfo->ScreenAttributes;
481 else if (TextMode == Popup)
482 CurrentAttrib = pConInfo->PopupAttributes;
483 else
484 return;
485
486 nbkColor = pConInfo->ColorTable[BkgdAttribFromAttrib(CurrentAttrib)];
487 ntColor = pConInfo->ColorTable[TextAttribFromAttrib(CurrentAttrib)];
488
489 hBrush = CreateSolidBrush(nbkColor);
490 if (!hBrush) return;
491
492 hOldFont = SelectObject(drawItem->hDC, hCurrentFont);
493 //if (hOldFont == NULL)
494 //{
495 // DeleteObject(hBrush);
496 // return;
497 //}
498
499 FillRect(drawItem->hDC, &drawItem->rcItem, hBrush);
500
501 /* Add a few space between the preview window border and the text sample */
502 InflateRect(&drawItem->rcItem, -2, -2);
503
504 ptColor = SetTextColor(drawItem->hDC, ntColor);
505 pbkColor = SetBkColor(drawItem->hDC, nbkColor);
506 DrawTextW(drawItem->hDC, szPreviewText, (INT)wcslen(szPreviewText), &drawItem->rcItem, 0);
507 SetTextColor(drawItem->hDC, ptColor);
508 SetBkColor(drawItem->hDC, pbkColor);
509
510 SelectObject(drawItem->hDC, hOldFont);
511 DeleteObject(hBrush);
512 }
513
514
515 /* LAYOUT DIALOG **************************************************************/
516
517 INT_PTR
518 CALLBACK
519 LayoutProc(HWND hDlg,
520 UINT uMsg,
521 WPARAM wParam,
522 LPARAM lParam)
523 {
524 switch (uMsg)
525 {
526 case WM_INITDIALOG:
527 {
528 /* Multi-monitor support */
529 LONG xVirtScr, yVirtScr; // Coordinates of the top-left virtual screen
530 LONG cxVirtScr, cyVirtScr; // Width and Height of the virtual screen
531 LONG cxFrame , cyFrame ; // Thickness of the window frame
532
533 xVirtScr = GetSystemMetrics(SM_XVIRTUALSCREEN);
534 yVirtScr = GetSystemMetrics(SM_YVIRTUALSCREEN);
535 cxVirtScr = GetSystemMetrics(SM_CXVIRTUALSCREEN);
536 cyVirtScr = GetSystemMetrics(SM_CYVIRTUALSCREEN);
537 cxFrame = GetSystemMetrics(SM_CXFRAME);
538 cyFrame = GetSystemMetrics(SM_CYFRAME);
539
540 SendDlgItemMessageW(hDlg, IDC_UPDOWN_SCREEN_BUFFER_HEIGHT, UDM_SETRANGE, 0, (LPARAM)MAKELONG(9999, 1));
541 SendDlgItemMessageW(hDlg, IDC_UPDOWN_SCREEN_BUFFER_WIDTH , UDM_SETRANGE, 0, (LPARAM)MAKELONG(9999, 1));
542 SendDlgItemMessageW(hDlg, IDC_UPDOWN_WINDOW_SIZE_HEIGHT, UDM_SETRANGE, 0, (LPARAM)MAKELONG(9999, 1));
543 SendDlgItemMessageW(hDlg, IDC_UPDOWN_WINDOW_SIZE_WIDTH , UDM_SETRANGE, 0, (LPARAM)MAKELONG(9999, 1));
544
545 SetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_HEIGHT, ConInfo->ScreenBufferSize.Y, FALSE);
546 SetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_WIDTH , ConInfo->ScreenBufferSize.X, FALSE);
547 SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_HEIGHT, ConInfo->WindowSize.Y, FALSE);
548 SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_WIDTH , ConInfo->WindowSize.X, FALSE);
549
550 SendDlgItemMessageW(hDlg, IDC_UPDOWN_WINDOW_POS_LEFT, UDM_SETRANGE, 0,
551 (LPARAM)MAKELONG(xVirtScr + cxVirtScr - cxFrame, xVirtScr - cxFrame));
552 SendDlgItemMessageW(hDlg, IDC_UPDOWN_WINDOW_POS_TOP , UDM_SETRANGE, 0,
553 (LPARAM)MAKELONG(yVirtScr + cyVirtScr - cyFrame, yVirtScr - cyFrame));
554
555 SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_LEFT, ConInfo->WindowPosition.x, TRUE);
556 SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_TOP , ConInfo->WindowPosition.y, TRUE);
557
558 if (ConInfo->AutoPosition)
559 {
560 EnableDlgItem(hDlg, IDC_EDIT_WINDOW_POS_LEFT, FALSE);
561 EnableDlgItem(hDlg, IDC_EDIT_WINDOW_POS_TOP , FALSE);
562 EnableDlgItem(hDlg, IDC_UPDOWN_WINDOW_POS_LEFT, FALSE);
563 EnableDlgItem(hDlg, IDC_UPDOWN_WINDOW_POS_TOP , FALSE);
564 }
565 CheckDlgButton(hDlg, IDC_CHECK_SYSTEM_POS_WINDOW,
566 ConInfo->AutoPosition ? BST_CHECKED : BST_UNCHECKED);
567
568 return TRUE;
569 }
570
571 case WM_DISPLAYCHANGE:
572 {
573 /* Retransmit to the preview window */
574 SendDlgItemMessageW(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW,
575 WM_DISPLAYCHANGE, wParam, lParam);
576 break;
577 }
578
579 case WM_NOTIFY:
580 {
581 LPPSHNOTIFY lppsn = (LPPSHNOTIFY)lParam;
582
583 if (lppsn->hdr.code == UDN_DELTAPOS)
584 {
585 LPNMUPDOWN lpnmud = (LPNMUPDOWN)lParam;
586 DWORD wheight, wwidth;
587 DWORD sheight, swidth;
588 DWORD left, top;
589
590 if (lppsn->hdr.idFrom == IDC_UPDOWN_WINDOW_SIZE_WIDTH)
591 {
592 wwidth = lpnmud->iPos + lpnmud->iDelta;
593 }
594 else
595 {
596 wwidth = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_WIDTH, NULL, FALSE);
597 }
598
599 if (lppsn->hdr.idFrom == IDC_UPDOWN_WINDOW_SIZE_HEIGHT)
600 {
601 wheight = lpnmud->iPos + lpnmud->iDelta;
602 }
603 else
604 {
605 wheight = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_HEIGHT, NULL, FALSE);
606 }
607
608 if (lppsn->hdr.idFrom == IDC_UPDOWN_SCREEN_BUFFER_WIDTH)
609 {
610 swidth = lpnmud->iPos + lpnmud->iDelta;
611 }
612 else
613 {
614 swidth = GetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_WIDTH, NULL, FALSE);
615 }
616
617 if (lppsn->hdr.idFrom == IDC_UPDOWN_SCREEN_BUFFER_HEIGHT)
618 {
619 sheight = lpnmud->iPos + lpnmud->iDelta;
620 }
621 else
622 {
623 sheight = GetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_HEIGHT, NULL, FALSE);
624 }
625
626 if (lppsn->hdr.idFrom == IDC_UPDOWN_WINDOW_POS_LEFT)
627 {
628 left = lpnmud->iPos + lpnmud->iDelta;
629 }
630 else
631 {
632 left = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_LEFT, NULL, TRUE);
633 }
634
635 if (lppsn->hdr.idFrom == IDC_UPDOWN_WINDOW_POS_TOP)
636 {
637 top = lpnmud->iPos + lpnmud->iDelta;
638 }
639 else
640 {
641 top = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_TOP, NULL, TRUE);
642 }
643
644 if (lppsn->hdr.idFrom == IDC_UPDOWN_WINDOW_SIZE_WIDTH || lppsn->hdr.idFrom == IDC_UPDOWN_WINDOW_SIZE_HEIGHT)
645 {
646 /* Automatically adjust screen buffer size when window size enlarges */
647 if (wwidth >= swidth)
648 {
649 SetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_WIDTH, wwidth, TRUE);
650 swidth = wwidth;
651 }
652 if (wheight >= sheight)
653 {
654 SetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_HEIGHT, wheight, TRUE);
655 sheight = wheight;
656 }
657 }
658
659 /* Be sure that the (new) screen buffer sizes are in the correct range */
660 swidth = min(max(swidth , 1), 0xFFFF);
661 sheight = min(max(sheight, 1), 0xFFFF);
662
663 if (lppsn->hdr.idFrom == IDC_UPDOWN_SCREEN_BUFFER_WIDTH || lppsn->hdr.idFrom == IDC_UPDOWN_SCREEN_BUFFER_HEIGHT)
664 {
665 /* Automatically adjust window size when screen buffer decreases */
666 if (wwidth > swidth)
667 {
668 SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_WIDTH, swidth, TRUE);
669 wwidth = swidth;
670 }
671 if (wheight > sheight)
672 {
673 SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_HEIGHT, sheight, TRUE);
674 wheight = sheight;
675 }
676 }
677
678 ConInfo->ScreenBufferSize.X = (SHORT)swidth;
679 ConInfo->ScreenBufferSize.Y = (SHORT)sheight;
680 ConInfo->WindowSize.X = (SHORT)wwidth;
681 ConInfo->WindowSize.Y = (SHORT)wheight;
682 ConInfo->WindowPosition.x = left;
683 ConInfo->WindowPosition.y = top;
684
685 InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
686 PropSheet_Changed(GetParent(hDlg), hDlg);
687 }
688 break;
689 }
690
691 case WM_COMMAND:
692 {
693 if (HIWORD(wParam) == EN_KILLFOCUS)
694 {
695 switch (LOWORD(wParam))
696 {
697 case IDC_EDIT_SCREEN_BUFFER_WIDTH:
698 {
699 DWORD swidth, wwidth;
700
701 swidth = GetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_WIDTH, NULL, FALSE);
702 wwidth = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_WIDTH , NULL, FALSE);
703
704 /* Be sure that the (new) screen buffer width is in the correct range */
705 swidth = min(max(swidth, 1), 0xFFFF);
706
707 /* Automatically adjust window size when screen buffer decreases */
708 if (wwidth > swidth)
709 {
710 wwidth = swidth;
711 SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_WIDTH, wwidth, TRUE);
712 }
713
714 ConInfo->ScreenBufferSize.X = (SHORT)swidth;
715 ConInfo->WindowSize.X = (SHORT)wwidth;
716
717 InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
718 PropSheet_Changed(GetParent(hDlg), hDlg);
719 break;
720 }
721
722 case IDC_EDIT_WINDOW_SIZE_WIDTH:
723 {
724 DWORD swidth, wwidth;
725
726 swidth = GetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_WIDTH, NULL, FALSE);
727 wwidth = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_WIDTH , NULL, FALSE);
728
729 /* Automatically adjust screen buffer size when window size enlarges */
730 if (wwidth >= swidth)
731 {
732 swidth = wwidth;
733
734 /* Be sure that the (new) screen buffer width is in the correct range */
735 swidth = min(max(swidth, 1), 0xFFFF);
736
737 SetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_WIDTH, swidth, TRUE);
738 }
739
740 ConInfo->ScreenBufferSize.X = (SHORT)swidth;
741 ConInfo->WindowSize.X = (SHORT)wwidth;
742
743 InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
744 PropSheet_Changed(GetParent(hDlg), hDlg);
745 break;
746 }
747
748 case IDC_EDIT_SCREEN_BUFFER_HEIGHT:
749 {
750 DWORD sheight, wheight;
751
752 sheight = GetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_HEIGHT, NULL, FALSE);
753 wheight = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_HEIGHT , NULL, FALSE);
754
755 /* Be sure that the (new) screen buffer width is in the correct range */
756 sheight = min(max(sheight, 1), 0xFFFF);
757
758 /* Automatically adjust window size when screen buffer decreases */
759 if (wheight > sheight)
760 {
761 wheight = sheight;
762 SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_HEIGHT, wheight, TRUE);
763 }
764
765 ConInfo->ScreenBufferSize.Y = (SHORT)sheight;
766 ConInfo->WindowSize.Y = (SHORT)wheight;
767
768 InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
769 PropSheet_Changed(GetParent(hDlg), hDlg);
770 break;
771 }
772
773 case IDC_EDIT_WINDOW_SIZE_HEIGHT:
774 {
775 DWORD sheight, wheight;
776
777 sheight = GetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_HEIGHT, NULL, FALSE);
778 wheight = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_HEIGHT , NULL, FALSE);
779
780 /* Automatically adjust screen buffer size when window size enlarges */
781 if (wheight >= sheight)
782 {
783 sheight = wheight;
784
785 /* Be sure that the (new) screen buffer width is in the correct range */
786 sheight = min(max(sheight, 1), 0xFFFF);
787
788 SetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_HEIGHT, sheight, TRUE);
789 }
790
791 ConInfo->ScreenBufferSize.Y = (SHORT)sheight;
792 ConInfo->WindowSize.Y = (SHORT)wheight;
793
794 InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
795 PropSheet_Changed(GetParent(hDlg), hDlg);
796 break;
797 }
798
799 case IDC_EDIT_WINDOW_POS_LEFT:
800 case IDC_EDIT_WINDOW_POS_TOP:
801 {
802 ConInfo->WindowPosition.x = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_LEFT, NULL, TRUE);
803 ConInfo->WindowPosition.y = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_TOP , NULL, TRUE);
804
805 InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
806 PropSheet_Changed(GetParent(hDlg), hDlg);
807 break;
808 }
809 }
810 }
811 else
812 if (HIWORD(wParam) == BN_CLICKED &&
813 LOWORD(wParam) == IDC_CHECK_SYSTEM_POS_WINDOW)
814 {
815 if (IsDlgButtonChecked(hDlg, IDC_CHECK_SYSTEM_POS_WINDOW) == BST_CHECKED)
816 {
817 EnableDlgItem(hDlg, IDC_EDIT_WINDOW_POS_LEFT, FALSE);
818 EnableDlgItem(hDlg, IDC_EDIT_WINDOW_POS_TOP , FALSE);
819 EnableDlgItem(hDlg, IDC_UPDOWN_WINDOW_POS_LEFT, FALSE);
820 EnableDlgItem(hDlg, IDC_UPDOWN_WINDOW_POS_TOP , FALSE);
821
822 ConInfo->AutoPosition = TRUE;
823 // Do not touch ConInfo->WindowPosition !!
824
825 InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
826 PropSheet_Changed(GetParent(hDlg), hDlg);
827 }
828 else
829 {
830 ULONG left, top;
831
832 left = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_LEFT, NULL, TRUE);
833 top = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_TOP , NULL, TRUE);
834
835 EnableDlgItem(hDlg, IDC_EDIT_WINDOW_POS_LEFT, TRUE);
836 EnableDlgItem(hDlg, IDC_EDIT_WINDOW_POS_TOP , TRUE);
837 EnableDlgItem(hDlg, IDC_UPDOWN_WINDOW_POS_LEFT, TRUE);
838 EnableDlgItem(hDlg, IDC_UPDOWN_WINDOW_POS_TOP , TRUE);
839
840 ConInfo->AutoPosition = FALSE;
841 ConInfo->WindowPosition.x = left;
842 ConInfo->WindowPosition.y = top;
843
844 InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
845 PropSheet_Changed(GetParent(hDlg), hDlg);
846 }
847 }
848
849 break;
850 }
851
852 default:
853 break;
854 }
855
856 return FALSE;
857 }