git.oblomov.eu Git - wine/blob - programs/wineconsole/dialog.c

   1 /* dialog management for wineconsole
   2  * USER32 backend
   3  * Copyright (c) 2001, 2002 Eric Pouech
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <stdarg.h>
  23
  24 #define NONAMELESSUNION
  25 #define NONAMELESSSTRUCT
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "winuser.h"
  30 #include "winnls.h"
  31 #include "commctrl.h"
  32 #include "prsht.h"
  33 #include "winecon_user.h"
  34
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(wineconsole);
  38
  39 struct dialog_info
  40 {
  41     struct config_data  config;         /* configuration used for dialog box */
  42     struct inner_data*  data;           /* pointer to current winecon info */
  43     HWND                hDlg;           /* handle to active propsheet */
  44     int                 nFont;          /* number of font size in size LB */
  45     struct font_info
  46     {
  47         UINT                    height;
  48         UINT                    weight;
  49         WCHAR                   faceName[LF_FACESIZE];
  50     }                   *font;          /* array of nFont. index sync'ed with SIZE LB */
  51 };
  52
  53 /******************************************************************
  54  *              WCUSER_OptionDlgProc
  55  *
  56  * Dialog prop for the option property sheet
  57  */
  58 static INT_PTR WINAPI WCUSER_OptionDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
  59 {
  60     struct dialog_info*         di;
  61     unsigned                    idc;
  62
  63     switch (msg)
  64     {
  65     case WM_INITDIALOG:
  66         di = (struct dialog_info*)((PROPSHEETPAGEA*)lParam)->lParam;
  67         di->hDlg = hDlg;
  68         SetWindowLongPtrW(hDlg, DWLP_USER, (LONG_PTR)di);
  69
  70         SendMessageW(GetDlgItem(hDlg,IDC_OPT_HIST_SIZE_UD), UDM_SETRANGE, 0, MAKELPARAM(500, 0));
  71
  72         if (di->config.cursor_size <= 25)       idc = IDC_OPT_CURSOR_SMALL;
  73         else if (di->config.cursor_size <= 50)  idc = IDC_OPT_CURSOR_MEDIUM;
  74         else                                    idc = IDC_OPT_CURSOR_LARGE;
  75         SendDlgItemMessageW(hDlg, idc, BM_SETCHECK, BST_CHECKED, 0);
  76         SetDlgItemInt(hDlg, IDC_OPT_HIST_SIZE, di->config.history_size,  FALSE);
  77         SendDlgItemMessageW(hDlg, IDC_OPT_HIST_NODOUBLE, BM_SETCHECK,
  78                             (di->config.history_nodup) ? BST_CHECKED : BST_UNCHECKED, 0);
  79         SendDlgItemMessageW(hDlg, IDC_OPT_CONF_CTRL, BM_SETCHECK,
  80                             (di->config.menu_mask & MK_CONTROL) ? BST_CHECKED : BST_UNCHECKED, 0);
  81         SendDlgItemMessageW(hDlg, IDC_OPT_CONF_SHIFT, BM_SETCHECK,
  82                             (di->config.menu_mask & MK_SHIFT) ? BST_CHECKED : BST_UNCHECKED, 0);
  83         SendDlgItemMessageW(hDlg, IDC_OPT_QUICK_EDIT, BM_SETCHECK,
  84                             (di->config.quick_edit) ? BST_CHECKED : BST_UNCHECKED, 0);
  85         return FALSE; /* because we set the focus */
  86     case WM_COMMAND:
  87         break;
  88     case WM_NOTIFY:
  89     {
  90         NMHDR*  nmhdr = (NMHDR*)lParam;
  91         DWORD   val;
  92         BOOL    done;
  93
  94         di = (struct dialog_info*)GetWindowLongPtrW(hDlg, DWLP_USER);
  95
  96         switch (nmhdr->code)
  97         {
  98         case PSN_SETACTIVE:
  99             /* needed in propsheet to keep properly the selected radio button
 100              * otherwise, the focus would be set to the first tab stop in the
 101              * propsheet, which would always activate the first radio button
 102              */
 103             if (IsDlgButtonChecked(hDlg, IDC_OPT_CURSOR_SMALL) == BST_CHECKED)
 104                 idc = IDC_OPT_CURSOR_SMALL;
 105             else if (IsDlgButtonChecked(hDlg, IDC_OPT_CURSOR_MEDIUM) == BST_CHECKED)
 106                 idc = IDC_OPT_CURSOR_MEDIUM;
 107             else
 108                 idc = IDC_OPT_CURSOR_LARGE;
 109             PostMessageW(hDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hDlg, idc), TRUE);
 110             di->hDlg = hDlg;
 111             break;
 112         case PSN_APPLY:
 113             if (IsDlgButtonChecked(hDlg, IDC_OPT_CURSOR_SMALL) == BST_CHECKED) val = 25;
 114             else if (IsDlgButtonChecked(hDlg, IDC_OPT_CURSOR_MEDIUM) == BST_CHECKED) val = 50;
 115             else val = 100;
 116             di->config.cursor_size = val;
 117
 118             val = GetDlgItemInt(hDlg, IDC_OPT_HIST_SIZE, &done, FALSE);
 119             if (done) di->config.history_size = val;
 120
 121             val = (IsDlgButtonChecked(hDlg, IDC_OPT_HIST_NODOUBLE) & BST_CHECKED) ? TRUE : FALSE;
 122             di->config.history_nodup = val;
 123
 124             val = 0;
 125             if (IsDlgButtonChecked(hDlg, IDC_OPT_CONF_CTRL) & BST_CHECKED)  val |= MK_CONTROL;
 126             if (IsDlgButtonChecked(hDlg, IDC_OPT_CONF_SHIFT) & BST_CHECKED) val |= MK_SHIFT;
 127             di->config.menu_mask = val;
 128
 129             val = (IsDlgButtonChecked(hDlg, IDC_OPT_QUICK_EDIT) & BST_CHECKED) ? TRUE : FALSE;
 130             di->config.quick_edit = val;
 131
 132             SetWindowLongPtrW(hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
 133             return TRUE;
 134         default:
 135             return FALSE;
 136         }
 137         break;
 138     }
 139     default:
 140         return FALSE;
 141     }
 142     return TRUE;
 143 }
 144
 145 /******************************************************************
 146  *              WCUSER_FontPreviewProc
 147  *
 148  * Window proc for font previewer in font property sheet
 149  */
 150 static LRESULT WINAPI WCUSER_FontPreviewProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 151 {
 152     switch (msg)
 153     {
 154     case WM_CREATE:
 155         SetWindowLongPtrW(hWnd, 0, 0);
 156         break;
 157     case WM_GETFONT:
 158         return GetWindowLongPtrW(hWnd, 0);
 159     case WM_SETFONT:
 160         SetWindowLongPtrW(hWnd, 0, wParam);
 161         if (LOWORD(lParam))
 162         {
 163             InvalidateRect(hWnd, NULL, TRUE);
 164             UpdateWindow(hWnd);
 165         }
 166         break;
 167     case WM_DESTROY:
 168         {
 169             HFONT hFont = (HFONT)GetWindowLongPtrW(hWnd, 0);
 170             if (hFont) DeleteObject(hFont);
 171         }
 172         break;
 173     case WM_PAINT:
 174         {
 175             PAINTSTRUCT         ps;
 176             int                 size_idx;
 177             struct dialog_info* di;
 178             HFONT               hFont, hOldFont;
 179
 180             di = (struct dialog_info*)GetWindowLongPtrW(GetParent(hWnd), DWLP_USER);
 181             BeginPaint(hWnd, &ps);
 182
 183             size_idx = SendDlgItemMessageW(di->hDlg, IDC_FNT_LIST_SIZE, LB_GETCURSEL, 0, 0);
 184
 185             hFont = (HFONT)GetWindowLongPtrW(hWnd, 0);
 186             if (hFont)
 187             {
 188                 WCHAR ascii[] = {'A','S','C','I','I',':',' ','a','b','c','X','Y','Z','\0'};
 189                 WCHAR buf[256];
 190                 int   len;
 191
 192                 hOldFont = SelectObject(ps.hdc, hFont);
 193                 SetBkColor(ps.hdc, WCUSER_ColorMap[GetWindowLongW(GetDlgItem(di->hDlg, IDC_FNT_COLOR_BK), 0)]);
 194                 SetTextColor(ps.hdc, WCUSER_ColorMap[GetWindowLongW(GetDlgItem(di->hDlg, IDC_FNT_COLOR_FG), 0)]);
 195                 len = LoadStringW(GetModuleHandleW(NULL), IDS_FNT_PREVIEW,
 196                                   buf, sizeof(buf) / sizeof(buf[0]));
 197                 if (len)
 198                     TextOutW(ps.hdc, 0, 0, buf, len);
 199                 TextOutW(ps.hdc, 0, di->font[size_idx].height, ascii,
 200                          sizeof(ascii)/sizeof(ascii[0]) - 1);
 201                 SelectObject(ps.hdc, hOldFont);
 202             }
 203             EndPaint(hWnd, &ps);
 204         }
 205         break;
 206     default:
 207         return DefWindowProcW(hWnd, msg, wParam, lParam);
 208     }
 209     return 0L;
 210 }
 211
 212 /******************************************************************
 213  *              WCUSER_ColorPreviewProc
 214  *
 215  * Window proc for color previewer in font property sheet
 216  */
 217 static LRESULT WINAPI WCUSER_ColorPreviewProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 218 {
 219     switch (msg)
 220     {
 221     case WM_PAINT:
 222         {
 223             PAINTSTRUCT     ps;
 224             int             i, step;
 225             RECT            client, r;
 226             HBRUSH          hbr;
 227
 228             BeginPaint(hWnd, &ps);
 229             GetClientRect(hWnd, &client);
 230             step = client.right / 8;
 231
 232             for (i = 0; i < 16; i++)
 233             {
 234                 r.top = (i / 8) * (client.bottom / 2);
 235                 r.bottom = r.top + client.bottom / 2;
 236                 r.left = (i & 7) * step;
 237                 r.right = r.left + step;
 238                 hbr = CreateSolidBrush(WCUSER_ColorMap[i]);
 239                 FillRect(ps.hdc, &r, hbr);
 240                 DeleteObject(hbr);
 241                 if (GetWindowLongW(hWnd, 0) == i)
 242                 {
 243                     HPEN        hOldPen;
 244                     int         i = 2;
 245
 246                     hOldPen = SelectObject(ps.hdc, GetStockObject(WHITE_PEN));
 247                     r.right--; r.bottom--;
 248                     for (;;)
 249                     {
 250                         MoveToEx(ps.hdc, r.left, r.bottom, NULL);
 251                         LineTo(ps.hdc, r.left, r.top);
 252                         LineTo(ps.hdc, r.right, r.top);
 253                         SelectObject(ps.hdc, GetStockObject(BLACK_PEN));
 254                         LineTo(ps.hdc, r.right, r.bottom);
 255                         LineTo(ps.hdc, r.left, r.bottom);
 256
 257                         if (--i == 0) break;
 258                         r.left++; r.top++; r.right--; r.bottom--;
 259                         SelectObject(ps.hdc, GetStockObject(WHITE_PEN));
 260                     }
 261                     SelectObject(ps.hdc, hOldPen);
 262                 }
 263             }
 264             EndPaint(hWnd, &ps);
 265             break;
 266         }
 267     case WM_LBUTTONDOWN:
 268         {
 269             int             i, step;
 270             RECT            client;
 271
 272             GetClientRect(hWnd, &client);
 273             step = client.right / 8;
 274             i = (HIWORD(lParam) >= client.bottom / 2) ? 8 : 0;
 275             i += LOWORD(lParam) / step;
 276             SetWindowLongW(hWnd, 0, i);
 277             InvalidateRect(GetDlgItem(GetParent(hWnd), IDC_FNT_PREVIEW), NULL, FALSE);
 278             InvalidateRect(hWnd, NULL, FALSE);
 279         }
 280         break;
 281     default:
 282         return DefWindowProcW(hWnd, msg, wParam, lParam);
 283     }
 284     return 0L;
 285 }
 286
 287 /******************************************************************
 288  *              font_enum
 289  *
 290  * enumerates all the font names with at least one valid font
 291  */
 292 static int CALLBACK font_enum_size2(const LOGFONTW* lf, const TEXTMETRICW* tm,
 293                                     DWORD FontType, LPARAM lParam)
 294 {
 295     struct dialog_info* di = (struct dialog_info*)lParam;
 296
 297     WCUSER_DumpTextMetric(tm, FontType);
 298     if (WCUSER_ValidateFontMetric(di->data, tm, FontType))
 299     {
 300         di->nFont++;
 301     }
 302
 303     return 1;
 304 }
 305
 306 static int CALLBACK font_enum(const LOGFONTW* lf, const TEXTMETRICW* tm,
 307                               DWORD FontType, LPARAM lParam)
 308 {
 309     struct dialog_info* di = (struct dialog_info*)lParam;
 310
 311     WCUSER_DumpLogFont("DlgFamily: ", lf, FontType);
 312     if (WCUSER_ValidateFont(di->data, lf))
 313     {
 314         if (FontType & RASTER_FONTTYPE)
 315         {
 316             di->nFont = 0;
 317             EnumFontFamiliesW(PRIVATE(di->data)->hMemDC, lf->lfFaceName, font_enum_size2, (LPARAM)di);
 318         }
 319         else
 320             di->nFont = 1;
 321
 322         if (di->nFont)
 323         {
 324             SendDlgItemMessageW(di->hDlg, IDC_FNT_LIST_FONT, LB_ADDSTRING,
 325                                 0, (LPARAM)lf->lfFaceName);
 326         }
 327     }
 328
 329     return 1;
 330 }
 331
 332 /******************************************************************
 333  *              font_enum_size
 334  *
 335  *
 336  */
 337 static int CALLBACK font_enum_size(const LOGFONTW* lf, const TEXTMETRICW* tm,
 338                                    DWORD FontType, LPARAM lParam)
 339 {
 340     struct dialog_info* di = (struct dialog_info*)lParam;
 341     WCHAR               buf[32];
 342     static const WCHAR  fmt[] = {'%','l','d',0};
 343
 344     WCUSER_DumpTextMetric(tm, FontType);
 345     if (di->nFont == 0 && !(FontType & RASTER_FONTTYPE))
 346     {
 347         static const int sizes[] = {8,9,10,11,12,14,16,18,20,22,24,26,28,36,48,72};
 348         int i;
 349
 350         di->nFont = sizeof(sizes) / sizeof(sizes[0]);
 351         di->font = HeapAlloc(GetProcessHeap(), 0, di->nFont * sizeof(di->font[0]));
 352         for (i = 0; i < di->nFont; i++)
 353         {
 354             /* drop sizes where window size wouldn't fit on screen */
 355             if (sizes[i] * di->data->curcfg.win_height > GetSystemMetrics(SM_CYSCREEN))
 356             {
 357                 di->nFont = i;
 358                 break;
 359             }
 360             di->font[i].height = sizes[i];
 361             di->font[i].weight = 400;
 362             lstrcpyW(di->font[i].faceName, lf->lfFaceName);
 363             wsprintfW(buf, fmt, sizes[i]);
 364             SendDlgItemMessageW(di->hDlg, IDC_FNT_LIST_SIZE, LB_INSERTSTRING, i, (LPARAM)buf);
 365         }
 366         /* don't need to enumerate other */
 367         return 0;
 368     }
 369
 370     if (WCUSER_ValidateFontMetric(di->data, tm, FontType))
 371     {
 372         int     idx;
 373
 374         /* we want the string to be sorted with a numeric order, not a lexicographic...
 375          * do the job by hand... get where to insert the new string
 376          */
 377         for (idx = 0; idx < di->nFont && tm->tmHeight > di->font[idx].height; idx++);
 378         while (idx < di->nFont &&
 379                tm->tmHeight == di->font[idx].height &&
 380                tm->tmWeight > di->font[idx].weight)
 381             idx++;
 382         if (idx == di->nFont ||
 383             tm->tmHeight != di->font[idx].height ||
 384             tm->tmWeight < di->font[idx].weight)
 385         {
 386             /* here we need to add the new entry */
 387             wsprintfW(buf, fmt, tm->tmHeight);
 388             SendDlgItemMessageW(di->hDlg, IDC_FNT_LIST_SIZE, LB_INSERTSTRING, idx, (LPARAM)buf);
 389
 390             /* now grow our arrays and insert the values at the same index than in the list box */
 391             if (di->nFont)
 392             {
 393                 di->font = HeapReAlloc(GetProcessHeap(), 0, di->font, sizeof(*di->font) * (di->nFont + 1));
 394                 if (idx != di->nFont)
 395                     memmove(&di->font[idx + 1], &di->font[idx], (di->nFont - idx) * sizeof(*di->font));
 396             }
 397             else
 398                 di->font = HeapAlloc(GetProcessHeap(), 0, sizeof(*di->font));
 399             di->font[idx].height = tm->tmHeight;
 400             di->font[idx].weight = tm->tmWeight;
 401             lstrcpyW(di->font[idx].faceName, lf->lfFaceName);
 402             di->nFont++;
 403         }
 404     }
 405     return 1;
 406 }
 407
 408 /******************************************************************
 409  *              select_font
 410  *
 411  *
 412  */
 413 static BOOL  select_font(struct dialog_info* di)
 414 {
 415     int         font_idx, size_idx;
 416     WCHAR       buf[256];
 417     WCHAR       fmt[128];
 418     LOGFONTW    lf;
 419     HFONT       hFont, hOldFont;
 420     struct config_data config;
 421
 422     font_idx = SendDlgItemMessageW(di->hDlg, IDC_FNT_LIST_FONT, LB_GETCURSEL, 0, 0);
 423     size_idx = SendDlgItemMessageW(di->hDlg, IDC_FNT_LIST_SIZE, LB_GETCURSEL, 0, 0);
 424
 425     if (font_idx < 0 || size_idx < 0 || size_idx >= di->nFont)
 426         return FALSE;
 427
 428     WCUSER_FillLogFont(&lf, di->font[size_idx].faceName,
 429                        di->font[size_idx].height, di->font[size_idx].weight);
 430     hFont = WCUSER_CopyFont(&config, di->data->hWnd, &lf, NULL);
 431     if (!hFont) return FALSE;
 432
 433     if (config.cell_height != di->font[size_idx].height)
 434         WINE_TRACE("mismatched heights (%u<>%u)\n",
 435                    config.cell_height, di->font[size_idx].height);
 436     hOldFont = (HFONT)SendDlgItemMessageW(di->hDlg, IDC_FNT_PREVIEW, WM_GETFONT, 0, 0);
 437
 438     SendDlgItemMessageW(di->hDlg, IDC_FNT_PREVIEW, WM_SETFONT, (WPARAM)hFont, TRUE);
 439     if (hOldFont) DeleteObject(hOldFont);
 440
 441     LoadStringW(GetModuleHandleW(NULL), IDS_FNT_DISPLAY, fmt, sizeof(fmt) / sizeof(fmt[0]));
 442     wsprintfW(buf, fmt, config.cell_width, config.cell_height);
 443
 444     SendDlgItemMessageW(di->hDlg, IDC_FNT_FONT_INFO, WM_SETTEXT, 0, (LPARAM)buf);
 445
 446     return TRUE;
 447 }
 448
 449 /******************************************************************
 450  *              fill_list_size
 451  *
 452  * fills the size list box according to selected family in font LB
 453  */
 454 static BOOL  fill_list_size(struct dialog_info* di, BOOL doInit)
 455 {
 456     int         idx;
 457     WCHAR       lfFaceName[LF_FACESIZE];
 458
 459     idx = SendDlgItemMessageW(di->hDlg, IDC_FNT_LIST_FONT, LB_GETCURSEL, 0, 0);
 460     if (idx < 0) return FALSE;
 461
 462     SendDlgItemMessageW(di->hDlg, IDC_FNT_LIST_FONT, LB_GETTEXT, idx, (LPARAM)lfFaceName);
 463     SendDlgItemMessageW(di->hDlg, IDC_FNT_LIST_SIZE, LB_RESETCONTENT, 0, 0);
 464     HeapFree(GetProcessHeap(), 0, di->font);
 465     di->nFont = 0;
 466     di->font = NULL;
 467
 468     EnumFontFamiliesW(PRIVATE(di->data)->hMemDC, lfFaceName, font_enum_size, (LPARAM)di);
 469
 470     if (doInit)
 471     {
 472         int     ref = -1;
 473
 474         for (idx = 0; idx < di->nFont; idx++)
 475         {
 476             if (!lstrcmpW(di->font[idx].faceName, di->config.face_name) &&
 477                 di->font[idx].height == di->config.cell_height &&
 478                 di->font[idx].weight == di->config.font_weight)
 479             {
 480                 if (ref == -1) ref = idx;
 481                 else WINE_TRACE("Several matches found: ref=%d idx=%d\n", ref, idx);
 482             }
 483         }
 484         idx = (ref == -1) ? 0 : ref;
 485     }
 486     else
 487         idx = 0;
 488     SendDlgItemMessageW(di->hDlg, IDC_FNT_LIST_SIZE, LB_SETCURSEL, idx, 0);
 489     select_font(di);
 490     return TRUE;
 491 }
 492
 493 /******************************************************************
 494  *              fill_list_font
 495  *
 496  * Fills the font LB
 497  */
 498 static BOOL fill_list_font(struct dialog_info* di)
 499 {
 500     SendDlgItemMessageW(di->hDlg, IDC_FNT_LIST_FONT, LB_RESETCONTENT, 0, 0);
 501     EnumFontFamiliesW(PRIVATE(di->data)->hMemDC, NULL, font_enum, (LPARAM)di);
 502     if (SendDlgItemMessageW(di->hDlg, IDC_FNT_LIST_FONT, LB_SELECTSTRING,
 503                             -1, (LPARAM)di->config.face_name) == LB_ERR)
 504         SendDlgItemMessageW(di->hDlg, IDC_FNT_LIST_FONT, LB_SETCURSEL, 0, 0);
 505     fill_list_size(di, TRUE);
 506     return TRUE;
 507 }
 508
 509 /******************************************************************
 510  *              WCUSER_FontDlgProc
 511  *
 512  * Dialog proc for the Font property sheet
 513  */
 514 static INT_PTR WINAPI WCUSER_FontDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
 515 {
 516     struct dialog_info*         di;
 517
 518     switch (msg)
 519     {
 520     case WM_INITDIALOG:
 521         di = (struct dialog_info*)((PROPSHEETPAGEA*)lParam)->lParam;
 522         di->hDlg = hDlg;
 523         SetWindowLongPtrW(hDlg, DWLP_USER, (DWORD_PTR)di);
 524         /* remove dialog from this control, font will be reset when listboxes are filled */
 525         SendDlgItemMessageW(hDlg, IDC_FNT_PREVIEW, WM_SETFONT, 0, 0);
 526         fill_list_font(di);
 527         SetWindowLongW(GetDlgItem(hDlg, IDC_FNT_COLOR_BK), 0, (di->config.def_attr >> 4) & 0x0F);
 528         SetWindowLongW(GetDlgItem(hDlg, IDC_FNT_COLOR_FG), 0, di->config.def_attr & 0x0F);
 529         break;
 530     case WM_COMMAND:
 531         di = (struct dialog_info*)GetWindowLongPtrW(hDlg, DWLP_USER);
 532         switch (LOWORD(wParam))
 533         {
 534         case IDC_FNT_LIST_FONT:
 535             if (HIWORD(wParam) == LBN_SELCHANGE)
 536             {
 537                 fill_list_size(di, FALSE);
 538             }
 539             break;
 540         case IDC_FNT_LIST_SIZE:
 541             if (HIWORD(wParam) == LBN_SELCHANGE)
 542             {
 543                 select_font(di);
 544             }
 545             break;
 546         }
 547         break;
 548     case WM_NOTIFY:
 549     {
 550         NMHDR*  nmhdr = (NMHDR*)lParam;
 551         DWORD   val;
 552
 553         di = (struct dialog_info*)GetWindowLongPtrW(hDlg, DWLP_USER);
 554         switch (nmhdr->code)
 555         {
 556         case PSN_SETACTIVE:
 557             di->hDlg = hDlg;
 558             break;
 559         case PSN_APPLY:
 560             val = SendDlgItemMessageW(hDlg, IDC_FNT_LIST_SIZE, LB_GETCURSEL, 0, 0);
 561
 562             if (val < di->nFont)
 563             {
 564                 LOGFONTW lf;
 565
 566                 WCUSER_FillLogFont(&lf, di->font[val].faceName,
 567                                    di->font[val].height, di->font[val].weight);
 568                 DeleteObject(WCUSER_CopyFont(&di->config,
 569                                              di->data->hWnd, &lf, NULL));
 570             }
 571
 572             val = (GetWindowLongW(GetDlgItem(hDlg, IDC_FNT_COLOR_BK), 0) << 4) |
 573                    GetWindowLongW(GetDlgItem(hDlg, IDC_FNT_COLOR_FG), 0);
 574             di->config.def_attr = val;
 575
 576             SetWindowLongPtrW(hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
 577             return TRUE;
 578         default:
 579             return FALSE;
 580         }
 581         break;
 582     }
 583     default:
 584         return FALSE;
 585     }
 586     return TRUE;
 587 }
 588
 589 /******************************************************************
 590  *              WCUSER_ConfigDlgProc
 591  *
 592  * Dialog proc for the config property sheet
 593  */
 594 static INT_PTR WINAPI WCUSER_ConfigDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
 595 {
 596     struct dialog_info*         di;
 597     int                     nMaxUD = 2000;
 598
 599     switch (msg)
 600     {
 601     case WM_INITDIALOG:
 602         di = (struct dialog_info*)((PROPSHEETPAGEA*)lParam)->lParam;
 603         di->hDlg = hDlg;
 604
 605         SetWindowLongPtrW(hDlg, DWLP_USER, (DWORD_PTR)di);
 606         SetDlgItemInt(hDlg, IDC_CNF_SB_WIDTH,   di->config.sb_width,   FALSE);
 607         SetDlgItemInt(hDlg, IDC_CNF_SB_HEIGHT,  di->config.sb_height,  FALSE);
 608         SetDlgItemInt(hDlg, IDC_CNF_WIN_WIDTH,  di->config.win_width,  FALSE);
 609         SetDlgItemInt(hDlg, IDC_CNF_WIN_HEIGHT, di->config.win_height, FALSE);
 610
 611         SendMessageW(GetDlgItem(hDlg,IDC_CNF_WIN_HEIGHT_UD), UDM_SETRANGE, 0, MAKELPARAM(nMaxUD, 0));
 612         SendMessageW(GetDlgItem(hDlg,IDC_CNF_WIN_WIDTH_UD), UDM_SETRANGE, 0, MAKELPARAM(nMaxUD, 0));
 613         SendMessageW(GetDlgItem(hDlg,IDC_CNF_SB_HEIGHT_UD), UDM_SETRANGE, 0, MAKELPARAM(nMaxUD, 0));
 614         SendMessageW(GetDlgItem(hDlg,IDC_CNF_SB_WIDTH_UD), UDM_SETRANGE, 0, MAKELPARAM(nMaxUD, 0));
 615
 616         SendDlgItemMessageW(hDlg, IDC_CNF_CLOSE_EXIT, BM_SETCHECK,
 617                             (di->config.exit_on_die) ? BST_CHECKED : BST_UNCHECKED, 0);
 618         {
 619             static const WCHAR s1[] = {'W','i','n','3','2',0};
 620             static const WCHAR s2[] = {'E','m','a','c','s',0};
 621
 622             SendDlgItemMessageW(hDlg, IDC_CNF_EDITION_MODE, CB_ADDSTRING, 0, (LPARAM)s1);
 623             SendDlgItemMessageW(hDlg, IDC_CNF_EDITION_MODE, CB_ADDSTRING, 0, (LPARAM)s2);
 624             SendDlgItemMessageW(hDlg, IDC_CNF_EDITION_MODE, CB_SETCURSEL, di->config.edition_mode, 0);
 625         }
 626
 627         break;
 628     case WM_COMMAND:
 629         di = (struct dialog_info*)GetWindowLongPtrW(hDlg, DWLP_USER);
 630         switch (LOWORD(wParam))
 631         {
 632         }
 633         break;
 634     case WM_NOTIFY:
 635     {
 636         NMHDR*          nmhdr = (NMHDR*)lParam;
 637         int             win_w, win_h, sb_w, sb_h;
 638         BOOL            st1, st2;
 639
 640         di = (struct dialog_info*)GetWindowLongPtrW(hDlg, DWLP_USER);
 641         switch (nmhdr->code)
 642         {
 643         case PSN_SETACTIVE:
 644             di->hDlg = hDlg;
 645             break;
 646         case PSN_APPLY:
 647             sb_w = GetDlgItemInt(hDlg, IDC_CNF_SB_WIDTH,  &st1, FALSE);
 648             sb_h = GetDlgItemInt(hDlg, IDC_CNF_SB_HEIGHT, &st2, FALSE);
 649             if (!st1 || ! st2)
 650             {
 651                 SetWindowLongPtrW(hDlg, DWLP_MSGRESULT, PSNRET_INVALID);
 652                 return TRUE;
 653             }
 654             win_w = GetDlgItemInt(hDlg, IDC_CNF_WIN_WIDTH,  &st1, FALSE);
 655             win_h = GetDlgItemInt(hDlg, IDC_CNF_WIN_HEIGHT, &st2, FALSE);
 656             if (!st1 || !st2)
 657             {
 658                 SetWindowLongPtrW(hDlg, DWLP_MSGRESULT, PSNRET_INVALID);
 659                 return TRUE;
 660             }
 661             if (win_w > sb_w || win_h > sb_h)
 662             {
 663                 WCHAR   cap[256];
 664                 WCHAR   txt[256];
 665
 666                 LoadStringW(GetModuleHandleW(NULL), IDS_DLG_TIT_ERROR,
 667                             cap, sizeof(cap) / sizeof(cap[0]));
 668                 LoadStringW(GetModuleHandleW(NULL), IDS_DLG_ERR_SBWINSIZE,
 669                             txt, sizeof(txt) / sizeof(cap[0]));
 670
 671                 MessageBoxW(hDlg, txt, cap, MB_OK);
 672                 SetWindowLongPtrW(hDlg, DWLP_MSGRESULT, PSNRET_INVALID);
 673                 return TRUE;
 674             }
 675             di->config.win_width  = win_w;
 676             di->config.win_height = win_h;
 677             di->config.sb_width  = sb_w;
 678             di->config.sb_height = sb_h;
 679
 680             di->config.exit_on_die = IsDlgButtonChecked(hDlg, IDC_CNF_CLOSE_EXIT) ? 1 : 0;
 681             di->config.edition_mode = SendDlgItemMessageW(hDlg, IDC_CNF_EDITION_MODE,
 682                                                           CB_GETCURSEL, 0, 0);
 683             SetWindowLongPtrW(hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
 684             return TRUE;
 685         default:
 686             return FALSE;
 687         }
 688         break;
 689     }
 690     default:
 691         return FALSE;
 692     }
 693     return TRUE;
 694 }
 695
 696 /******************************************************************
 697  *              WCUSER_SaveDlgProc
 698  *
 699  *      Dialog Procedure for choosing how to handle modification to the
 700  * console settings.
 701  */
 702 static INT_PTR WINAPI WCUSER_SaveDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
 703 {
 704     switch (msg)
 705     {
 706     case WM_INITDIALOG:
 707         SendDlgItemMessageW(hDlg, IDC_SAV_SESSION, BM_SETCHECK, BST_CHECKED, 0);
 708         break;
 709     case WM_COMMAND:
 710         switch (LOWORD(wParam))
 711         {
 712         case IDOK:
 713             EndDialog(hDlg,
 714                       (IsDlgButtonChecked(hDlg, IDC_SAV_SAVE) == BST_CHECKED) ?
 715                       IDC_SAV_SAVE : IDC_SAV_SESSION);
 716             break;
 717         case IDCANCEL:
 718             EndDialog(hDlg, IDCANCEL); break;
 719         }
 720         break;
 721     default:
 722         return FALSE;
 723     }
 724     return TRUE;
 725 }
 726
 727 /******************************************************************
 728  *              WCUSER_GetProperties
 729  *
 730  * Runs the dialog box to set up the wineconsole options
 731  */
 732 BOOL WCUSER_GetProperties(struct inner_data* data, BOOL current)
 733 {
 734     HPROPSHEETPAGE   psPage[3];
 735     PROPSHEETPAGEW   psp;
 736     PROPSHEETHEADERW psHead;
 737     WCHAR            buff[256];
 738     WNDCLASSW        wndclass;
 739     static const WCHAR szFntPreview[] = {'W','i','n','e','C','o','n','F','o','n','t','P','r','e','v','i','e','w',0};
 740     static const WCHAR szColorPreview[] = {'W','i','n','e','C','o','n','C','o','l','o','r','P','r','e','v','i','e','w',0};
 741     struct dialog_info  di;
 742     struct config_data  defcfg;
 743     struct config_data* refcfg;
 744     BOOL                save, modify_session;
 745
 746     InitCommonControls();
 747
 748     di.data = data;
 749     if (current)
 750     {
 751         refcfg = &data->curcfg;
 752         save = FALSE;
 753     }
 754     else
 755     {
 756         WINECON_RegLoad(NULL, refcfg = &defcfg);
 757         save = TRUE;
 758     }
 759     di.config = *refcfg;
 760     di.nFont = 0;
 761     di.font = NULL;
 762
 763     modify_session = FALSE;
 764
 765     wndclass.style         = 0;
 766     wndclass.lpfnWndProc   = WCUSER_FontPreviewProc;
 767     wndclass.cbClsExtra    = 0;
 768     wndclass.cbWndExtra    = sizeof (DWORD_PTR); /* for hFont */
 769     wndclass.hInstance     = GetModuleHandleW(NULL);
 770     wndclass.hIcon         = 0;
 771     wndclass.hCursor       = LoadCursorW(0, (LPCWSTR)IDC_ARROW);
 772     wndclass.hbrBackground = GetStockObject(BLACK_BRUSH);
 773     wndclass.lpszMenuName  = NULL;
 774     wndclass.lpszClassName = szFntPreview;
 775     RegisterClassW(&wndclass);
 776
 777     wndclass.style         = 0;
 778     wndclass.lpfnWndProc   = WCUSER_ColorPreviewProc;
 779     wndclass.cbClsExtra    = 0;
 780     wndclass.cbWndExtra    = sizeof(DWORD);
 781     wndclass.hInstance     = GetModuleHandleW(NULL);
 782     wndclass.hIcon         = 0;
 783     wndclass.hCursor       = LoadCursorW(0, (LPCWSTR)IDC_ARROW);
 784     wndclass.hbrBackground = GetStockObject(BLACK_BRUSH);
 785     wndclass.lpszMenuName  = NULL;
 786     wndclass.lpszClassName = szColorPreview;
 787     RegisterClassW(&wndclass);
 788
 789     memset(&psp, 0, sizeof(psp));
 790     psp.dwSize = sizeof(psp);
 791     psp.dwFlags = 0;
 792     psp.hInstance = wndclass.hInstance;
 793     psp.lParam = (LPARAM)&di;
 794
 795     psp.u.pszTemplate = MAKEINTRESOURCEW(IDD_OPTION);
 796     psp.pfnDlgProc = WCUSER_OptionDlgProc;
 797     psPage[0] = CreatePropertySheetPageW(&psp);
 798
 799     psp.u.pszTemplate = MAKEINTRESOURCEW(IDD_FONT);
 800     psp.pfnDlgProc = WCUSER_FontDlgProc;
 801     psPage[1] = CreatePropertySheetPageW(&psp);
 802
 803     psp.u.pszTemplate = MAKEINTRESOURCEW(IDD_CONFIG);
 804     psp.pfnDlgProc = WCUSER_ConfigDlgProc;
 805     psPage[2] = CreatePropertySheetPageW(&psp);
 806
 807     memset(&psHead, 0, sizeof(psHead));
 808     psHead.dwSize = sizeof(psHead);
 809
 810     if (!LoadStringW(GetModuleHandleW(NULL),
 811                      (current) ? IDS_DLG_TIT_CURRENT : IDS_DLG_TIT_DEFAULT,
 812                      buff, sizeof(buff) / sizeof(buff[0])))
 813     {
 814         buff[0] = 'S';
 815         buff[1] = 'e';
 816         buff[2] = 't';
 817         buff[3] = 'u';
 818         buff[4] = 'p';
 819         buff[5] = '\0';
 820     }
 821
 822     psHead.pszCaption = buff;
 823     psHead.nPages = 3;
 824     psHead.hwndParent = data->hWnd;
 825     psHead.u3.phpage = psPage;
 826     psHead.dwFlags = PSH_NOAPPLYNOW;
 827
 828     WINECON_DumpConfig("init", refcfg);
 829
 830     PropertySheetW(&psHead);
 831
 832     if (memcmp(refcfg, &di.config, sizeof(*refcfg)) == 0)
 833         return TRUE;
 834
 835     WINECON_DumpConfig("ref", refcfg);
 836     WINECON_DumpConfig("cur", &di.config);
 837     if (refcfg == &data->curcfg)
 838     {
 839         switch (DialogBoxW(GetModuleHandleW(NULL), MAKEINTRESOURCEW(IDD_SAVE_SETTINGS),
 840                            data->hWnd, WCUSER_SaveDlgProc))
 841         {
 842         case IDC_SAV_SAVE:      save = TRUE; modify_session = TRUE; break;
 843         case IDC_SAV_SESSION:   modify_session = TRUE; break;
 844         case IDCANCEL:          break;
 845         default: WINE_ERR("ooch\n");
 846         }
 847     }
 848
 849     if (modify_session) WINECON_SetConfig(data, &di.config);
 850     if (save)           WINECON_RegSave(&di.config);
 851
 852     return TRUE;
 853 }