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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 BOOL 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         SetWindowLong(hDlg, DWL_USER, (DWORD)di);
  69
  70         if (di->config.cursor_size <= 25)       idc = IDC_OPT_CURSOR_SMALL;
  71         else if (di->config.cursor_size <= 50)  idc = IDC_OPT_CURSOR_MEDIUM;
  72         else                                    idc = IDC_OPT_CURSOR_LARGE;
  73         SendDlgItemMessage(hDlg, idc, BM_SETCHECK, BST_CHECKED, 0L);
  74         SetDlgItemInt(hDlg, IDC_OPT_HIST_SIZE, WINECON_GetHistorySize(di->data->hConIn),  FALSE);
  75         SendDlgItemMessage(hDlg, IDC_OPT_HIST_NODOUBLE, BM_SETCHECK,
  76                            (di->config.history_nodup) ? BST_CHECKED : BST_UNCHECKED, 0L);
  77         SendDlgItemMessage(hDlg, IDC_OPT_CONF_CTRL, BM_SETCHECK,
  78                            (di->config.menu_mask & MK_CONTROL) ? BST_CHECKED : BST_UNCHECKED, 0L);
  79         SendDlgItemMessage(hDlg, IDC_OPT_CONF_SHIFT, BM_SETCHECK,
  80                            (di->config.menu_mask & MK_SHIFT) ? BST_CHECKED : BST_UNCHECKED, 0L);
  81         SendDlgItemMessage(hDlg, IDC_OPT_QUICK_EDIT, BM_SETCHECK,
  82                            (di->config.quick_edit) ? BST_CHECKED : BST_UNCHECKED, 0L);
  83         return FALSE; /* because we set the focus */
  84     case WM_COMMAND:
  85         break;
  86     case WM_NOTIFY:
  87     {
  88         NMHDR*  nmhdr = (NMHDR*)lParam;
  89         DWORD   val;
  90         BOOL    done;
  91
  92         di = (struct dialog_info*)GetWindowLong(hDlg, DWL_USER);
  93
  94         switch (nmhdr->code)
  95         {
  96         case PSN_SETACTIVE:
  97             /* needed in propsheet to keep properly the selected radio button
  98              * otherwise, the focus would be set to the first tab stop in the
  99              * propsheet, which would always activate the first radio button
 100              */
 101             if (IsDlgButtonChecked(hDlg, IDC_OPT_CURSOR_SMALL) == BST_CHECKED)
 102                 idc = IDC_OPT_CURSOR_SMALL;
 103             else if (IsDlgButtonChecked(hDlg, IDC_OPT_CURSOR_MEDIUM) == BST_CHECKED)
 104                 idc = IDC_OPT_CURSOR_MEDIUM;
 105             else
 106                 idc = IDC_OPT_CURSOR_LARGE;
 107             PostMessage(hDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hDlg, idc), TRUE);
 108             di->hDlg = hDlg;
 109             break;
 110         case PSN_APPLY:
 111             if (IsDlgButtonChecked(hDlg, IDC_OPT_CURSOR_SMALL) == BST_CHECKED) val = 25;
 112             else if (IsDlgButtonChecked(hDlg, IDC_OPT_CURSOR_MEDIUM) == BST_CHECKED) val = 50;
 113             else val = 100;
 114             di->config.cursor_size = val;
 115
 116             val = GetDlgItemInt(hDlg, IDC_OPT_HIST_SIZE, &done, FALSE);
 117             if (done) di->config.history_size = val;
 118
 119             val = (IsDlgButtonChecked(hDlg, IDC_OPT_HIST_NODOUBLE) & BST_CHECKED) ? TRUE : FALSE;
 120             di->config.history_nodup = val;
 121
 122             val = 0;
 123             if (IsDlgButtonChecked(hDlg, IDC_OPT_CONF_CTRL) & BST_CHECKED)  val |= MK_CONTROL;
 124             if (IsDlgButtonChecked(hDlg, IDC_OPT_CONF_SHIFT) & BST_CHECKED) val |= MK_SHIFT;
 125             di->config.menu_mask = val;
 126
 127             val = (IsDlgButtonChecked(hDlg, IDC_OPT_QUICK_EDIT) & BST_CHECKED) ? TRUE : FALSE;
 128             di->config.quick_edit = val;
 129
 130             SetWindowLong(hDlg, DWL_MSGRESULT, PSNRET_NOERROR);
 131             return TRUE;
 132         default:
 133             return FALSE;
 134         }
 135         break;
 136     }
 137     default:
 138         return FALSE;
 139     }
 140     return TRUE;
 141 }
 142
 143 /******************************************************************
 144  *              WCUSER_FontPreviewProc
 145  *
 146  * Window proc for font previewer in font property sheet
 147  */
 148 static LRESULT WINAPI WCUSER_FontPreviewProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 149 {
 150     switch (msg)
 151     {
 152     case WM_CREATE:
 153         SetWindowLong(hWnd, 0, 0);
 154         break;
 155     case WM_GETFONT:
 156         return GetWindowLong(hWnd, 0);
 157     case WM_SETFONT:
 158         SetWindowLong(hWnd, 0, wParam);
 159         if (LOWORD(lParam))
 160         {
 161             InvalidateRect(hWnd, NULL, TRUE);
 162             UpdateWindow(hWnd);
 163         }
 164         break;
 165     case WM_DESTROY:
 166         {
 167             HFONT hFont = (HFONT)GetWindowLong(hWnd, 0L);
 168             if (hFont) DeleteObject(hFont);
 169         }
 170         break;
 171     case WM_PAINT:
 172         {
 173             PAINTSTRUCT         ps;
 174             int                 font_idx;
 175             int                 size_idx;
 176             struct dialog_info* di;
 177             HFONT               hFont, hOldFont;
 178
 179             di = (struct dialog_info*)GetWindowLong(GetParent(hWnd), DWL_USER);
 180             BeginPaint(hWnd, &ps);
 181
 182             font_idx = SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_FONT, LB_GETCURSEL, 0L, 0L);
 183             size_idx = SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_SIZE, LB_GETCURSEL, 0L, 0L);
 184
 185             hFont = (HFONT)GetWindowLong(hWnd, 0L);
 186             if (hFont)
 187             {
 188                 WCHAR   buf1[256];
 189                 WCHAR   buf2[256];
 190                 int     len1, len2;
 191
 192                 len1 = LoadString(GetModuleHandle(NULL), IDS_FNT_PREVIEW_1,
 193                                   buf1, sizeof(buf1) / sizeof(WCHAR));
 194                 len2 = LoadString(GetModuleHandle(NULL), IDS_FNT_PREVIEW_2,
 195                                   buf2, sizeof(buf2) / sizeof(WCHAR));
 196                 buf1[len1] = buf2[len2] = 0;
 197                 if (len1)
 198                 {
 199                     hOldFont = SelectObject(ps.hdc, hFont);
 200                     SetBkColor(ps.hdc, WCUSER_ColorMap[GetWindowLong(GetDlgItem(di->hDlg, IDC_FNT_COLOR_BK), 0)]);
 201                     SetTextColor(ps.hdc, WCUSER_ColorMap[GetWindowLong(GetDlgItem(di->hDlg, IDC_FNT_COLOR_FG), 0)]);
 202                     TextOut(ps.hdc, 0, 0, buf1, len1);
 203                     if (len2)
 204                         TextOut(ps.hdc, 0, di->font[size_idx].height, buf2, len2);
 205                     SelectObject(ps.hdc, hOldFont);
 206                 }
 207             }
 208             EndPaint(hWnd, &ps);
 209         }
 210         break;
 211     default:
 212         return DefWindowProc(hWnd, msg, wParam, lParam);
 213     }
 214     return 0L;
 215 }
 216
 217 /******************************************************************
 218  *              WCUSER_ColorPreviewProc
 219  *
 220  * Window proc for color previewer in font property sheet
 221  */
 222 static LRESULT WINAPI WCUSER_ColorPreviewProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 223 {
 224     switch (msg)
 225     {
 226     case WM_PAINT:
 227         {
 228             PAINTSTRUCT     ps;
 229             int             i, step;
 230             RECT            client, r;
 231             HBRUSH          hbr;
 232
 233             BeginPaint(hWnd, &ps);
 234             GetClientRect(hWnd, &client);
 235             step = client.right / 8;
 236
 237             for (i = 0; i < 16; i++)
 238             {
 239                 r.top = (i / 8) * (client.bottom / 2);
 240                 r.bottom = r.top + client.bottom / 2;
 241                 r.left = (i & 7) * step;
 242                 r.right = r.left + step;
 243                 hbr = CreateSolidBrush(WCUSER_ColorMap[i]);
 244                 FillRect(ps.hdc, &r, hbr);
 245                 DeleteObject(hbr);
 246                 if (GetWindowLong(hWnd, 0) == i)
 247                 {
 248                     HPEN        hOldPen;
 249                     int         i = 2;
 250
 251                     hOldPen = SelectObject(ps.hdc, GetStockObject(WHITE_PEN));
 252                     r.right--; r.bottom--;
 253                     for (;;)
 254                     {
 255                         MoveToEx(ps.hdc, r.left, r.bottom, NULL);
 256                         LineTo(ps.hdc, r.left, r.top);
 257                         LineTo(ps.hdc, r.right, r.top);
 258                         SelectObject(ps.hdc, GetStockObject(BLACK_PEN));
 259                         LineTo(ps.hdc, r.right, r.bottom);
 260                         LineTo(ps.hdc, r.left, r.bottom);
 261
 262                         if (--i == 0) break;
 263                         r.left++; r.top++; r.right--; r.bottom--;
 264                         SelectObject(ps.hdc, GetStockObject(WHITE_PEN));
 265                     }
 266                     SelectObject(ps.hdc, hOldPen);
 267                 }
 268             }
 269             EndPaint(hWnd, &ps);
 270             break;
 271         }
 272     case WM_LBUTTONDOWN:
 273         {
 274             int             i, step;
 275             RECT            client;
 276
 277             GetClientRect(hWnd, &client);
 278             step = client.right / 8;
 279             i = (HIWORD(lParam) >= client.bottom / 2) ? 8 : 0;
 280             i += LOWORD(lParam) / step;
 281             SetWindowLong(hWnd, 0, i);
 282             InvalidateRect(GetDlgItem(GetParent(hWnd), IDC_FNT_PREVIEW), NULL, FALSE);
 283             InvalidateRect(hWnd, NULL, FALSE);
 284         }
 285         break;
 286     default:
 287         return DefWindowProc(hWnd, msg, wParam, lParam);
 288     }
 289     return 0L;
 290 }
 291
 292 /******************************************************************
 293  *              font_enum
 294  *
 295  * enumerates all the font names with at least one valid font
 296  */
 297 static int CALLBACK font_enum_size2(const LOGFONT* lf, const TEXTMETRIC* tm,
 298                                     DWORD FontType, LPARAM lParam)
 299 {
 300     struct dialog_info* di = (struct dialog_info*)lParam;
 301
 302     WCUSER_DumpTextMetric(tm, FontType);
 303     if (WCUSER_ValidateFontMetric(di->data, tm, FontType))
 304     {
 305         di->nFont++;
 306     }
 307
 308     return 1;
 309 }
 310
 311 static int CALLBACK font_enum(const LOGFONT* lf, const TEXTMETRIC* tm,
 312                               DWORD FontType, LPARAM lParam)
 313 {
 314     struct dialog_info* di = (struct dialog_info*)lParam;
 315
 316     WCUSER_DumpLogFont("DlgFamily: ", lf, FontType);
 317     if (WCUSER_ValidateFont(di->data, lf))
 318     {
 319         if (FontType & RASTER_FONTTYPE)
 320         {
 321             di->nFont = 0;
 322             EnumFontFamilies(PRIVATE(di->data)->hMemDC, lf->lfFaceName, font_enum_size2, (LPARAM)di);
 323         }
 324         else
 325             di->nFont = 1;
 326
 327         if (di->nFont)
 328         {
 329             SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_FONT, LB_ADDSTRING,
 330                                0, (LPARAM)lf->lfFaceName);
 331         }
 332     }
 333
 334     return 1;
 335 }
 336
 337 /******************************************************************
 338  *              font_enum_size
 339  *
 340  *
 341  */
 342 static int CALLBACK font_enum_size(const LOGFONT* lf, const TEXTMETRIC* tm,
 343                                    DWORD FontType, LPARAM lParam)
 344 {
 345     struct dialog_info* di = (struct dialog_info*)lParam;
 346     WCHAR               buf[32];
 347     static const WCHAR  fmt[] = {'%','l','d',0};
 348
 349     WCUSER_DumpTextMetric(tm, FontType);
 350     if (di->nFont == 0 && !(FontType & RASTER_FONTTYPE))
 351     {
 352         static const int sizes[] = {8,9,10,11,12,14,16,18,20,22,24,26,28,36,48,72};
 353         int i;
 354
 355         di->nFont = sizeof(sizes) / sizeof(sizes[0]);
 356         di->font = HeapAlloc(GetProcessHeap(), 0, di->nFont * sizeof(di->font[0]));
 357         for (i = 0; i < di->nFont; i++)
 358         {
 359             /* drop sizes where window size wouldn't fit on screen */
 360             if (sizes[i] * di->data->curcfg.win_height > GetSystemMetrics(SM_CYSCREEN))
 361             {
 362                 di->nFont = i;
 363                 break;
 364             }
 365             di->font[i].height = sizes[i];
 366             di->font[i].weight = 400;
 367             lstrcpy(di->font[i].faceName, lf->lfFaceName);
 368             wsprintf(buf, fmt, sizes[i]);
 369             SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_SIZE, LB_INSERTSTRING, i, (LPARAM)buf);
 370         }
 371         /* don't need to enumerate other */
 372         return 0;
 373     }
 374
 375     if (WCUSER_ValidateFontMetric(di->data, tm, FontType))
 376     {
 377         int     idx;
 378
 379         /* we want the string to be sorted with a numeric order, not a lexicographic...
 380          * do the job by hand... get where to insert the new string
 381          */
 382         for (idx = 0; idx < di->nFont && tm->tmHeight > di->font[idx].height; idx++);
 383         while (idx < di->nFont &&
 384                tm->tmHeight == di->font[idx].height &&
 385                tm->tmWeight > di->font[idx].weight)
 386             idx++;
 387         if (idx == di->nFont ||
 388             tm->tmHeight != di->font[idx].height ||
 389             tm->tmWeight < di->font[idx].weight)
 390         {
 391             /* here we need to add the new entry */
 392             wsprintf(buf, fmt, tm->tmHeight);
 393             SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_SIZE, LB_INSERTSTRING, idx, (LPARAM)buf);
 394
 395             /* now grow our arrays and insert the values at the same index than in the list box */
 396             di->font = HeapReAlloc(GetProcessHeap(), 0, di->font, sizeof(*di->font) * (di->nFont + 1));
 397             if (idx != di->nFont)
 398                 memmove(&di->font[idx + 1], &di->font[idx], (di->nFont - idx) * sizeof(*di->font));
 399             di->font[idx].height = tm->tmHeight;
 400             di->font[idx].weight = tm->tmWeight;
 401             lstrcpy(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     LOGFONT     lf;
 419     HFONT       hFont, hOldFont;
 420     struct config_data config;
 421
 422     font_idx = SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_FONT, LB_GETCURSEL, 0L, 0L);
 423     size_idx = SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_SIZE, LB_GETCURSEL, 0L, 0L);
 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, PRIVATE(di->data)->hWnd, &lf);
 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)SendDlgItemMessage(di->hDlg, IDC_FNT_PREVIEW, WM_GETFONT, 0L, 0L);
 437
 438     SendDlgItemMessage(di->hDlg, IDC_FNT_PREVIEW, WM_SETFONT, (DWORD)hFont, TRUE);
 439     if (hOldFont) DeleteObject(hOldFont);
 440
 441     LoadString(GetModuleHandle(NULL), IDS_FNT_DISPLAY, fmt, sizeof(fmt) / sizeof(WCHAR));
 442     wsprintf(buf, fmt, config.cell_width, config.cell_height);
 443
 444     SendDlgItemMessage(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 = SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_FONT, LB_GETCURSEL, 0L, 0L);
 460     if (idx < 0) return FALSE;
 461
 462     SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_FONT, LB_GETTEXT, idx, (LPARAM)lfFaceName);
 463     SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_SIZE, LB_RESETCONTENT, 0L, 0L);
 464     if (di->font) HeapFree(GetProcessHeap(), 0, di->font);
 465     di->nFont = 0;
 466     di->font = NULL;
 467
 468     EnumFontFamilies(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 (!lstrcmp(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     SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_SIZE, LB_SETCURSEL, idx, 0L);
 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     SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_FONT, LB_RESETCONTENT, 0L, 0L);
 501     EnumFontFamilies(PRIVATE(di->data)->hMemDC, NULL, font_enum, (LPARAM)di);
 502     if (SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_FONT, LB_SELECTSTRING,
 503                            (WPARAM)-1, (LPARAM)di->config.face_name) == LB_ERR)
 504         SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_FONT, LB_SETCURSEL, 0L, 0L);
 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 BOOL 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         SetWindowLong(hDlg, DWL_USER, (DWORD)di);
 524         /* remove dialog from this control, font will be reset when listboxes are filled */
 525         SendDlgItemMessage(hDlg, IDC_FNT_PREVIEW, WM_SETFONT, 0L, 0L);
 526         fill_list_font(di);
 527         SetWindowLong(GetDlgItem(hDlg, IDC_FNT_COLOR_BK), 0, (di->config.def_attr >> 4) & 0x0F);
 528         SetWindowLong(GetDlgItem(hDlg, IDC_FNT_COLOR_FG), 0, di->config.def_attr & 0x0F);
 529         break;
 530     case WM_COMMAND:
 531         di = (struct dialog_info*)GetWindowLong(hDlg, DWL_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*)GetWindowLong(hDlg, DWL_USER);
 554         switch (nmhdr->code)
 555         {
 556         case PSN_SETACTIVE:
 557             di->hDlg = hDlg;
 558             break;
 559         case PSN_APPLY:
 560             val = SendDlgItemMessage(hDlg, IDC_FNT_LIST_SIZE, LB_GETCURSEL, 0L, 0L);
 561
 562             if (val < di->nFont)
 563             {
 564                 LOGFONT 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                                              PRIVATE(di->data)->hWnd, &lf));
 570             }
 571
 572             val = (GetWindowLong(GetDlgItem(hDlg, IDC_FNT_COLOR_BK), 0) << 4) |
 573                 GetWindowLong(GetDlgItem(hDlg, IDC_FNT_COLOR_FG), 0);
 574             di->config.def_attr = val;
 575
 576             SetWindowLong(hDlg, DWL_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 BOOL WINAPI WCUSER_ConfigDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
 595 {
 596     struct dialog_info*         di;
 597
 598     switch (msg)
 599     {
 600     case WM_INITDIALOG:
 601         di = (struct dialog_info*)((PROPSHEETPAGEA*)lParam)->lParam;
 602         di->hDlg = hDlg;
 603         SetWindowLong(hDlg, DWL_USER, (DWORD)di);
 604         SetDlgItemInt(hDlg, IDC_CNF_SB_WIDTH,   di->config.sb_width,   FALSE);
 605         SetDlgItemInt(hDlg, IDC_CNF_SB_HEIGHT,  di->config.sb_height,  FALSE);
 606         SetDlgItemInt(hDlg, IDC_CNF_WIN_WIDTH,  di->config.win_width,  FALSE);
 607         SetDlgItemInt(hDlg, IDC_CNF_WIN_HEIGHT, di->config.win_height, FALSE);
 608         SendDlgItemMessage(hDlg, IDC_CNF_CLOSE_EXIT, BM_SETCHECK,
 609                            (di->config.exit_on_die) ? BST_CHECKED : BST_UNCHECKED, 0L);
 610         {
 611             static const WCHAR s1[] = {'W','i','n','3','2',0};
 612             static const WCHAR s2[] = {'E','m','a','c','s',0};
 613
 614             SendDlgItemMessage(hDlg, IDC_CNF_EDITION_MODE, CB_ADDSTRING,
 615                                0, (LPARAM)s1);
 616             SendDlgItemMessage(hDlg, IDC_CNF_EDITION_MODE, CB_ADDSTRING,
 617                                0, (LPARAM)s2);
 618             SendDlgItemMessage(hDlg, IDC_CNF_EDITION_MODE, CB_SETCURSEL,
 619                                di->config.edition_mode, 0);
 620         }
 621
 622         break;
 623     case WM_COMMAND:
 624         di = (struct dialog_info*)GetWindowLong(hDlg, DWL_USER);
 625         switch (LOWORD(wParam))
 626         {
 627         }
 628         break;
 629     case WM_NOTIFY:
 630     {
 631         NMHDR*          nmhdr = (NMHDR*)lParam;
 632         int             win_w, win_h, sb_w, sb_h;
 633         BOOL            st1, st2;
 634
 635         di = (struct dialog_info*)GetWindowLong(hDlg, DWL_USER);
 636         switch (nmhdr->code)
 637         {
 638         case PSN_SETACTIVE:
 639             di->hDlg = hDlg;
 640             break;
 641         case PSN_APPLY:
 642             sb_w = GetDlgItemInt(hDlg, IDC_CNF_SB_WIDTH,  &st1, FALSE);
 643             sb_h = GetDlgItemInt(hDlg, IDC_CNF_SB_HEIGHT, &st2, FALSE);
 644             if (!st1 || ! st2)
 645             {
 646                 SetWindowLong(hDlg, DWL_MSGRESULT, PSNRET_INVALID);
 647                 return TRUE;
 648             }
 649             win_w = GetDlgItemInt(hDlg, IDC_CNF_WIN_WIDTH,  &st1, FALSE);
 650             win_h = GetDlgItemInt(hDlg, IDC_CNF_WIN_HEIGHT, &st2, FALSE);
 651             if (!st1 || !st2)
 652             {
 653                 SetWindowLong(hDlg, DWL_MSGRESULT, PSNRET_INVALID);
 654                 return TRUE;
 655             }
 656             if (win_w > sb_w || win_h > sb_h)
 657             {
 658                 WCHAR   cap[256];
 659                 WCHAR   txt[256];
 660
 661                 LoadString(GetModuleHandle(NULL), IDS_DLG_TIT_ERROR,
 662                            cap, sizeof(cap) / sizeof(WCHAR));
 663                 LoadString(GetModuleHandle(NULL), IDS_DLG_ERR_SBWINSIZE,
 664                            txt, sizeof(txt) / sizeof(WCHAR));
 665
 666                 MessageBox(hDlg, txt, cap, MB_OK);
 667                 SetWindowLong(hDlg, DWL_MSGRESULT, PSNRET_INVALID);
 668                 return TRUE;
 669             }
 670             di->config.win_width  = win_w;
 671             di->config.win_height = win_h;
 672             di->config.sb_width  = sb_w;
 673             di->config.sb_height = sb_h;
 674
 675             di->config.exit_on_die = IsDlgButtonChecked(hDlg, IDC_CNF_CLOSE_EXIT) ? 1 : 0;
 676             di->config.edition_mode = SendDlgItemMessage(hDlg, IDC_CNF_EDITION_MODE, CB_GETCURSEL,
 677                                                          0, 0);
 678             SetWindowLong(hDlg, DWL_MSGRESULT, PSNRET_NOERROR);
 679             return TRUE;
 680         default:
 681             return FALSE;
 682         }
 683         break;
 684     }
 685     default:
 686         return FALSE;
 687     }
 688     return TRUE;
 689 }
 690
 691 /******************************************************************
 692  *              WCUSER_SaveDlgProc
 693  *
 694  *      Dialog Procedure for choosing how to handle modification to the
 695  * console settings.
 696  */
 697 static BOOL WINAPI WCUSER_SaveDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
 698 {
 699     switch (msg)
 700     {
 701     case WM_INITDIALOG:
 702         break;
 703     case WM_COMMAND:
 704         switch (LOWORD(wParam))
 705         {
 706         case IDOK:
 707             EndDialog(hDlg,
 708                       (IsDlgButtonChecked(hDlg, IDC_SAV_SAVE) == BST_CHECKED) ?
 709                       IDC_SAV_SAVE : IDC_SAV_SESSION);
 710             break;
 711         case IDCANCEL:
 712             EndDialog(hDlg, IDCANCEL); break;
 713         }
 714         break;
 715     default:
 716         return FALSE;
 717     }
 718     return TRUE;
 719 }
 720
 721 /******************************************************************
 722  *              WCUSER_GetProperties
 723  *
 724  * Runs the dialog box to set up the wineconsole options
 725  */
 726 BOOL WCUSER_GetProperties(struct inner_data* data, BOOL current)
 727 {
 728     HPROPSHEETPAGE      psPage[3];
 729     PROPSHEETPAGE       psp;
 730     PROPSHEETHEADER     psHead;
 731     WCHAR               buff[256];
 732     WNDCLASS            wndclass;
 733     static const WCHAR szFntPreview[] = {'W','i','n','e','C','o','n','F','o','n','t','P','r','e','v','i','e','w',0};
 734     static const WCHAR szColorPreview[] = {'W','i','n','e','C','o','n','C','o','l','o','r','P','r','e','v','i','e','w',0};
 735     struct dialog_info  di;
 736     struct config_data  defcfg;
 737     struct config_data* refcfg;
 738     BOOL                save, modify_session;
 739
 740     InitCommonControls();
 741
 742     di.data = data;
 743     if (current)
 744     {
 745         refcfg = &data->curcfg;
 746         save = FALSE;
 747     }
 748     else
 749     {
 750         WINECON_RegLoad(NULL, refcfg = &defcfg);
 751         save = TRUE;
 752     }
 753     di.config = *refcfg;
 754     di.nFont = 0;
 755     di.font = NULL;
 756
 757     modify_session = FALSE;
 758
 759     wndclass.style         = 0;
 760     wndclass.lpfnWndProc   = WCUSER_FontPreviewProc;
 761     wndclass.cbClsExtra    = 0;
 762     wndclass.cbWndExtra    = 4; /* for hFont */
 763     wndclass.hInstance     = GetModuleHandle(NULL);
 764     wndclass.hIcon         = 0;
 765     wndclass.hCursor       = LoadCursor(0, IDC_ARROW);
 766     wndclass.hbrBackground = GetStockObject(BLACK_BRUSH);
 767     wndclass.lpszMenuName  = NULL;
 768     wndclass.lpszClassName = szFntPreview;
 769     RegisterClass(&wndclass);
 770
 771     wndclass.style         = 0;
 772     wndclass.lpfnWndProc   = WCUSER_ColorPreviewProc;
 773     wndclass.cbClsExtra    = 0;
 774     wndclass.cbWndExtra    = sizeof(DWORD);
 775     wndclass.hInstance     = GetModuleHandle(NULL);
 776     wndclass.hIcon         = 0;
 777     wndclass.hCursor       = LoadCursor(0, IDC_ARROW);
 778     wndclass.hbrBackground = GetStockObject(BLACK_BRUSH);
 779     wndclass.lpszMenuName  = NULL;
 780     wndclass.lpszClassName = szColorPreview;
 781     RegisterClass(&wndclass);
 782
 783     memset(&psp, 0, sizeof(psp));
 784     psp.dwSize = sizeof(psp);
 785     psp.dwFlags = 0;
 786     psp.hInstance = wndclass.hInstance;
 787     psp.lParam = (LPARAM)&di;
 788
 789     psp.u.pszTemplate = MAKEINTRESOURCE(IDD_OPTION);
 790     psp.pfnDlgProc = WCUSER_OptionDlgProc;
 791     psPage[0] = CreatePropertySheetPage(&psp);
 792
 793     psp.u.pszTemplate = MAKEINTRESOURCE(IDD_FONT);
 794     psp.pfnDlgProc = WCUSER_FontDlgProc;
 795     psPage[1] = CreatePropertySheetPage(&psp);
 796
 797     psp.u.pszTemplate = MAKEINTRESOURCE(IDD_CONFIG);
 798     psp.pfnDlgProc = WCUSER_ConfigDlgProc;
 799     psPage[2] = CreatePropertySheetPage(&psp);
 800
 801     memset(&psHead, 0, sizeof(psHead));
 802     psHead.dwSize = sizeof(psHead);
 803
 804     if (!LoadString(GetModuleHandle(NULL),
 805                     (current) ? IDS_DLG_TIT_CURRENT : IDS_DLG_TIT_DEFAULT,
 806                     buff, sizeof(buff) / sizeof(buff[0])))
 807     {
 808         buff[0] = 'S';
 809         buff[1] = 'e';
 810         buff[2] = 't';
 811         buff[3] = 'u';
 812         buff[4] = 'p';
 813         buff[5] = '\0';
 814     }
 815
 816     psHead.pszCaption = buff;
 817     psHead.nPages = 3;
 818     psHead.hwndParent = PRIVATE(data)->hWnd;
 819     psHead.u3.phpage = psPage;
 820
 821     WINECON_DumpConfig("init", refcfg);
 822
 823     PropertySheet(&psHead);
 824
 825     if (memcmp(refcfg, &di.config, sizeof(*refcfg)) == 0)
 826         return TRUE;
 827
 828     WINECON_DumpConfig("ref", refcfg);
 829     WINECON_DumpConfig("cur", &di.config);
 830     if (refcfg == &data->curcfg)
 831     {
 832         switch (DialogBox(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_SAVE_SETTINGS),
 833                           PRIVATE(data)->hWnd, WCUSER_SaveDlgProc))
 834         {
 835         case IDC_SAV_SAVE:      save = TRUE; modify_session = TRUE; break;
 836         case IDC_SAV_SESSION:   modify_session = TRUE; break;
 837         case IDCANCEL:          break;
 838         default: WINE_ERR("ooch\n");
 839         }
 840     }
 841
 842     if (modify_session) WINECON_SetConfig(data, &di.config, FALSE);
 843     if (save)           WINECON_RegSave(&di.config);
 844
 845     return TRUE;
 846 }