programs/winetest/gui.c

   1 /*
   2  * GUI support
   3  *
   4  * Copyright 2004 Ferenc Wagner
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <windows.h>
  22 #include <commctrl.h>
  23
  24 #include "resource.h"
  25 #include "winetest.h"
  26
  27 /* Event object to signal successful window creation to main thread.
  28  */
  29 static HANDLE initEvent;
  30
  31 /* Dialog handle
  32  */
  33 static HWND dialog;
  34
  35 /* Progress data for the text* functions and for scaling.
  36  */
  37 static unsigned int progressMax, progressCurr;
  38 static double progressScale;
  39
  40 /* Progress group counter for the gui* functions.
  41  */
  42 static int progressGroup;
  43
  44 static WNDPROC DefEditProc;
  45
  46 static int
  47 MBdefault (int uType)
  48 {
  49     static const int matrix[][4] = {{IDOK,    0,        0,        0},
  50                                     {IDOK,    IDCANCEL, 0,        0},
  51                                     {IDABORT, IDRETRY,  IDIGNORE, 0},
  52                                     {IDYES,   IDNO,     IDCANCEL, 0},
  53                                     {IDYES,   IDNO,     0,        0},
  54                                     {IDRETRY, IDCANCEL, 0,        0}};
  55     int type = uType & MB_TYPEMASK;
  56     int def  = (uType & MB_DEFMASK) / MB_DEFBUTTON2;
  57
  58     return matrix[type][def];
  59 }
  60
  61 /* report (R_STATUS, fmt, ...) */
  62 static int
  63 textStatus (__ms_va_list ap)
  64 {
  65     char *str = vstrmake (NULL, ap);
  66
  67     fputs (str, stderr);
  68     fputc ('\n', stderr);
  69     heap_free (str);
  70     return 0;
  71 }
  72
  73 static int
  74 guiStatus (__ms_va_list ap)
  75 {
  76     size_t len;
  77     char *str = vstrmake (&len, ap);
  78
  79     if (len > 128) str[129] = 0;
  80     SetDlgItemTextA (dialog, IDC_SB, str);
  81     heap_free (str);
  82     return 0;
  83 }
  84
  85 /* report (R_PROGRESS, barnum, steps) */
  86 static int
  87 textProgress (__ms_va_list ap)
  88 {
  89     progressGroup = va_arg (ap, int);
  90     progressMax = va_arg (ap, int);
  91     progressCurr = 0;
  92     return 0;
  93 }
  94
  95 static int
  96 guiProgress (__ms_va_list ap)
  97 {
  98     unsigned int max;
  99     HWND pb;
 100
 101     progressGroup = va_arg (ap, int);
 102     progressMax = max = va_arg (ap, int);
 103     progressCurr = 0;
 104     if (max > 0xffff) {
 105         progressScale = (double)0xffff / max;
 106         max = 0xffff;
 107     }
 108     else progressScale = 1;
 109     pb = GetDlgItem (dialog, IDC_PB0 + progressGroup * 2);
 110     SendMessageA(pb, PBM_SETRANGE, 0, MAKELPARAM (0, max));
 111     SendMessageA(pb, PBM_SETSTEP, 1, 0);
 112     return 0;
 113 }
 114
 115 /* report (R_STEP, fmt, ...) */
 116 static int
 117 textStep (__ms_va_list ap)
 118 {
 119     char *str = vstrmake (NULL, ap);
 120
 121     progressCurr++;
 122     fputs (str, stderr);
 123     fprintf (stderr, " (%d of %d)\n", progressCurr, progressMax);
 124     heap_free (str);
 125     return 0;
 126 }
 127
 128 static int
 129 guiStep (__ms_va_list ap)
 130 {
 131     const int pgID = IDC_ST0 + progressGroup * 2;
 132     char *str = vstrmake (NULL, ap);
 133
 134     progressCurr++;
 135     SetDlgItemTextA (dialog, pgID, str);
 136     SendDlgItemMessageA(dialog, pgID+1, PBM_SETPOS,
 137                         progressScale * progressCurr, 0);
 138     heap_free (str);
 139     return 0;
 140 }
 141
 142 /* report (R_DELTA, inc, fmt, ...) */
 143 static int
 144 textDelta (__ms_va_list ap)
 145 {
 146     const int inc = va_arg (ap, int);
 147     char *str = vstrmake (NULL, ap);
 148
 149     progressCurr += inc;
 150     fputs (str, stderr);
 151     fprintf (stderr, " (%d of %d)\n", progressCurr, progressMax);
 152     heap_free (str);
 153     return 0;
 154 }
 155
 156 static int
 157 guiDelta (__ms_va_list ap)
 158 {
 159     const int inc = va_arg (ap, int);
 160     const int pgID = IDC_ST0 + progressGroup * 2;
 161     char *str = vstrmake (NULL, ap);
 162
 163     progressCurr += inc;
 164     SetDlgItemTextA (dialog, pgID, str);
 165     SendDlgItemMessageA(dialog, pgID+1, PBM_SETPOS,
 166                         progressScale * progressCurr, 0);
 167     heap_free (str);
 168     return 0;
 169 }
 170
 171 /* report (R_TAG) */
 172 static int
 173 textTag (__ms_va_list ap)
 174 {
 175     fputs ("Tag: ", stderr);
 176     fputs (tag, stderr);
 177     fputc ('\n', stderr);
 178     return 0;
 179 }
 180
 181 static int
 182 guiTag (__ms_va_list ap)
 183 {
 184     SetDlgItemTextA (dialog, IDC_TAG, tag);
 185     return 0;
 186 }
 187
 188 /* report (R_DIR, fmt, ...) */
 189 static int
 190 textDir (__ms_va_list ap)
 191 {
 192     char *str = vstrmake (NULL, ap);
 193
 194     fputs ("Temporary directory: ", stderr);
 195     fputs (str, stderr);
 196     fputc ('\n', stderr);
 197     heap_free (str);
 198     return 0;
 199 }
 200
 201 static int
 202 guiDir (__ms_va_list ap)
 203 {
 204     char *str = vstrmake (NULL, ap);
 205
 206     SetDlgItemTextA (dialog, IDC_DIR, str);
 207     heap_free (str);
 208     return 0;
 209 }
 210
 211 /* report (R_OUT, fmt, ...) */
 212 static int
 213 textOut (__ms_va_list ap)
 214 {
 215     char *str = vstrmake (NULL, ap);
 216
 217     fputs ("Log file: ", stderr);
 218     fputs (str, stderr);
 219     fputc ('\n', stderr);
 220     heap_free (str);
 221     return 0;
 222 }
 223
 224 static int
 225 guiOut (__ms_va_list ap)
 226 {
 227     char *str = vstrmake (NULL, ap);
 228
 229     SetDlgItemTextA (dialog, IDC_OUT, str);
 230     heap_free (str);
 231     return 0;
 232 }
 233
 234 /* report (R_WARNING, fmt, ...) */
 235 static int
 236 textWarning (__ms_va_list ap)
 237 {
 238     fputs ("Warning: ", stderr);
 239     textStatus (ap);
 240     return 0;
 241 }
 242
 243 static int
 244 guiWarning (__ms_va_list ap)
 245 {
 246     char *str = vstrmake (NULL, ap);
 247
 248     MessageBoxA (dialog, str, "Warning", MB_ICONWARNING | MB_OK);
 249     heap_free (str);
 250     return 0;
 251 }
 252
 253 /* report (R_ERROR, fmt, ...) */
 254 static int
 255 textError (__ms_va_list ap)
 256 {
 257     fputs ("Error: ", stderr);
 258     textStatus (ap);
 259     return 0;
 260 }
 261
 262 static int
 263 guiError (__ms_va_list ap)
 264 {
 265     char *str = vstrmake (NULL, ap);
 266
 267     MessageBoxA (dialog, str, "Error", MB_ICONERROR | MB_OK);
 268     heap_free (str);
 269     return 0;
 270 }
 271
 272 /* report (R_FATAL, fmt, ...) */
 273 static int
 274 textFatal (__ms_va_list ap)
 275 {
 276     textError (ap);
 277     exit (1);
 278     return 0;
 279 }
 280
 281 static int
 282 guiFatal (__ms_va_list ap)
 283 {
 284     guiError (ap);
 285     exit (1);
 286     return 0;
 287 }
 288
 289 /* report (R_ASK, type, fmt, ...) */
 290 static int
 291 textAsk (__ms_va_list ap)
 292 {
 293     int uType = va_arg (ap, int);
 294     int ret = MBdefault (uType);
 295     char *str = vstrmake (NULL, ap);
 296
 297     fprintf (stderr, "Question of type %d: %s\n"
 298              "Returning default: %d\n", uType, str, ret);
 299     heap_free (str);
 300     return ret;
 301 }
 302
 303 static int
 304 guiAsk (__ms_va_list ap)
 305 {
 306     int uType = va_arg (ap, int);
 307     char *str = vstrmake (NULL, ap);
 308     int ret = MessageBoxA (dialog, str, "Question", MB_ICONQUESTION | uType);
 309
 310     heap_free (str);
 311     return ret;
 312 }
 313
 314 static BOOL CALLBACK
 315 EditTagProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 316 {
 317     switch (msg) {
 318     case WM_CHAR:
 319         if (wParam == 8) break; /* backspace is OK */
 320         if (GetWindowTextLengthA (hwnd) == MAXTAGLEN ||
 321             !goodtagchar (wParam)) return TRUE;
 322         break;
 323     }
 324     return CallWindowProcA (DefEditProc, hwnd, msg, wParam, lParam);
 325 }
 326
 327 static INT_PTR CALLBACK
 328 AskTagProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 329 {
 330     int len;
 331
 332     switch (msg) {
 333     case WM_INITDIALOG:
 334         DefEditProc = (WNDPROC)SetWindowLongPtrA
 335             (GetDlgItem (hwnd, IDC_TAG), GWLP_WNDPROC, (LONG_PTR)EditTagProc);
 336         return TRUE;
 337     case WM_COMMAND:
 338         switch (LOWORD (wParam)) {
 339         case IDOK:
 340             len = GetWindowTextLengthA (GetDlgItem (hwnd, IDC_TAG));
 341             if(!len) {
 342                report (R_WARNING, "You must enter a tag to continue");
 343                return FALSE;
 344             }
 345             tag = heap_alloc (len+1);
 346             GetDlgItemTextA (hwnd, IDC_TAG, tag, len+1);
 347             EndDialog (hwnd, IDOK);
 348             return TRUE;
 349         case IDABORT:
 350             EndDialog (hwnd, IDABORT);
 351             return TRUE;
 352         }
 353     }
 354     return FALSE;
 355 }
 356
 357 int
 358 guiAskTag (void)
 359 {
 360     return DialogBoxA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(IDD_TAG), dialog, AskTagProc);
 361 }
 362
 363 static INT_PTR CALLBACK
 364 AskEmailProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 365 {
 366     int len;
 367
 368     switch (msg)
 369     {
 370     case WM_COMMAND:
 371         switch (LOWORD (wParam)) {
 372         case IDOK:
 373             len = GetWindowTextLengthA (GetDlgItem (hwnd, IDC_EMAIL));
 374             if(!len) {
 375                report (R_WARNING, "You must enter an email address to continue");
 376                return FALSE;
 377             }
 378             email = heap_alloc (len+1);
 379             GetDlgItemTextA (hwnd, IDC_EMAIL, email, len+1);
 380             EndDialog (hwnd, IDOK);
 381             return TRUE;
 382         case IDABORT:
 383             EndDialog (hwnd, IDABORT);
 384             return TRUE;
 385         }
 386     }
 387     return FALSE;
 388 }
 389
 390 int
 391 guiAskEmail (void)
 392 {
 393     return DialogBoxA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(IDD_EMAIL), dialog, AskEmailProc);
 394 }
 395
 396 /* Quiet functions */
 397 static int
 398 qNoOp (__ms_va_list ap)
 399 {
 400     return 0;
 401 }
 402
 403 static int
 404 qAsk (__ms_va_list ap)
 405 {
 406     return MBdefault (va_arg (ap, int));
 407 }
 408
 409 static INT_PTR CALLBACK
 410 AboutProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 411 {
 412     switch (msg) {
 413     case WM_COMMAND:
 414         switch (LOWORD (wParam)) {
 415         case IDCANCEL:
 416             EndDialog (hwnd, IDCANCEL);
 417             return TRUE;
 418         }
 419     }
 420     return FALSE;
 421 }
 422
 423 static INT_PTR CALLBACK
 424 DlgProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 425 {
 426     switch (msg) {
 427     case WM_INITDIALOG:
 428         SendMessageA(hwnd, WM_SETICON, ICON_SMALL,
 429                      (LPARAM)LoadImageA( GetModuleHandleA(NULL), MAKEINTRESOURCEA(IDI_WINE), IMAGE_ICON,
 430                                          GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON),
 431                                          LR_SHARED ));
 432         SendMessageA(hwnd, WM_SETICON, ICON_BIG,
 433                      (LPARAM)LoadIconA( GetModuleHandleA(NULL), MAKEINTRESOURCEA(IDI_WINE)));
 434         dialog = hwnd;
 435         if (!SetEvent (initEvent)) {
 436             report (R_STATUS, "Can't signal main thread: %d",
 437                     GetLastError ());
 438             EndDialog (hwnd, 2);
 439         }
 440         return TRUE;
 441     case WM_CLOSE:
 442         EndDialog (hwnd, 3);
 443         return TRUE;
 444     case WM_COMMAND:
 445         switch (LOWORD (wParam)) {
 446         case IDHELP:
 447             DialogBoxA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(IDD_ABOUT), hwnd, AboutProc);
 448             return TRUE;
 449         case IDABORT:
 450             report (R_STATUS, "Aborting, please wait...");
 451             aborting = TRUE;
 452             return TRUE;
 453         }
 454     }
 455     return FALSE;
 456 }
 457
 458 static DWORD WINAPI
 459 DlgThreadProc (LPVOID param)
 460 {
 461     int ret;
 462
 463     InitCommonControls ();
 464     ret = DialogBoxA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(IDD_STATUS), NULL, DlgProc);
 465     switch (ret) {
 466     case 0:
 467         report (R_FATAL, "Cannot display dialog");
 468         break;
 469     case 1:
 470         report (R_WARNING, "DialogBox failed: %d",
 471                 GetLastError ());
 472         break;
 473     case 3:
 474         exit (0);
 475     default:
 476         report (R_STATUS, "Dialog exited: %d", ret);
 477     }
 478     return 0;
 479 }
 480
 481 int WINAPIV report (enum report_type t, ...)
 482 {
 483     typedef int r_fun_t (__ms_va_list);
 484
 485     __ms_va_list ap;
 486     int ret = 0;
 487     static r_fun_t * const text_funcs[] =
 488         {textStatus, textProgress, textStep, textDelta,
 489          textTag, textDir, textOut,
 490          textWarning, textError, textFatal, textAsk};
 491     static r_fun_t * const GUI_funcs[] =
 492         {guiStatus, guiProgress, guiStep, guiDelta,
 493          guiTag, guiDir, guiOut,
 494          guiWarning, guiError, guiFatal, guiAsk};
 495     static r_fun_t * const quiet_funcs[] =
 496         {qNoOp, qNoOp, qNoOp, qNoOp,
 497          qNoOp, qNoOp, qNoOp,
 498          qNoOp, textError, textFatal, qAsk};
 499     static r_fun_t * const * funcs = NULL;
 500
 501     switch (t) {
 502     case R_TEXTMODE:
 503         funcs = text_funcs;
 504         return 0;
 505     case R_QUIET:
 506         funcs = quiet_funcs;
 507         return 0;
 508     default:
 509         break;
 510     }
 511
 512     if (!funcs) {
 513         HANDLE DlgThread;
 514         DWORD DlgThreadID;
 515
 516         funcs = text_funcs;
 517         initEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
 518         if (!initEvent)
 519             report (R_STATUS, "Can't create event object: %d",
 520                     GetLastError ());
 521         else {
 522             DlgThread = CreateThread (NULL, 0, DlgThreadProc,
 523                                       NULL, 0, &DlgThreadID);
 524             if (!DlgThread)
 525                 report (R_STATUS, "Can't create GUI thread: %d",
 526                         GetLastError ());
 527             else {
 528                 DWORD ret = WaitForSingleObject (initEvent, INFINITE);
 529                 CloseHandle(DlgThread);
 530                 switch (ret) {
 531                 case WAIT_OBJECT_0:
 532                     funcs = GUI_funcs;
 533                     break;
 534                 case WAIT_TIMEOUT:
 535                     report (R_STATUS, "GUI creation timed out");
 536                     break;
 537                 case WAIT_FAILED:
 538                     report (R_STATUS, "Wait for GUI failed: %d",
 539                             GetLastError ());
 540                     break;
 541                 default:
 542                     report (R_STATUS, "Wait returned %d",
 543                             ret);
 544                     break;
 545                 }
 546             }
 547         }
 548     }
 549
 550     __ms_va_start (ap, t);
 551     if (t < ARRAY_SIZE(text_funcs)) ret = funcs[t](ap);
 552     else report (R_WARNING, "unimplemented report type: %d", t);
 553     __ms_va_end (ap);
 554     return ret;
 555 }