git.oblomov.eu Git - wine/blob - 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  *
  19  */
  20
  21 #include <windows.h>
  22 #include <commctrl.h>
  23
  24 #include "guires.h"
  25 #include "winetest.h"
  26
  27 /* Event object to signal successful window creation to main thread.
  28  */
  29 HANDLE initEvent;
  30
  31 /* Dialog handle
  32  */
  33 HWND dialog;
  34
  35 /* Progress data for the text* functions and for scaling.
  36  */
  37 unsigned int progressMax, progressCurr;
  38 double progressScale;
  39
  40 /* Progress group counter for the gui* functions.
  41  */
  42 int progressGroup;
  43
  44 char *
  45 renderString (va_list ap)
  46 {
  47     const char *fmt = va_arg (ap, char*);
  48     static char buffer[128];
  49
  50     vsnprintf (buffer, sizeof buffer, fmt, ap);
  51     return buffer;
  52 }
  53
  54 int
  55 MBdefault (int uType)
  56 {
  57     static const int matrix[][4] = {{IDOK,    0,        0,        0},
  58                                     {IDOK,    IDCANCEL, 0,        0},
  59                                     {IDABORT, IDRETRY,  IDIGNORE, 0},
  60                                     {IDYES,   IDNO,     IDCANCEL, 0},
  61                                     {IDYES,   IDNO,     0,        0},
  62                                     {IDRETRY, IDCANCEL, 0,        0}};
  63     int type = uType & MB_TYPEMASK;
  64     int def  = (uType & MB_DEFMASK) / MB_DEFBUTTON2;
  65
  66     return matrix[type][def];
  67 }
  68
  69 /* report (R_STATUS, fmt, ...) */
  70 int
  71 textStatus (va_list ap)
  72 {
  73     char *str = vstrmake (NULL, ap);
  74
  75     fputs (str, stderr);
  76     fputc ('\n', stderr);
  77     free (str);
  78     return 0;
  79 }
  80
  81 int
  82 guiStatus (va_list ap)
  83 {
  84     size_t len;
  85     char *str = vstrmake (&len, ap);
  86
  87     if (len > 128) str[129] = 0;
  88     SetDlgItemText (dialog, IDC_SB, str);
  89     free (str);
  90     return 0;
  91 }
  92
  93 /* report (R_PROGRESS, barnum, steps) */
  94 int
  95 textProgress (va_list ap)
  96 {
  97     progressMax = va_arg (ap, int);
  98     progressCurr = 0;
  99     return 0;
 100 }
 101
 102 int
 103 guiProgress (va_list ap)
 104 {
 105     unsigned int max;
 106     HWND pb;
 107
 108     progressGroup = va_arg (ap, int);
 109     progressMax = max = va_arg (ap, int);
 110     progressCurr = 0;
 111     if (max > 0xffff) {
 112         progressScale = (double)0xffff / max;
 113         max = 0xffff;
 114     }
 115     else progressScale = 1;
 116     pb = GetDlgItem (dialog, IDC_PB0 + progressGroup * 2);
 117     SendMessage (pb, PBM_SETRANGE, 0, MAKELPARAM (0, max));
 118     SendMessage (pb, PBM_SETSTEP, (WPARAM)1, 0);
 119     return 0;
 120 }
 121
 122 /* report (R_STEP, fmt, ...) */
 123 int
 124 textStep (va_list ap)
 125 {
 126     char *str = vstrmake (NULL, ap);
 127
 128     progressCurr++;
 129     fputs (str, stderr);
 130     fprintf (stderr, " (%d of %d)\n", progressCurr, progressMax);
 131     free (str);
 132     return 0;
 133 }
 134
 135 int
 136 guiStep (va_list ap)
 137 {
 138     const int pgID = IDC_ST0 + progressGroup * 2;
 139     char *str = vstrmake (NULL, ap);
 140
 141     progressCurr++;
 142     SetDlgItemText (dialog, pgID, str);
 143     SendDlgItemMessage (dialog, pgID+1, PBM_SETPOS,
 144                         (WPARAM)(progressScale * progressCurr), 0);
 145     free (str);
 146     return 0;
 147 }
 148
 149 /* report (R_DELTA, inc, fmt, ...) */
 150 int
 151 textDelta (va_list ap)
 152 {
 153     const int inc = va_arg (ap, int);
 154     char *str = vstrmake (NULL, ap);
 155
 156     progressCurr += inc;
 157     fputs (str, stderr);
 158     fprintf (stderr, " (%d of %d)\n", progressCurr, progressMax);
 159     free (str);
 160     return 0;
 161 }
 162
 163 int
 164 guiDelta (va_list ap)
 165 {
 166     const int inc = va_arg (ap, int);
 167     const int pgID = IDC_ST0 + progressGroup * 2;
 168     char *str = vstrmake (NULL, ap);
 169
 170     progressCurr += inc;
 171     SetDlgItemText (dialog, pgID, str);
 172     SendDlgItemMessage (dialog, pgID+1, PBM_SETPOS,
 173                         (WPARAM)(progressScale * progressCurr), 0);
 174     free (str);
 175     return 0;
 176 }
 177
 178 /* report (R_DIR, fmt, ...) */
 179 int
 180 textDir (va_list ap)
 181 {
 182     char *str = vstrmake (NULL, ap);
 183
 184     fputs ("Temporary directory: ", stderr);
 185     fputs (str, stderr);
 186     fputc ('\n', stderr);
 187     free (str);
 188     return 0;
 189 }
 190
 191 int
 192 guiDir (va_list ap)
 193 {
 194     char *str = vstrmake (NULL, ap);
 195
 196     SetDlgItemText (dialog, IDC_DIR, str);
 197     free (str);
 198     return 0;
 199 }
 200
 201 /* report (R_OUT, fmt, ...) */
 202 int
 203 textOut (va_list ap)
 204 {
 205     char *str = vstrmake (NULL, ap);
 206
 207     fputs ("Log file: ", stderr);
 208     fputs (str, stderr);
 209     fputc ('\n', stderr);
 210     free (str);
 211     return 0;
 212 }
 213
 214 int
 215 guiOut (va_list ap)
 216 {
 217     char *str = vstrmake (NULL, ap);
 218
 219     SetDlgItemText (dialog, IDC_OUT, str);
 220     free (str);
 221     return 0;
 222 }
 223
 224 /* report (R_WARNING, fmt, ...) */
 225 int
 226 textWarning (va_list ap)
 227 {
 228     fputs ("Warning: ", stderr);
 229     textStatus (ap);
 230     return 0;
 231 }
 232
 233 int
 234 guiWarning (va_list ap)
 235 {
 236     char *str = vstrmake (NULL, ap);
 237
 238     MessageBox (dialog, str, "Warning", MB_ICONWARNING | MB_OK);
 239     free (str);
 240     return 0;
 241 }
 242
 243 /* report (R_ERROR, fmt, ...) */
 244 int
 245 textError (va_list ap)
 246 {
 247     fputs ("Error: ", stderr);
 248     textStatus (ap);
 249     return 0;
 250 }
 251
 252 int
 253 guiError (va_list ap)
 254 {
 255     char *str = vstrmake (NULL, ap);
 256
 257     MessageBox (dialog, str, "Error", MB_ICONERROR | MB_OK);
 258     free (str);
 259     return 0;
 260 }
 261
 262 /* report (R_FATAL, fmt, ...) */
 263 int
 264 textFatal (va_list ap)
 265 {
 266     textError (ap);
 267     exit (1);
 268 }
 269
 270 int
 271 guiFatal (va_list ap)
 272 {
 273     guiError (ap);
 274     exit (1);
 275 }
 276
 277 /* report (R_ASK, type, fmt, ...) */
 278 int
 279 textAsk (va_list ap)
 280 {
 281     int uType = va_arg (ap, int);
 282     int ret = MBdefault (uType);
 283     char *str = vstrmake (NULL, ap);
 284
 285     fprintf (stderr, "Question of type %d: %s\n"
 286              "Returning default: %d\n", uType, str, ret);
 287     free (str);
 288     return ret;
 289 }
 290
 291 int
 292 guiAsk (va_list ap)
 293 {
 294     int uType = va_arg (ap, int);
 295     char *str = vstrmake (NULL, ap);
 296     int ret = MessageBox (dialog, str, "Question",
 297                           MB_ICONQUESTION | uType);
 298
 299     free (str);
 300     return ret;
 301 }
 302
 303 /* Quiet functions */
 304 int
 305 qNoOp (va_list ap)
 306 {
 307     return 0;
 308 }
 309
 310 int
 311 qFatal (va_list ap)
 312 {
 313     exit (1);
 314 }
 315
 316 int
 317 qAsk (va_list ap)
 318 {
 319     return MBdefault (va_arg (ap, int));
 320 }
 321
 322 BOOL CALLBACK
 323 AboutProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 324 {
 325     switch (msg) {
 326     case WM_COMMAND:
 327         switch (LOWORD (wParam)) {
 328         case IDCANCEL:
 329             EndDialog (hwnd, IDCANCEL);
 330             return TRUE;
 331         }
 332     }
 333     return FALSE;
 334 }
 335
 336 BOOL CALLBACK
 337 DlgProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 338 {
 339     switch (msg) {
 340     case WM_INITDIALOG:
 341         SendMessage (hwnd, WM_SETICON, ICON_SMALL,
 342                      (LPARAM)LoadIcon (GetModuleHandle (NULL),
 343                                        MAKEINTRESOURCE (IDI_WINE)));
 344         SendMessage (hwnd, WM_SETICON, ICON_BIG,
 345                      (LPARAM)LoadIcon (GetModuleHandle (NULL),
 346                                        MAKEINTRESOURCE (IDI_WINE)));
 347         dialog = hwnd;
 348         if (!SetEvent (initEvent)) {
 349             report (R_STATUS, "Can't signal main thread: %d",
 350                     GetLastError ());
 351             EndDialog (hwnd, 2);
 352         }
 353         return TRUE;
 354     case WM_CLOSE:
 355         EndDialog (hwnd, 3);
 356         return TRUE;
 357     case WM_COMMAND:
 358         switch (LOWORD (wParam)) {
 359         case IDHELP:
 360             DialogBox (GetModuleHandle (NULL),
 361                        MAKEINTRESOURCE (IDD_ABOUT), hwnd, AboutProc);
 362             return TRUE;
 363         case IDABORT:
 364             report (R_WARNING, "Not implemented");
 365             return TRUE;
 366         }
 367     }
 368     return FALSE;
 369 }
 370
 371 DWORD WINAPI
 372 DlgThreadProc ()
 373 {
 374     int ret;
 375
 376     InitCommonControls ();
 377     ret = DialogBox (GetModuleHandle (NULL),
 378                      MAKEINTRESOURCE (IDD_STATUS),
 379                      NULL, DlgProc);
 380     switch (ret) {
 381     case 0:
 382         report (R_WARNING, "Invalid parent handle");
 383         break;
 384     case 1:
 385         report (R_WARNING, "DialogBox failed: %d",
 386                 GetLastError ());
 387         break;
 388     case 3:
 389         exit (0);
 390     default:
 391         report (R_STATUS, "Dialog exited: %d", ret);
 392     }
 393     return 0;
 394 }
 395
 396 int
 397 report (enum report_type t, ...)
 398 {
 399     typedef int r_fun_t (va_list);
 400
 401     va_list ap;
 402     int ret = 0;
 403     static r_fun_t * const text_funcs[] =
 404         {textStatus, textProgress, textStep, textDelta,
 405          textDir, textOut, textFatal, textWarning, textAsk};
 406     static r_fun_t * const GUI_funcs[] =
 407         {guiStatus, guiProgress, guiStep, guiDelta,
 408          guiDir, guiOut, guiFatal, guiWarning, guiAsk};
 409     static r_fun_t * const quiet_funcs[] =
 410         {qNoOp, qNoOp, qNoOp, qNoOp,
 411          qNoOp, qNoOp, qFatal, qNoOp, qAsk};
 412     static r_fun_t * const * funcs = NULL;
 413
 414     switch (t) {
 415     case R_TEXTMODE:
 416         funcs = text_funcs;
 417         return 0;
 418     case R_QUIET:
 419         funcs = quiet_funcs;
 420         return 0;
 421     default:
 422         break;
 423     }
 424
 425     if (!funcs) {
 426         HANDLE DlgThread;
 427         DWORD DlgThreadID;
 428
 429         funcs = text_funcs;
 430         initEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
 431         if (!initEvent)
 432             report (R_STATUS, "Can't create event object: %d",
 433                     GetLastError ());
 434         else {
 435             DlgThread = CreateThread (NULL, 0, DlgThreadProc,
 436                                       NULL, 0, &DlgThreadID);
 437             if (!DlgThread)
 438                 report (R_STATUS, "Can't create GUI thread: %d",
 439                         GetLastError ());
 440             else {
 441                 DWORD ret = WaitForSingleObject (initEvent, INFINITE);
 442                 switch (ret) {
 443                 case WAIT_OBJECT_0:
 444                     funcs = GUI_funcs;
 445                     break;
 446                 case WAIT_TIMEOUT:
 447                     report (R_STATUS, "GUI creation timed out");
 448                     break;
 449                 case WAIT_FAILED:
 450                     report (R_STATUS, "Wait for GUI failed: %d",
 451                             GetLastError ());
 452                     break;
 453                 default:
 454                     report (R_STATUS, "Wait returned %d",
 455                             ret);
 456                     break;
 457                 }
 458             }
 459         }
 460     }
 461
 462     va_start (ap, t);
 463     if (t < sizeof text_funcs / sizeof text_funcs[0] &&
 464         t < sizeof GUI_funcs / sizeof GUI_funcs[0] &&
 465         t >= 0) ret = funcs[t](ap);
 466     else report (R_WARNING, "unimplemented report type: %d", t);
 467     va_end (ap);
 468     return ret;
 469 }