dlls/msi/dialog.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2005 Mike McCormack for CodeWeavers
   5  * Copyright 2005 Aric Stewart for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define COBJMACROS
  23
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "winuser.h"
  30 #include "winnls.h"
  31 #include "msi.h"
  32 #include "msidefs.h"
  33 #include "ocidl.h"
  34 #include "olectl.h"
  35 #include "richedit.h"
  36 #include "commctrl.h"
  37 #include "winreg.h"
  38 #include "shlwapi.h"
  39 #include "shellapi.h"
  40
  41 #include "wine/debug.h"
  42
  43 #include "msipriv.h"
  44 #include "msiserver.h"
  45 #include "resource.h"
  46
  47 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  48
  49 extern HINSTANCE msi_hInstance;
  50
  51 struct control
  52 {
  53     struct list entry;
  54     HWND hwnd;
  55     UINT (*handler)( msi_dialog *, struct control *, WPARAM );
  56     void (*update)( msi_dialog *, struct control * );
  57     LPWSTR property;
  58     LPWSTR value;
  59     HBITMAP hBitmap;
  60     HICON hIcon;
  61     HIMAGELIST hImageList;
  62     LPWSTR tabnext;
  63     LPWSTR type;
  64     HMODULE hDll;
  65     float progress_current;
  66     float progress_max;
  67     BOOL  progress_backwards;
  68     DWORD attributes;
  69     WCHAR name[1];
  70 };
  71
  72 struct font
  73 {
  74     struct list entry;
  75     HFONT hfont;
  76     COLORREF color;
  77     WCHAR name[1];
  78 };
  79
  80 struct msi_dialog_tag
  81 {
  82     MSIPACKAGE *package;
  83     msi_dialog *parent;
  84     UINT (*event_handler)( msi_dialog *, const WCHAR *, const WCHAR * );
  85     BOOL finished;
  86     INT scale;
  87     DWORD attributes;
  88     SIZE size;
  89     HWND hwnd;
  90     LPWSTR default_font;
  91     struct list fonts;
  92     struct list controls;
  93     HWND hWndFocus;
  94     LPWSTR control_default;
  95     LPWSTR control_cancel;
  96     UINT (*pending_event)( msi_dialog *, const WCHAR * );
  97     LPWSTR pending_argument;
  98     INT retval;
  99     WCHAR name[1];
 100 };
 101
 102 struct subscriber
 103 {
 104     struct list entry;
 105     msi_dialog *dialog;
 106     WCHAR      *event;
 107     WCHAR      *control;
 108     WCHAR      *attribute;
 109 };
 110
 111 struct control_handler
 112 {
 113     LPCWSTR control_type;
 114     UINT (*func)( msi_dialog *dialog, MSIRECORD *rec );
 115 };
 116
 117 struct radio_button_group_descr
 118 {
 119     msi_dialog *dialog;
 120     struct control *parent;
 121     WCHAR *propval;
 122 };
 123
 124 /* dialog sequencing */
 125
 126 #define WM_MSI_DIALOG_CREATE  (WM_USER+0x100)
 127 #define WM_MSI_DIALOG_DESTROY (WM_USER+0x101)
 128
 129 #define USER_INSTALLSTATE_ALL 0x1000
 130
 131 static DWORD uiThreadId;
 132 static HWND hMsiHiddenWindow;
 133
 134 static WCHAR *get_window_text( HWND hwnd )
 135 {
 136     UINT sz, r;
 137     WCHAR *buf, *new_buf;
 138
 139     sz = 0x20;
 140     buf = malloc( sz * sizeof(WCHAR) );
 141     while ( buf )
 142     {
 143         r = GetWindowTextW( hwnd, buf, sz );
 144         if ( r < (sz - 1) )
 145             break;
 146         sz *= 2;
 147         new_buf = realloc( buf, sz * sizeof(WCHAR) );
 148         if ( !new_buf )
 149             free( buf );
 150         buf = new_buf;
 151     }
 152
 153     return buf;
 154 }
 155
 156 static INT dialog_scale_unit( msi_dialog *dialog, INT val )
 157 {
 158     return MulDiv( val, dialog->scale, 12 );
 159 }
 160
 161 static struct control *dialog_find_control( msi_dialog *dialog, const WCHAR *name )
 162 {
 163     struct control *control;
 164
 165     if( !name )
 166         return NULL;
 167     if( !dialog->hwnd )
 168         return NULL;
 169     LIST_FOR_EACH_ENTRY( control, &dialog->controls, struct control, entry )
 170         if( !wcscmp( control->name, name ) ) /* FIXME: case sensitive? */
 171             return control;
 172     return NULL;
 173 }
 174
 175 static struct control *dialog_find_control_by_type( msi_dialog *dialog, const WCHAR *type )
 176 {
 177     struct control *control;
 178
 179     if( !type )
 180         return NULL;
 181     if( !dialog->hwnd )
 182         return NULL;
 183     LIST_FOR_EACH_ENTRY( control, &dialog->controls, struct control, entry )
 184         if( !wcscmp( control->type, type ) ) /* FIXME: case sensitive? */
 185             return control;
 186     return NULL;
 187 }
 188
 189 static struct control *dialog_find_control_by_hwnd( msi_dialog *dialog, HWND hwnd )
 190 {
 191     struct control *control;
 192
 193     if( !dialog->hwnd )
 194         return NULL;
 195     LIST_FOR_EACH_ENTRY( control, &dialog->controls, struct control, entry )
 196         if( hwnd == control->hwnd )
 197             return control;
 198     return NULL;
 199 }
 200
 201 static WCHAR *get_deformatted_field( MSIPACKAGE *package, MSIRECORD *rec, int field )
 202 {
 203     LPCWSTR str = MSI_RecordGetString( rec, field );
 204     LPWSTR ret = NULL;
 205
 206     if (str)
 207         deformat_string( package, str, &ret );
 208     return ret;
 209 }
 210
 211 static WCHAR *dialog_dup_property( msi_dialog *dialog, const WCHAR *property, BOOL indirect )
 212 {
 213     LPWSTR prop = NULL;
 214
 215     if (!property)
 216         return NULL;
 217
 218     if (indirect)
 219         prop = msi_dup_property( dialog->package->db, property );
 220
 221     if (!prop)
 222         prop = wcsdup( property );
 223
 224     return prop;
 225 }
 226
 227 /*
 228  * dialog_get_style
 229  *
 230  * Extract the {\style} string from the front of the text to display and
 231  * update the pointer.  Only the last style in a list is applied.
 232  */
 233 static WCHAR *dialog_get_style( const WCHAR *p, const WCHAR **rest )
 234 {
 235     LPWSTR ret;
 236     LPCWSTR q, i, first;
 237     DWORD len;
 238
 239     q = NULL;
 240     *rest = p;
 241     if( !p )
 242         return NULL;
 243
 244     while ((first = wcschr( p, '{' )) && (q = wcschr( first + 1, '}' )))
 245     {
 246         p = first + 1;
 247         if( *p != '\\' && *p != '&' )
 248             return NULL;
 249
 250         /* little bit of sanity checking to stop us getting confused with RTF */
 251         for( i=++p; i<q; i++ )
 252             if( *i == '}' || *i == '\\' )
 253                 return NULL;
 254     }
 255
 256     if (!q)
 257         return NULL;
 258
 259     *rest = ++q;
 260     len = q - p;
 261
 262     ret = malloc( len * sizeof(WCHAR) );
 263     if( !ret )
 264         return ret;
 265     memcpy( ret, p, len*sizeof(WCHAR) );
 266     ret[len-1] = 0;
 267     return ret;
 268 }
 269
 270 static UINT dialog_add_font( MSIRECORD *rec, void *param )
 271 {
 272     msi_dialog *dialog = param;
 273     struct font *font;
 274     LPCWSTR face, name;
 275     LOGFONTW lf;
 276     INT style;
 277     HDC hdc;
 278
 279     /* create a font and add it to the list */
 280     name = MSI_RecordGetString( rec, 1 );
 281     font = malloc( offsetof( struct font, name[wcslen( name ) + 1] ) );
 282     lstrcpyW( font->name, name );
 283     list_add_head( &dialog->fonts, &font->entry );
 284
 285     font->color = MSI_RecordGetInteger( rec, 4 );
 286
 287     memset( &lf, 0, sizeof lf );
 288     face = MSI_RecordGetString( rec, 2 );
 289     lf.lfHeight = MSI_RecordGetInteger( rec, 3 );
 290     style = MSI_RecordGetInteger( rec, 5 );
 291     if( style & msidbTextStyleStyleBitsBold )
 292         lf.lfWeight = FW_BOLD;
 293     if( style & msidbTextStyleStyleBitsItalic )
 294         lf.lfItalic = TRUE;
 295     if( style & msidbTextStyleStyleBitsUnderline )
 296         lf.lfUnderline = TRUE;
 297     if( style & msidbTextStyleStyleBitsStrike )
 298         lf.lfStrikeOut = TRUE;
 299     lstrcpynW( lf.lfFaceName, face, LF_FACESIZE );
 300
 301     /* adjust the height */
 302     hdc = GetDC( dialog->hwnd );
 303     if (hdc)
 304     {
 305         lf.lfHeight = -MulDiv(lf.lfHeight, GetDeviceCaps(hdc, LOGPIXELSY), 72);
 306         ReleaseDC( dialog->hwnd, hdc );
 307     }
 308
 309     font->hfont = CreateFontIndirectW( &lf );
 310
 311     TRACE("Adding font style %s\n", debugstr_w(font->name) );
 312
 313     return ERROR_SUCCESS;
 314 }
 315
 316 static struct font *dialog_find_font( msi_dialog *dialog, const WCHAR *name )
 317 {
 318     struct font *font = NULL;
 319
 320     LIST_FOR_EACH_ENTRY( font, &dialog->fonts, struct font, entry )
 321         if( !wcscmp( font->name, name ) )  /* FIXME: case sensitive? */
 322             break;
 323
 324     return font;
 325 }
 326
 327 static UINT dialog_set_font( msi_dialog *dialog, HWND hwnd, const WCHAR *name )
 328 {
 329     struct font *font;
 330
 331     font = dialog_find_font( dialog, name );
 332     if( font )
 333         SendMessageW( hwnd, WM_SETFONT, (WPARAM) font->hfont, TRUE );
 334     else
 335         ERR("No font entry for %s\n", debugstr_w(name));
 336     return ERROR_SUCCESS;
 337 }
 338
 339 static UINT dialog_build_font_list( msi_dialog *dialog )
 340 {
 341     MSIQUERY *view;
 342     UINT r;
 343
 344     TRACE("dialog %p\n", dialog );
 345
 346     r = MSI_OpenQuery( dialog->package->db, &view, L"SELECT * FROM `TextStyle`" );
 347     if( r != ERROR_SUCCESS )
 348         return r;
 349
 350     r = MSI_IterateRecords( view, NULL, dialog_add_font, dialog );
 351     msiobj_release( &view->hdr );
 352     return r;
 353 }
 354
 355 static void destroy_control( struct control *t )
 356 {
 357     list_remove( &t->entry );
 358     /* leave dialog->hwnd - destroying parent destroys child windows */
 359     free( t->property );
 360     free( t->value );
 361     if( t->hBitmap )
 362         DeleteObject( t->hBitmap );
 363     if( t->hIcon )
 364         DestroyIcon( t->hIcon );
 365     if ( t->hImageList )
 366         ImageList_Destroy( t->hImageList );
 367     free( t->tabnext );
 368     free( t->type );
 369     if (t->hDll)
 370         FreeLibrary( t->hDll );
 371     free( t );
 372 }
 373
 374 static struct control *dialog_create_window( msi_dialog *dialog, MSIRECORD *rec, DWORD exstyle,
 375                                              const WCHAR *szCls, const WCHAR *name, const WCHAR *text,
 376                                              DWORD style, HWND parent )
 377 {
 378     DWORD x, y, width, height;
 379     LPWSTR font = NULL, title_font = NULL;
 380     LPCWSTR title = NULL;
 381     struct control *control;
 382
 383     style |= WS_CHILD;
 384
 385     control = malloc( offsetof( struct control, name[wcslen( name ) + 1] ) );
 386     if (!control)
 387         return NULL;
 388
 389     lstrcpyW( control->name, name );
 390     list_add_tail( &dialog->controls, &control->entry );
 391     control->handler = NULL;
 392     control->update = NULL;
 393     control->property = NULL;
 394     control->value = NULL;
 395     control->hBitmap = NULL;
 396     control->hIcon = NULL;
 397     control->hImageList = NULL;
 398     control->hDll = NULL;
 399     control->tabnext = wcsdup( MSI_RecordGetString( rec, 11 ) );
 400     control->type = wcsdup( MSI_RecordGetString( rec, 3 ) );
 401     control->progress_current = 0;
 402     control->progress_max = 100;
 403     control->progress_backwards = FALSE;
 404
 405     x = MSI_RecordGetInteger( rec, 4 );
 406     y = MSI_RecordGetInteger( rec, 5 );
 407     width = MSI_RecordGetInteger( rec, 6 );
 408     height = MSI_RecordGetInteger( rec, 7 );
 409
 410     x = dialog_scale_unit( dialog, x );
 411     y = dialog_scale_unit( dialog, y );
 412     width = dialog_scale_unit( dialog, width );
 413     height = dialog_scale_unit( dialog, height );
 414
 415     if( text )
 416     {
 417         deformat_string( dialog->package, text, &title_font );
 418         font = dialog_get_style( title_font, &title );
 419     }
 420
 421     if (!wcsicmp( MSI_RecordGetString( rec, 3 ), L"Line" ))
 422         height = 2; /* line is exactly 2 units in height */
 423
 424     control->hwnd = CreateWindowExW( exstyle, szCls, title, style,
 425                           x, y, width, height, parent, NULL, NULL, NULL );
 426
 427     TRACE("Dialog %s control %s hwnd %p\n",
 428            debugstr_w(dialog->name), debugstr_w(text), control->hwnd );
 429
 430     dialog_set_font( dialog, control->hwnd, font ? font : dialog->default_font );
 431
 432     free( title_font );
 433     free( font );
 434
 435     return control;
 436 }
 437
 438 static WCHAR *dialog_get_uitext( msi_dialog *dialog, const WCHAR *key )
 439 {
 440     MSIRECORD *rec;
 441     LPWSTR text;
 442
 443     rec = MSI_QueryGetRecord( dialog->package->db, L"SELECT * FROM `UIText` WHERE `Key` = '%s'", key );
 444     if (!rec) return NULL;
 445     text = wcsdup( MSI_RecordGetString( rec, 2 ) );
 446     msiobj_release( &rec->hdr );
 447     return text;
 448 }
 449
 450 static HANDLE load_image( MSIDATABASE *db, const WCHAR *name, UINT type, UINT cx, UINT cy, UINT flags )
 451 {
 452     MSIRECORD *rec;
 453     HANDLE himage = NULL;
 454     LPWSTR tmp;
 455     UINT r;
 456
 457     TRACE("%p %s %u %u %08x\n", db, debugstr_w(name), cx, cy, flags);
 458
 459     if (!(tmp = msi_create_temp_file( db ))) return NULL;
 460
 461     rec = MSI_QueryGetRecord( db, L"SELECT * FROM `Binary` WHERE `Name` = '%s'", name );
 462     if( rec )
 463     {
 464         r = MSI_RecordStreamToFile( rec, 2, tmp );
 465         if( r == ERROR_SUCCESS )
 466         {
 467             himage = LoadImageW( 0, tmp, type, cx, cy, flags );
 468         }
 469         msiobj_release( &rec->hdr );
 470     }
 471     DeleteFileW( tmp );
 472
 473     free( tmp );
 474     return himage;
 475 }
 476
 477 static HICON load_icon( MSIDATABASE *db, const WCHAR *text, UINT attributes )
 478 {
 479     DWORD cx = 0, cy = 0, flags;
 480
 481     flags = LR_LOADFROMFILE | LR_DEFAULTSIZE;
 482     if( attributes & msidbControlAttributesFixedSize )
 483     {
 484         flags &= ~LR_DEFAULTSIZE;
 485         if( attributes & msidbControlAttributesIconSize16 )
 486         {
 487             cx += 16;
 488             cy += 16;
 489         }
 490         if( attributes & msidbControlAttributesIconSize32 )
 491         {
 492             cx += 32;
 493             cy += 32;
 494         }
 495         /* msidbControlAttributesIconSize48 handled by above logic */
 496     }
 497     return load_image( db, text, IMAGE_ICON, cx, cy, flags );
 498 }
 499
 500 static void dialog_update_controls( msi_dialog *dialog, const WCHAR *property )
 501 {
 502     struct control *control;
 503
 504     LIST_FOR_EACH_ENTRY( control, &dialog->controls, struct control, entry )
 505     {
 506         if ( control->property && !wcscmp( control->property, property ) && control->update )
 507             control->update( dialog, control );
 508     }
 509 }
 510
 511 static void dialog_update_all_controls( msi_dialog *dialog )
 512 {
 513     struct control *control;
 514
 515     LIST_FOR_EACH_ENTRY( control, &dialog->controls, struct control, entry )
 516     {
 517         if ( control->property && control->update )
 518             control->update( dialog, control );
 519     }
 520 }
 521
 522 static void dialog_set_property( MSIPACKAGE *package, const WCHAR *property, const WCHAR *value )
 523 {
 524     UINT r = msi_set_property( package->db, property, value, -1 );
 525     if (r == ERROR_SUCCESS && !wcscmp( property, L"SourceDir" ))
 526         msi_reset_source_folders( package );
 527 }
 528
 529 static MSIFEATURE *seltree_feature_from_item( HWND hwnd, HTREEITEM hItem )
 530 {
 531     TVITEMW tvi;
 532
 533     /* get the feature from the item */
 534     memset( &tvi, 0, sizeof tvi );
 535     tvi.hItem = hItem;
 536     tvi.mask = TVIF_PARAM | TVIF_HANDLE;
 537     SendMessageW( hwnd, TVM_GETITEMW, 0, (LPARAM)&tvi );
 538     return (MSIFEATURE *)tvi.lParam;
 539 }
 540
 541 struct msi_selection_tree_info
 542 {
 543     msi_dialog *dialog;
 544     HWND hwnd;
 545     WNDPROC oldproc;
 546     HTREEITEM selected;
 547 };
 548
 549 static MSIFEATURE *seltree_get_selected_feature( struct control *control )
 550 {
 551     struct msi_selection_tree_info *info = GetPropW( control->hwnd, L"MSIDATA" );
 552     return seltree_feature_from_item( control->hwnd, info->selected );
 553 }
 554
 555 static void dialog_handle_event( msi_dialog *dialog, const WCHAR *control, const WCHAR *attribute, MSIRECORD *rec )
 556 {
 557     struct control* ctrl;
 558
 559     ctrl = dialog_find_control( dialog, control );
 560     if (!ctrl)
 561         return;
 562     if( !wcscmp( attribute, L"Text" ) )
 563     {
 564         const WCHAR *font_text, *text = NULL;
 565         WCHAR *font, *text_fmt = NULL;
 566
 567         font_text = MSI_RecordGetString( rec , 1 );
 568         font = dialog_get_style( font_text, &text );
 569         deformat_string( dialog->package, text, &text_fmt );
 570         if (text_fmt) text = text_fmt;
 571         else text = L"";
 572
 573         SetWindowTextW( ctrl->hwnd, text );
 574
 575         free( font );
 576         free( text_fmt );
 577         msi_dialog_check_messages( NULL );
 578     }
 579     else if( !wcscmp( attribute, L"Progress" ) )
 580     {
 581         DWORD func, val1, val2, units;
 582
 583         func = MSI_RecordGetInteger( rec, 1 );
 584         val1 = MSI_RecordGetInteger( rec, 2 );
 585         val2 = MSI_RecordGetInteger( rec, 3 );
 586
 587         TRACE( "progress: func %lu val1 %lu val2 %lu\n", func, val1, val2 );
 588
 589         units = val1 / 512;
 590         switch (func)
 591         {
 592         case 0: /* init */
 593             SendMessageW( ctrl->hwnd, PBM_SETRANGE, 0, MAKELPARAM(0,100) );
 594             if (val2)
 595             {
 596                 ctrl->progress_max = units ? units : 100;
 597                 ctrl->progress_current = units;
 598                 ctrl->progress_backwards = TRUE;
 599                 SendMessageW( ctrl->hwnd, PBM_SETPOS, 100, 0 );
 600             }
 601             else
 602             {
 603                 ctrl->progress_max = units ? units : 100;
 604                 ctrl->progress_current = 0;
 605                 ctrl->progress_backwards = FALSE;
 606                 SendMessageW( ctrl->hwnd, PBM_SETPOS, 0, 0 );
 607             }
 608             break;
 609         case 1: /* action data increment */
 610             if (val2) dialog->package->action_progress_increment = val1;
 611             else dialog->package->action_progress_increment = 0;
 612             break;
 613         case 2: /* move */
 614             if (ctrl->progress_backwards)
 615             {
 616                 if (units >= ctrl->progress_current) ctrl->progress_current -= units;
 617                 else ctrl->progress_current = 0;
 618             }
 619             else
 620             {
 621                 if (ctrl->progress_current + units < ctrl->progress_max) ctrl->progress_current += units;
 622                 else ctrl->progress_current = ctrl->progress_max;
 623             }
 624             SendMessageW( ctrl->hwnd, PBM_SETPOS, MulDiv(100, ctrl->progress_current, ctrl->progress_max), 0 );
 625             break;
 626         case 3: /* add */
 627             ctrl->progress_max += units;
 628             break;
 629         default:
 630             FIXME( "unknown progress message %lu\n", func );
 631             break;
 632         }
 633     }
 634     else if ( !wcscmp( attribute, L"Property" ) )
 635     {
 636         MSIFEATURE *feature = seltree_get_selected_feature( ctrl );
 637         if (feature) dialog_set_property( dialog->package, ctrl->property, feature->Directory );
 638     }
 639     else if ( !wcscmp( attribute, L"SelectionPath" ) )
 640     {
 641         BOOL indirect = ctrl->attributes & msidbControlAttributesIndirect;
 642         WCHAR *path = dialog_dup_property( dialog, ctrl->property, indirect );
 643         if (!path) return;
 644         SetWindowTextW( ctrl->hwnd, path );
 645         free( path );
 646     }
 647     else
 648     {
 649         FIXME("Attribute %s not being set\n", debugstr_w(attribute));
 650         return;
 651     }
 652 }
 653
 654 static void event_subscribe( msi_dialog *dialog, const WCHAR *event, const WCHAR *control, const WCHAR *attribute )
 655 {
 656     struct subscriber *sub;
 657
 658     TRACE("dialog %s event %s control %s attribute %s\n", debugstr_w(dialog->name), debugstr_w(event),
 659           debugstr_w(control), debugstr_w(attribute));
 660
 661     LIST_FOR_EACH_ENTRY( sub, &dialog->package->subscriptions, struct subscriber, entry )
 662     {
 663         if (sub->dialog == dialog &&
 664             !wcsicmp( sub->event, event ) &&
 665             !wcsicmp( sub->control, control ) &&
 666             !wcsicmp( sub->attribute, attribute ))
 667         {
 668             TRACE("already subscribed\n");
 669             return;
 670         };
 671     }
 672     if (!(sub = malloc( sizeof(*sub) ))) return;
 673     sub->dialog    = dialog;
 674     sub->event     = wcsdup( event );
 675     sub->control   = wcsdup( control );
 676     sub->attribute = wcsdup( attribute );
 677     list_add_tail( &dialog->package->subscriptions, &sub->entry );
 678 }
 679
 680 struct dialog_control
 681 {
 682     msi_dialog  *dialog;
 683     const WCHAR *control;
 684 };
 685
 686 static UINT map_event( MSIRECORD *row, void *param )
 687 {
 688     struct dialog_control *dc = param;
 689     const WCHAR *event = MSI_RecordGetString( row, 3 );
 690     const WCHAR *attribute = MSI_RecordGetString( row, 4 );
 691
 692     event_subscribe( dc->dialog, event, dc->control, attribute );
 693     return ERROR_SUCCESS;
 694 }
 695
 696 static void dialog_map_events( msi_dialog *dialog, const WCHAR *control )
 697 {
 698     MSIQUERY *view;
 699     struct dialog_control dialog_control =
 700     {
 701         dialog,
 702         control
 703     };
 704
 705     if (!MSI_OpenQuery( dialog->package->db, &view,
 706                         L"SELECT * FROM `EventMapping` WHERE `Dialog_` = '%s' AND `Control_` = '%s'",
 707                         dialog->name, control ))
 708     {
 709         MSI_IterateRecords( view, NULL, map_event, &dialog_control );
 710         msiobj_release( &view->hdr );
 711     }
 712 }
 713
 714 /* everything except radio buttons */
 715 static struct control *dialog_add_control( msi_dialog *dialog, MSIRECORD *rec, const WCHAR *szCls, DWORD style )
 716 {
 717     DWORD attributes;
 718     const WCHAR *text = NULL, *name, *control_type;
 719     DWORD exstyle = 0;
 720
 721     name = MSI_RecordGetString( rec, 2 );
 722     control_type = MSI_RecordGetString( rec, 3 );
 723     attributes = MSI_RecordGetInteger( rec, 8 );
 724     if (wcscmp( control_type, L"ScrollableText" )) text = MSI_RecordGetString( rec, 10 );
 725
 726     TRACE( "%s, %s, %#lx, %s, %#lx\n", debugstr_w(szCls), debugstr_w(name), attributes, debugstr_w(text), style );
 727
 728     if( attributes & msidbControlAttributesVisible )
 729         style |= WS_VISIBLE;
 730     if( ~attributes & msidbControlAttributesEnabled )
 731         style |= WS_DISABLED;
 732     if( attributes & msidbControlAttributesSunken )
 733         exstyle |= WS_EX_CLIENTEDGE;
 734
 735     dialog_map_events( dialog, name );
 736
 737     return dialog_create_window( dialog, rec, exstyle, szCls, name, text, style, dialog->hwnd );
 738 }
 739
 740 struct msi_text_info
 741 {
 742     struct font *font;
 743     WNDPROC oldproc;
 744     DWORD attributes;
 745 };
 746
 747 /*
 748  * we don't erase our own background,
 749  * so we have to make sure that the parent window redraws first
 750  */
 751 static void text_on_settext( HWND hWnd )
 752 {
 753     HWND hParent;
 754     RECT rc;
 755
 756     hParent = GetParent( hWnd );
 757     GetWindowRect( hWnd, &rc );
 758     MapWindowPoints( NULL, hParent, (LPPOINT) &rc, 2 );
 759     InvalidateRect( hParent, &rc, TRUE );
 760 }
 761
 762 static LRESULT WINAPI MSIText_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 763 {
 764     struct msi_text_info *info;
 765     LRESULT r = 0;
 766
 767     TRACE( "%p %04x %#Ix %#Ix\n", hWnd, msg, wParam, lParam );
 768
 769     info = GetPropW(hWnd, L"MSIDATA");
 770
 771     if( msg == WM_CTLCOLORSTATIC &&
 772        ( info->attributes & msidbControlAttributesTransparent ) )
 773     {
 774         SetBkMode( (HDC)wParam, TRANSPARENT );
 775         return (LRESULT) GetStockObject(NULL_BRUSH);
 776     }
 777
 778     r = CallWindowProcW(info->oldproc, hWnd, msg, wParam, lParam);
 779     if ( info->font )
 780         SetTextColor( (HDC)wParam, info->font->color );
 781
 782     switch( msg )
 783     {
 784     case WM_SETTEXT:
 785         text_on_settext( hWnd );
 786         break;
 787     case WM_NCDESTROY:
 788         free( info );
 789         RemovePropW( hWnd, L"MSIDATA" );
 790         break;
 791     }
 792
 793     return r;
 794 }
 795
 796 static UINT dialog_text_control( msi_dialog *dialog, MSIRECORD *rec )
 797 {
 798     struct control *control;
 799     struct msi_text_info *info;
 800     LPCWSTR text, ptr, prop, control_name;
 801     LPWSTR font_name;
 802
 803     TRACE("%p %p\n", dialog, rec);
 804
 805     control = dialog_add_control( dialog, rec, L"Static", SS_LEFT | WS_GROUP );
 806     if( !control )
 807         return ERROR_FUNCTION_FAILED;
 808
 809     info = malloc( sizeof *info );
 810     if( !info )
 811         return ERROR_SUCCESS;
 812
 813     control_name = MSI_RecordGetString( rec, 2 );
 814     control->attributes = MSI_RecordGetInteger( rec, 8 );
 815     prop = MSI_RecordGetString( rec, 9 );
 816     control->property = dialog_dup_property( dialog, prop, FALSE );
 817
 818     text = MSI_RecordGetString( rec, 10 );
 819     font_name = dialog_get_style( text, &ptr );
 820     info->font = ( font_name ) ? dialog_find_font( dialog, font_name ) : NULL;
 821     free( font_name );
 822
 823     info->attributes = MSI_RecordGetInteger( rec, 8 );
 824     if( info->attributes & msidbControlAttributesTransparent )
 825         SetWindowLongPtrW( control->hwnd, GWL_EXSTYLE, WS_EX_TRANSPARENT );
 826
 827     info->oldproc = (WNDPROC) SetWindowLongPtrW( control->hwnd, GWLP_WNDPROC,
 828                                           (LONG_PTR)MSIText_WndProc );
 829     SetPropW( control->hwnd, L"MSIDATA", info );
 830
 831     event_subscribe( dialog, L"SelectionPath", control_name, L"SelectionPath" );
 832     return ERROR_SUCCESS;
 833 }
 834
 835 /* strip any leading text style label from text field */
 836 static WCHAR *get_binary_name( MSIPACKAGE *package, MSIRECORD *rec )
 837 {
 838     WCHAR *p, *text;
 839
 840     text = get_deformatted_field( package, rec, 10 );
 841     if (!text)
 842         return NULL;
 843
 844     p = text;
 845     while (*p && *p != '{') p++;
 846     if (!*p++) return text;
 847
 848     while (*p && *p != '}') p++;
 849     if (!*p++) return text;
 850
 851     p = wcsdup( p );
 852     free( text );
 853     return p;
 854 }
 855
 856 static UINT dialog_set_property_event( msi_dialog *dialog, const WCHAR *event, const WCHAR *arg )
 857 {
 858     LPWSTR p, prop, arg_fmt = NULL;
 859     UINT len;
 860
 861     len = lstrlenW( event );
 862     prop = malloc( len * sizeof(WCHAR) );
 863     lstrcpyW( prop, &event[1] );
 864     p = wcschr( prop, ']' );
 865     if (p && (p[1] == 0 || p[1] == ' '))
 866     {
 867         *p = 0;
 868         if (wcscmp( L"{}", arg )) deformat_string( dialog->package, arg, &arg_fmt );
 869         dialog_set_property( dialog->package, prop, arg_fmt );
 870         dialog_update_controls( dialog, prop );
 871         free( arg_fmt );
 872     }
 873     else ERR("Badly formatted property string - what happens?\n");
 874     free( prop );
 875     return ERROR_SUCCESS;
 876 }
 877
 878 static UINT dialog_send_event( msi_dialog *dialog, const WCHAR *event, const WCHAR *arg )
 879 {
 880     LPWSTR event_fmt = NULL, arg_fmt = NULL;
 881
 882     TRACE("Sending control event %s %s\n", debugstr_w(event), debugstr_w(arg));
 883
 884     deformat_string( dialog->package, event, &event_fmt );
 885     deformat_string( dialog->package, arg, &arg_fmt );
 886
 887     dialog->event_handler( dialog, event_fmt, arg_fmt );
 888
 889     free( event_fmt );
 890     free( arg_fmt );
 891
 892     return ERROR_SUCCESS;
 893 }
 894
 895 static UINT dialog_control_event( MSIRECORD *rec, void *param )
 896 {
 897     msi_dialog *dialog = param;
 898     LPCWSTR condition, event, arg;
 899     UINT r;
 900
 901     condition = MSI_RecordGetString( rec, 5 );
 902     r = MSI_EvaluateConditionW( dialog->package, condition );
 903     if (r == MSICONDITION_TRUE || r == MSICONDITION_NONE)
 904     {
 905         event = MSI_RecordGetString( rec, 3 );
 906         arg = MSI_RecordGetString( rec, 4 );
 907         if (event[0] == '[')
 908             dialog_set_property_event( dialog, event, arg );
 909         else
 910             dialog_send_event( dialog, event, arg );
 911     }
 912     return ERROR_SUCCESS;
 913 }
 914
 915 static UINT dialog_button_handler( msi_dialog *dialog, struct control *control, WPARAM param )
 916 {
 917     MSIQUERY *view;
 918     UINT r;
 919
 920     if (HIWORD(param) != BN_CLICKED)
 921         return ERROR_SUCCESS;
 922
 923     r = MSI_OpenQuery( dialog->package->db, &view,
 924                        L"SELECT * FROM `ControlEvent` WHERE `Dialog_` = '%s' AND `Control_` = '%s' ORDER BY `Ordering`",
 925                        dialog->name, control->name );
 926     if (r != ERROR_SUCCESS)
 927     {
 928         ERR("query failed\n");
 929         return ERROR_SUCCESS;
 930     }
 931     r = MSI_IterateRecords( view, 0, dialog_control_event, dialog );
 932     msiobj_release( &view->hdr );
 933
 934     /* dialog control events must be processed last regardless of ordering */
 935     if (dialog->pending_event)
 936     {
 937         r = dialog->pending_event( dialog, dialog->pending_argument );
 938
 939         free( dialog->pending_argument );
 940         dialog->pending_event = NULL;
 941         dialog->pending_argument = NULL;
 942     }
 943     return r;
 944 }
 945
 946 static HBITMAP load_picture( MSIDATABASE *db, const WCHAR *name, INT cx, INT cy, DWORD flags )
 947 {
 948     HBITMAP hOleBitmap = 0, hBitmap = 0, hOldSrcBitmap, hOldDestBitmap;
 949     MSIRECORD *rec = NULL;
 950     IStream *stm = NULL;
 951     IPicture *pic = NULL;
 952     HDC srcdc, destdc;
 953     BITMAP bm;
 954     UINT r;
 955
 956     rec = MSI_QueryGetRecord( db, L"SELECT * FROM `Binary` WHERE `Name` = '%s'", name );
 957     if (!rec)
 958         goto end;
 959
 960     r = MSI_RecordGetIStream( rec, 2, &stm );
 961     msiobj_release( &rec->hdr );
 962     if (r != ERROR_SUCCESS)
 963         goto end;
 964
 965     r = OleLoadPicture( stm, 0, TRUE, &IID_IPicture, (void **)&pic );
 966     IStream_Release( stm );
 967     if (FAILED( r ))
 968     {
 969         ERR("failed to load picture\n");
 970         goto end;
 971     }
 972
 973     r = IPicture_get_Handle( pic, (OLE_HANDLE *)&hOleBitmap );
 974     if (FAILED( r ))
 975     {
 976         ERR("failed to get bitmap handle\n");
 977         goto end;
 978     }
 979
 980     /* make the bitmap the desired size */
 981     r = GetObjectW( hOleBitmap, sizeof(bm), &bm );
 982     if (r != sizeof(bm))
 983     {
 984         ERR("failed to get bitmap size\n");
 985         goto end;
 986     }
 987
 988     if (flags & LR_DEFAULTSIZE)
 989     {
 990         cx = bm.bmWidth;
 991         cy = bm.bmHeight;
 992     }
 993
 994     srcdc = CreateCompatibleDC( NULL );
 995     hOldSrcBitmap = SelectObject( srcdc, hOleBitmap );
 996     destdc = CreateCompatibleDC( NULL );
 997     hBitmap = CreateCompatibleBitmap( srcdc, cx, cy );
 998     hOldDestBitmap = SelectObject( destdc, hBitmap );
 999     StretchBlt( destdc, 0, 0, cx, cy, srcdc, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY );
1000     SelectObject( srcdc, hOldSrcBitmap );
1001     SelectObject( destdc, hOldDestBitmap );
1002     DeleteDC( srcdc );
1003     DeleteDC( destdc );
1004
1005 end:
1006     if (pic) IPicture_Release( pic );
1007     return hBitmap;
1008 }
1009
1010 static UINT dialog_button_control( msi_dialog *dialog, MSIRECORD *rec )
1011 {
1012     struct control *control;
1013     UINT attributes, style, cx = 0, cy = 0, flags = 0;
1014     WCHAR *name = NULL;
1015
1016     TRACE("%p %p\n", dialog, rec);
1017
1018     style = WS_TABSTOP;
1019     attributes = MSI_RecordGetInteger( rec, 8 );
1020     if (attributes & msidbControlAttributesIcon) style |= BS_ICON;
1021     else if (attributes & msidbControlAttributesBitmap)
1022     {
1023         style |= BS_BITMAP;
1024         if (attributes & msidbControlAttributesFixedSize) flags |= LR_DEFAULTSIZE;
1025         else
1026         {
1027             cx = dialog_scale_unit( dialog, MSI_RecordGetInteger(rec, 6) );
1028             cy = dialog_scale_unit( dialog, MSI_RecordGetInteger(rec, 7) );
1029         }
1030     }
1031
1032     control = dialog_add_control( dialog, rec, L"BUTTON", style );
1033     if (!control)
1034         return ERROR_FUNCTION_FAILED;
1035
1036     control->handler = dialog_button_handler;
1037
1038     if (attributes & msidbControlAttributesIcon)
1039     {
1040         name = get_binary_name( dialog->package, rec );
1041         control->hIcon = load_icon( dialog->package->db, name, attributes );
1042         if (control->hIcon)
1043         {
1044             SendMessageW( control->hwnd, BM_SETIMAGE, IMAGE_ICON, (LPARAM) control->hIcon );
1045         }
1046         else ERR("Failed to load icon %s\n", debugstr_w(name));
1047     }
1048     else if (attributes & msidbControlAttributesBitmap)
1049     {
1050         name = get_binary_name( dialog->package, rec );
1051         control->hBitmap = load_picture( dialog->package->db, name, cx, cy, flags );
1052         if (control->hBitmap)
1053         {
1054             SendMessageW( control->hwnd, BM_SETIMAGE, IMAGE_BITMAP, (LPARAM) control->hBitmap );
1055         }
1056         else ERR("Failed to load bitmap %s\n", debugstr_w(name));
1057     }
1058
1059     free( name );
1060     return ERROR_SUCCESS;
1061 }
1062
1063 static WCHAR *get_checkbox_value( msi_dialog *dialog, const WCHAR *prop )
1064 {
1065     MSIRECORD *rec = NULL;
1066     LPWSTR ret = NULL;
1067
1068     /* find if there is a value associated with the checkbox */
1069     rec = MSI_QueryGetRecord( dialog->package->db, L"SELECT * FROM `CheckBox` WHERE `Property` = '%s'", prop );
1070     if (!rec)
1071         return ret;
1072
1073     ret = get_deformatted_field( dialog->package, rec, 2 );
1074     if( ret && !ret[0] )
1075     {
1076         free( ret );
1077         ret = NULL;
1078     }
1079     msiobj_release( &rec->hdr );
1080     if (ret)
1081         return ret;
1082
1083     ret = msi_dup_property( dialog->package->db, prop );
1084     if( ret && !ret[0] )
1085     {
1086         free( ret );
1087         ret = NULL;
1088     }
1089
1090     return ret;
1091 }
1092
1093 static UINT dialog_get_checkbox_state( msi_dialog *dialog, struct control *control )
1094 {
1095     WCHAR state[2] = {0};
1096     DWORD sz = 2;
1097
1098     msi_get_property( dialog->package->db, control->property, state, &sz );
1099     return state[0] ? 1 : 0;
1100 }
1101
1102 static void dialog_set_checkbox_state( msi_dialog *dialog, struct control *control, UINT state )
1103 {
1104     LPCWSTR val;
1105
1106     /* if uncheck then the property is set to NULL */
1107     if (!state)
1108     {
1109         dialog_set_property( dialog->package, control->property, NULL );
1110         return;
1111     }
1112
1113     /* check for a custom state */
1114     if (control->value && control->value[0])
1115         val = control->value;
1116     else
1117         val = L"1";
1118
1119     dialog_set_property( dialog->package, control->property, val );
1120 }
1121
1122 static void dialog_checkbox_sync_state( msi_dialog *dialog, struct control *control )
1123 {
1124     UINT state = dialog_get_checkbox_state( dialog, control );
1125     SendMessageW( control->hwnd, BM_SETCHECK, state ? BST_CHECKED : BST_UNCHECKED, 0 );
1126 }
1127
1128 static UINT dialog_checkbox_handler( msi_dialog *dialog, struct control *control, WPARAM param )
1129 {
1130     UINT state;
1131
1132     if (HIWORD(param) != BN_CLICKED)
1133         return ERROR_SUCCESS;
1134
1135     TRACE("clicked checkbox %s, set %s\n", debugstr_w(control->name), debugstr_w(control->property));
1136
1137     state = dialog_get_checkbox_state( dialog, control );
1138     state = state ? 0 : 1;
1139     dialog_set_checkbox_state( dialog, control, state );
1140     dialog_checkbox_sync_state( dialog, control );
1141
1142     return dialog_button_handler( dialog, control, param );
1143 }
1144
1145 static UINT dialog_checkbox_control( msi_dialog *dialog, MSIRECORD *rec )
1146 {
1147     struct control *control;
1148     LPCWSTR prop;
1149
1150     TRACE("%p %p\n", dialog, rec);
1151
1152     control = dialog_add_control( dialog, rec, L"BUTTON", BS_CHECKBOX | BS_MULTILINE | WS_TABSTOP );
1153     control->handler = dialog_checkbox_handler;
1154     control->update = dialog_checkbox_sync_state;
1155     prop = MSI_RecordGetString( rec, 9 );
1156     if (prop)
1157     {
1158         control->property = wcsdup( prop );
1159         control->value = get_checkbox_value( dialog, prop );
1160         TRACE("control %s value %s\n", debugstr_w(control->property), debugstr_w(control->value));
1161     }
1162     dialog_checkbox_sync_state( dialog, control );
1163     return ERROR_SUCCESS;
1164 }
1165
1166 static UINT dialog_line_control( msi_dialog *dialog, MSIRECORD *rec )
1167 {
1168     if (!dialog_add_control( dialog, rec, L"Static", SS_ETCHEDHORZ | SS_SUNKEN))
1169         return ERROR_FUNCTION_FAILED;
1170
1171     return ERROR_SUCCESS;
1172 }
1173
1174 /******************** Scroll Text ********************************************/
1175
1176 struct msi_scrolltext_info
1177 {
1178     msi_dialog *dialog;
1179     struct control *control;
1180     WNDPROC oldproc;
1181 };
1182
1183 static LRESULT WINAPI MSIScrollText_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1184 {
1185     struct msi_scrolltext_info *info;
1186     HRESULT r;
1187
1188     TRACE( "%p %04x %#Ix %#Ix\n", hWnd, msg, wParam, lParam );
1189
1190     info = GetPropW( hWnd, L"MSIDATA" );
1191
1192     r = CallWindowProcW( info->oldproc, hWnd, msg, wParam, lParam );
1193
1194     switch( msg )
1195     {
1196     case WM_GETDLGCODE:
1197         return DLGC_WANTARROWS;
1198     case WM_NCDESTROY:
1199         free( info );
1200         RemovePropW( hWnd, L"MSIDATA" );
1201         break;
1202     case WM_PAINT:
1203         /* native MSI sets a wait cursor here */
1204         dialog_button_handler( info->dialog, info->control, BN_CLICKED );
1205         break;
1206     }
1207     return r;
1208 }
1209
1210 struct msi_streamin_info
1211 {
1212     LPSTR string;
1213     DWORD offset;
1214     DWORD length;
1215 };
1216
1217 static DWORD CALLBACK richedit_stream_in( DWORD_PTR arg, BYTE *buffer, LONG count, LONG *pcb )
1218 {
1219     struct msi_streamin_info *info = (struct msi_streamin_info*) arg;
1220
1221     if( (count + info->offset) > info->length )
1222         count = info->length - info->offset;
1223     memcpy( buffer, &info->string[ info->offset ], count );
1224     *pcb = count;
1225     info->offset += count;
1226
1227     TRACE( "%lu/%lu\n", info->offset, info->length );
1228
1229     return 0;
1230 }
1231
1232 static void scrolltext_add_text( struct control *control, const WCHAR *text )
1233 {
1234     struct msi_streamin_info info;
1235     EDITSTREAM es;
1236
1237     info.string = strdupWtoA( text );
1238     info.offset = 0;
1239     info.length = lstrlenA( info.string ) + 1;
1240
1241     es.dwCookie = (DWORD_PTR) &info;
1242     es.dwError = 0;
1243     es.pfnCallback = richedit_stream_in;
1244
1245     SendMessageW( control->hwnd, EM_STREAMIN, SF_RTF, (LPARAM) &es );
1246
1247     free( info.string );
1248 }
1249
1250 static UINT dialog_scrolltext_control( msi_dialog *dialog, MSIRECORD *rec )
1251 {
1252     struct msi_scrolltext_info *info;
1253     struct control *control;
1254     HMODULE hRichedit;
1255     LPCWSTR text;
1256     DWORD style;
1257
1258     info = malloc( sizeof *info );
1259     if (!info)
1260         return ERROR_FUNCTION_FAILED;
1261
1262     hRichedit = LoadLibraryA("riched20");
1263
1264     style = WS_BORDER | ES_MULTILINE | WS_VSCROLL |
1265             ES_READONLY | ES_AUTOVSCROLL | WS_TABSTOP;
1266     control = dialog_add_control( dialog, rec, L"RichEdit20W", style );
1267     if (!control)
1268     {
1269         FreeLibrary( hRichedit );
1270         free( info );
1271         return ERROR_FUNCTION_FAILED;
1272     }
1273
1274     control->hDll = hRichedit;
1275
1276     info->dialog = dialog;
1277     info->control = control;
1278
1279     /* subclass the static control */
1280     info->oldproc = (WNDPROC) SetWindowLongPtrW( control->hwnd, GWLP_WNDPROC,
1281                                           (LONG_PTR)MSIScrollText_WndProc );
1282     SetPropW( control->hwnd, L"MSIDATA", info );
1283
1284     /* add the text into the richedit */
1285     text = MSI_RecordGetString( rec, 10 );
1286     if (text)
1287         scrolltext_add_text( control, text );
1288
1289     return ERROR_SUCCESS;
1290 }
1291
1292
1293 static UINT dialog_bitmap_control( msi_dialog *dialog, MSIRECORD *rec )
1294 {
1295     UINT cx, cy, flags, style, attributes;
1296     struct control *control;
1297     LPWSTR name;
1298
1299     flags = LR_LOADFROMFILE;
1300     style = SS_BITMAP | SS_LEFT | WS_GROUP;
1301
1302     attributes = MSI_RecordGetInteger( rec, 8 );
1303     if( attributes & msidbControlAttributesFixedSize )
1304     {
1305         flags |= LR_DEFAULTSIZE;
1306         style |= SS_CENTERIMAGE;
1307     }
1308
1309     control = dialog_add_control( dialog, rec, L"Static", style );
1310     cx = MSI_RecordGetInteger( rec, 6 );
1311     cy = MSI_RecordGetInteger( rec, 7 );
1312     cx = dialog_scale_unit( dialog, cx );
1313     cy = dialog_scale_unit( dialog, cy );
1314
1315     name = get_binary_name( dialog->package, rec );
1316     control->hBitmap = load_picture( dialog->package->db, name, cx, cy, flags );
1317     if( control->hBitmap )
1318         SendMessageW( control->hwnd, STM_SETIMAGE,
1319                       IMAGE_BITMAP, (LPARAM) control->hBitmap );
1320     else
1321         ERR("Failed to load bitmap %s\n", debugstr_w(name));
1322
1323     free( name );
1324
1325     return ERROR_SUCCESS;
1326 }
1327
1328 static UINT dialog_icon_control( msi_dialog *dialog, MSIRECORD *rec )
1329 {
1330     struct control *control;
1331     DWORD attributes;
1332     LPWSTR name;
1333
1334     TRACE("\n");
1335
1336     control = dialog_add_control( dialog, rec, L"Static", SS_ICON | SS_CENTERIMAGE | WS_GROUP );
1337
1338     attributes = MSI_RecordGetInteger( rec, 8 );
1339     name = get_binary_name( dialog->package, rec );
1340     control->hIcon = load_icon( dialog->package->db, name, attributes );
1341     if( control->hIcon )
1342         SendMessageW( control->hwnd, STM_SETICON, (WPARAM) control->hIcon, 0 );
1343     else
1344         ERR("Failed to load bitmap %s\n", debugstr_w(name));
1345     free( name );
1346     return ERROR_SUCCESS;
1347 }
1348
1349 /******************** Combo Box ***************************************/
1350
1351 struct msi_combobox_info
1352 {
1353     msi_dialog *dialog;
1354     HWND hwnd;
1355     WNDPROC oldproc;
1356     DWORD num_items;
1357     DWORD addpos_items;
1358     LPWSTR *items;
1359 };
1360
1361 static LRESULT WINAPI MSIComboBox_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1362 {
1363     struct msi_combobox_info *info;
1364     LRESULT r;
1365     DWORD j;
1366
1367     TRACE( "%p %04x %#Ix %#Ix\n", hWnd, msg, wParam, lParam );
1368
1369     info = GetPropW( hWnd, L"MSIDATA" );
1370     if (!info)
1371         return 0;
1372
1373     r = CallWindowProcW( info->oldproc, hWnd, msg, wParam, lParam );
1374
1375     switch (msg)
1376     {
1377     case WM_NCDESTROY:
1378         for (j = 0; j < info->num_items; j++)
1379             free( info->items[j] );
1380         free( info->items );
1381         free( info );
1382         RemovePropW( hWnd, L"MSIDATA" );
1383         break;
1384     }
1385
1386     return r;
1387 }
1388
1389 static UINT combobox_add_item( MSIRECORD *rec, void *param )
1390 {
1391     struct msi_combobox_info *info = param;
1392     LPCWSTR value, text;
1393     int pos;
1394
1395     value = MSI_RecordGetString( rec, 3 );
1396     text = MSI_RecordGetString( rec, 4 );
1397
1398     info->items[info->addpos_items] = wcsdup( value );
1399
1400     pos = SendMessageW( info->hwnd, CB_ADDSTRING, 0, (LPARAM)text );
1401     SendMessageW( info->hwnd, CB_SETITEMDATA, pos, (LPARAM)info->items[info->addpos_items] );
1402     info->addpos_items++;
1403
1404     return ERROR_SUCCESS;
1405 }
1406
1407 static UINT combobox_add_items( struct msi_combobox_info *info, const WCHAR *property )
1408 {
1409     MSIQUERY *view;
1410     DWORD count;
1411     UINT r;
1412
1413     r = MSI_OpenQuery( info->dialog->package->db, &view,
1414                        L"SELECT * FROM `ComboBox` WHERE `Property` = '%s' ORDER BY `Order`", property );
1415     if (r != ERROR_SUCCESS)
1416         return r;
1417
1418     /* just get the number of records */
1419     count = 0;
1420     r = MSI_IterateRecords( view, &count, NULL, NULL );
1421     if (r != ERROR_SUCCESS)
1422     {
1423         msiobj_release( &view->hdr );
1424         return r;
1425     }
1426     info->num_items = count;
1427     info->items = malloc( sizeof(*info->items) * count );
1428
1429     r = MSI_IterateRecords( view, NULL, combobox_add_item, info );
1430     msiobj_release( &view->hdr );
1431     return r;
1432 }
1433
1434 static UINT dialog_set_control_condition( MSIRECORD *rec, void *param )
1435 {
1436     msi_dialog *dialog = param;
1437     struct control *control;
1438     LPCWSTR name, action, condition;
1439     UINT r;
1440
1441     name = MSI_RecordGetString( rec, 2 );
1442     action = MSI_RecordGetString( rec, 3 );
1443     condition = MSI_RecordGetString( rec, 4 );
1444     r = MSI_EvaluateConditionW( dialog->package, condition );
1445     control = dialog_find_control( dialog, name );
1446     if (r == MSICONDITION_TRUE && control)
1447     {
1448         TRACE("%s control %s\n", debugstr_w(action), debugstr_w(name));
1449
1450         /* FIXME: case sensitive? */
1451         if (!wcscmp( action, L"Hide" ))
1452             ShowWindow(control->hwnd, SW_HIDE);
1453         else if (!wcscmp( action, L"Show" ))
1454             ShowWindow(control->hwnd, SW_SHOW);
1455         else if (!wcscmp( action, L"Disable" ))
1456             EnableWindow(control->hwnd, FALSE);
1457         else if (!wcscmp( action, L"Enable" ))
1458             EnableWindow(control->hwnd, TRUE);
1459         else if (!wcscmp( action, L"Default" ))
1460             SetFocus(control->hwnd);
1461         else
1462             FIXME("Unhandled action %s\n", debugstr_w(action));
1463     }
1464     return ERROR_SUCCESS;
1465 }
1466
1467 static UINT dialog_evaluate_control_conditions( msi_dialog *dialog )
1468 {
1469     UINT r;
1470     MSIQUERY *view;
1471     MSIPACKAGE *package = dialog->package;
1472
1473     TRACE("%p %s\n", dialog, debugstr_w(dialog->name));
1474
1475     /* query the Control table for all the elements of the control */
1476     r = MSI_OpenQuery( package->db, &view, L"SELECT * FROM `ControlCondition` WHERE `Dialog_` = '%s'", dialog->name );
1477     if (r != ERROR_SUCCESS)
1478         return ERROR_SUCCESS;
1479
1480     r = MSI_IterateRecords( view, 0, dialog_set_control_condition, dialog );
1481     msiobj_release( &view->hdr );
1482     return r;
1483 }
1484
1485 static UINT dialog_combobox_handler( msi_dialog *dialog, struct control *control, WPARAM param )
1486 {
1487     struct msi_combobox_info *info;
1488     int index;
1489     LPWSTR value;
1490
1491     if (HIWORD(param) != CBN_SELCHANGE && HIWORD(param) != CBN_EDITCHANGE)
1492         return ERROR_SUCCESS;
1493
1494     info = GetPropW( control->hwnd, L"MSIDATA" );
1495     index = SendMessageW( control->hwnd, CB_GETCURSEL, 0, 0 );
1496     if (index == CB_ERR)
1497         value = get_window_text( control->hwnd );
1498     else
1499         value = (LPWSTR) SendMessageW( control->hwnd, CB_GETITEMDATA, index, 0 );
1500
1501     dialog_set_property( info->dialog->package, control->property, value );
1502     dialog_evaluate_control_conditions( info->dialog );
1503
1504     if (index == CB_ERR)
1505         free( value );
1506
1507     return ERROR_SUCCESS;
1508 }
1509
1510 static void dialog_combobox_update( msi_dialog *dialog, struct control *control )
1511 {
1512     struct msi_combobox_info *info;
1513     LPWSTR value, tmp;
1514     DWORD j;
1515
1516     info = GetPropW( control->hwnd, L"MSIDATA" );
1517
1518     value = msi_dup_property( dialog->package->db, control->property );
1519     if (!value)
1520     {
1521         SendMessageW( control->hwnd, CB_SETCURSEL, -1, 0 );
1522         return;
1523     }
1524
1525     for (j = 0; j < info->num_items; j++)
1526     {
1527         tmp = (LPWSTR) SendMessageW( control->hwnd, CB_GETITEMDATA, j, 0 );
1528         if (!wcscmp( value, tmp ))
1529             break;
1530     }
1531
1532     if (j < info->num_items)
1533     {
1534         SendMessageW( control->hwnd, CB_SETCURSEL, j, 0 );
1535     }
1536     else
1537     {
1538         SendMessageW( control->hwnd, CB_SETCURSEL, -1, 0 );
1539         SetWindowTextW( control->hwnd, value );
1540     }
1541
1542     free( value );
1543 }
1544
1545 static UINT dialog_combo_control( msi_dialog *dialog, MSIRECORD *rec )
1546 {
1547     struct msi_combobox_info *info;
1548     struct control *control;
1549     DWORD attributes, style;
1550     LPCWSTR prop;
1551
1552     info = malloc( sizeof *info );
1553     if (!info)
1554         return ERROR_FUNCTION_FAILED;
1555
1556     style = CBS_AUTOHSCROLL | WS_TABSTOP | WS_GROUP | WS_CHILD;
1557     attributes = MSI_RecordGetInteger( rec, 8 );
1558     if ( ~attributes & msidbControlAttributesSorted)
1559         style |= CBS_SORT;
1560     if ( attributes & msidbControlAttributesComboList)
1561         style |= CBS_DROPDOWNLIST;
1562     else
1563         style |= CBS_DROPDOWN;
1564
1565     control = dialog_add_control( dialog, rec, WC_COMBOBOXW, style );
1566     if (!control)
1567     {
1568         free( info );
1569         return ERROR_FUNCTION_FAILED;
1570     }
1571
1572     control->handler = dialog_combobox_handler;
1573     control->update = dialog_combobox_update;
1574
1575     prop = MSI_RecordGetString( rec, 9 );
1576     control->property = dialog_dup_property( dialog, prop, FALSE );
1577
1578     /* subclass */
1579     info->dialog = dialog;
1580     info->hwnd = control->hwnd;
1581     info->items = NULL;
1582     info->addpos_items = 0;
1583     info->oldproc = (WNDPROC)SetWindowLongPtrW( control->hwnd, GWLP_WNDPROC,
1584                                                 (LONG_PTR)MSIComboBox_WndProc );
1585     SetPropW( control->hwnd, L"MSIDATA", info );
1586
1587     if (control->property)
1588         combobox_add_items( info, control->property );
1589
1590     dialog_combobox_update( dialog, control );
1591
1592     return ERROR_SUCCESS;
1593 }
1594
1595 static UINT dialog_edit_handler( msi_dialog *dialog, struct control *control, WPARAM param )
1596 {
1597     LPWSTR buf;
1598
1599     if (HIWORD(param) != EN_CHANGE)
1600         return ERROR_SUCCESS;
1601
1602     TRACE("edit %s contents changed, set %s\n", debugstr_w(control->name), debugstr_w(control->property));
1603
1604     buf = get_window_text( control->hwnd );
1605     dialog_set_property( dialog->package, control->property, buf );
1606     free( buf );
1607
1608     return ERROR_SUCCESS;
1609 }
1610
1611 /* length of 2^32 + 1 */
1612 #define MAX_NUM_DIGITS 11
1613
1614 static UINT dialog_edit_control( msi_dialog *dialog, MSIRECORD *rec )
1615 {
1616     struct control *control;
1617     LPCWSTR prop, text;
1618     LPWSTR val, begin, end;
1619     WCHAR num[MAX_NUM_DIGITS];
1620     DWORD limit;
1621
1622     control = dialog_add_control( dialog, rec, L"Edit", WS_BORDER | WS_TABSTOP | ES_AUTOHSCROLL );
1623     control->handler = dialog_edit_handler;
1624
1625     text = MSI_RecordGetString( rec, 10 );
1626     if ( text )
1627     {
1628         begin = wcschr( text, '{' );
1629         end = wcschr( text, '}' );
1630
1631         if ( begin && end && end > begin &&
1632              begin[0] >= '0' && begin[0] <= '9' &&
1633              end - begin < MAX_NUM_DIGITS)
1634         {
1635             lstrcpynW( num, begin + 1, end - begin );
1636             limit = wcstol( num, NULL, 10 );
1637
1638             SendMessageW( control->hwnd, EM_SETLIMITTEXT, limit, 0 );
1639         }
1640     }
1641
1642     prop = MSI_RecordGetString( rec, 9 );
1643     if( prop )
1644         control->property = wcsdup( prop );
1645
1646     val = msi_dup_property( dialog->package->db, control->property );
1647     SetWindowTextW( control->hwnd, val );
1648     free( val );
1649     return ERROR_SUCCESS;
1650 }
1651
1652 /******************** Masked Edit ********************************************/
1653
1654 #define MASK_MAX_GROUPS 20
1655
1656 struct msi_mask_group
1657 {
1658     UINT len;
1659     UINT ofs;
1660     WCHAR type;
1661     HWND hwnd;
1662 };
1663
1664 struct msi_maskedit_info
1665 {
1666     msi_dialog *dialog;
1667     WNDPROC oldproc;
1668     HWND hwnd;
1669     LPWSTR prop;
1670     UINT num_chars;
1671     UINT num_groups;
1672     struct msi_mask_group group[MASK_MAX_GROUPS];
1673 };
1674
1675 static BOOL mask_editable( WCHAR type )
1676 {
1677     switch (type)
1678     {
1679     case '%':
1680     case '#':
1681     case '&':
1682     case '`':
1683     case '?':
1684     case '^':
1685         return TRUE;
1686     }
1687     return FALSE;
1688 }
1689
1690 static void mask_control_change( struct msi_maskedit_info *info )
1691 {
1692     LPWSTR val;
1693     UINT i, n, r;
1694
1695     val = malloc( (info->num_chars + 1) * sizeof(WCHAR) );
1696     for( i=0, n=0; i<info->num_groups; i++ )
1697     {
1698         if (info->group[i].len == ~0u)
1699         {
1700             UINT len = SendMessageW( info->group[i].hwnd, WM_GETTEXTLENGTH, 0, 0 );
1701             val = realloc( val, (len + 1) * sizeof(WCHAR) );
1702             GetWindowTextW( info->group[i].hwnd, val, len + 1 );
1703         }
1704         else
1705         {
1706             if (info->group[i].len + n > info->num_chars)
1707             {
1708                 ERR("can't fit control %d text into template\n",i);
1709                 break;
1710             }
1711             if (!mask_editable(info->group[i].type))
1712             {
1713                 for(r=0; r<info->group[i].len; r++)
1714                     val[n+r] = info->group[i].type;
1715                 val[n+r] = 0;
1716             }
1717             else
1718             {
1719                 r = GetWindowTextW( info->group[i].hwnd, &val[n], info->group[i].len+1 );
1720                 if( r != info->group[i].len )
1721                     break;
1722             }
1723             n += r;
1724         }
1725     }
1726
1727     TRACE("%d/%d controls were good\n", i, info->num_groups);
1728
1729     if( i == info->num_groups )
1730     {
1731         TRACE("Set property %s to %s\n", debugstr_w(info->prop), debugstr_w(val));
1732         dialog_set_property( info->dialog->package, info->prop, val );
1733         dialog_evaluate_control_conditions( info->dialog );
1734     }
1735     free( val );
1736 }
1737
1738 /* now move to the next control if necessary */
1739 static void mask_next_control( struct msi_maskedit_info *info, HWND hWnd )
1740 {
1741     HWND hWndNext;
1742     UINT len, i;
1743
1744     for( i=0; i<info->num_groups; i++ )
1745         if( info->group[i].hwnd == hWnd )
1746             break;
1747
1748     /* don't move from the last control */
1749     if( i >= (info->num_groups-1) )
1750         return;
1751
1752     len = SendMessageW( hWnd, WM_GETTEXTLENGTH, 0, 0 );
1753     if( len < info->group[i].len )
1754         return;
1755
1756     hWndNext = GetNextDlgTabItem( GetParent( hWnd ), hWnd, FALSE );
1757     SetFocus( hWndNext );
1758 }
1759
1760 static LRESULT WINAPI MSIMaskedEdit_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1761 {
1762     struct msi_maskedit_info *info;
1763     HRESULT r;
1764
1765     TRACE("%p %04x %#Ix %#Ix\n", hWnd, msg, wParam, lParam);
1766
1767     info = GetPropW(hWnd, L"MSIDATA");
1768
1769     r = CallWindowProcW(info->oldproc, hWnd, msg, wParam, lParam);
1770
1771     switch( msg )
1772     {
1773     case WM_COMMAND:
1774         if (HIWORD(wParam) == EN_CHANGE)
1775         {
1776             mask_control_change( info );
1777             mask_next_control( info, (HWND) lParam );
1778         }
1779         break;
1780     case WM_NCDESTROY:
1781         free( info->prop );
1782         free( info );
1783         RemovePropW( hWnd, L"MSIDATA" );
1784         break;
1785     }
1786
1787     return r;
1788 }
1789
1790 /* fish the various bits of the property out and put them in the control */
1791 static void maskedit_set_text( struct msi_maskedit_info *info, const WCHAR *text )
1792 {
1793     LPCWSTR p;
1794     UINT i;
1795
1796     p = text;
1797     for( i = 0; i < info->num_groups; i++ )
1798     {
1799         if( info->group[i].len < lstrlenW( p ) )
1800         {
1801             WCHAR *chunk = wcsdup( p );
1802             chunk[ info->group[i].len ] = 0;
1803             SetWindowTextW( info->group[i].hwnd, chunk );
1804             free( chunk );
1805         }
1806         else
1807         {
1808             SetWindowTextW( info->group[i].hwnd, p );
1809             break;
1810         }
1811         p += info->group[i].len;
1812     }
1813 }
1814
1815 static struct msi_maskedit_info *dialog_parse_groups( const WCHAR *mask )
1816 {
1817     struct msi_maskedit_info *info;
1818     int i = 0, n = 0, total = 0;
1819     LPCWSTR p;
1820
1821     TRACE("masked control, template %s\n", debugstr_w(mask));
1822
1823     if( !mask )
1824         return NULL;
1825
1826     info = calloc( 1, sizeof *info );
1827     if( !info )
1828         return info;
1829
1830     p = wcschr(mask, '<');
1831     if( p )
1832         p++;
1833     else
1834         p = mask;
1835
1836     for( i=0; i<MASK_MAX_GROUPS; i++ )
1837     {
1838         /* stop at the end of the string */
1839         if( p[0] == 0 || p[0] == '>' )
1840         {
1841             if (!total)
1842             {
1843                 /* create a group for the empty mask */
1844                 info->group[0].type = '&';
1845                 info->group[0].len = ~0u;
1846                 i = 1;
1847             }
1848             break;
1849         }
1850
1851         /* count the number of the same identifier */
1852         for( n=0; p[n] == p[0]; n++ )
1853             ;
1854         info->group[i].ofs = total;
1855         info->group[i].type = p[0];
1856         if( p[n] == '=' )
1857         {
1858             n++;
1859             total++; /* an extra not part of the group */
1860         }
1861         info->group[i].len = n;
1862         total += n;
1863         p += n;
1864     }
1865
1866     TRACE("%d characters in %d groups\n", total, i );
1867     if( i == MASK_MAX_GROUPS )
1868         ERR("too many groups in PIDTemplate %s\n", debugstr_w(mask));
1869
1870     info->num_chars = total;
1871     info->num_groups = i;
1872
1873     return info;
1874 }
1875
1876 static void maskedit_create_children( struct msi_maskedit_info *info, const WCHAR *font )
1877 {
1878     DWORD width, height, style, wx, ww;
1879     RECT rect;
1880     HWND hwnd;
1881     UINT i;
1882
1883     style = WS_CHILD | WS_BORDER | WS_VISIBLE | WS_TABSTOP | ES_AUTOHSCROLL;
1884
1885     GetClientRect( info->hwnd, &rect );
1886
1887     width = rect.right - rect.left;
1888     height = rect.bottom - rect.top;
1889
1890     for( i = 0; i < info->num_groups; i++ )
1891     {
1892         if (!mask_editable( info->group[i].type ))
1893             continue;
1894         if (info->num_chars)
1895         {
1896             wx = (info->group[i].ofs * width) / info->num_chars;
1897             ww = (info->group[i].len * width) / info->num_chars;
1898         }
1899         else
1900         {
1901             wx = 0;
1902             ww = width;
1903         }
1904         hwnd = CreateWindowW( L"Edit", NULL, style, wx, 0, ww, height,
1905                               info->hwnd, NULL, NULL, NULL );
1906         if( !hwnd )
1907         {
1908             ERR("failed to create mask edit sub window\n");
1909             break;
1910         }
1911
1912         SendMessageW( hwnd, EM_LIMITTEXT, info->group[i].len, 0 );
1913
1914         dialog_set_font( info->dialog, hwnd, font?font:info->dialog->default_font );
1915         info->group[i].hwnd = hwnd;
1916     }
1917 }
1918
1919 /*
1920  * office 2003 uses "73931<````=````=````=````=`````>@@@@@"
1921  * delphi 7 uses "<????-??????-??????-????>" and "<???-???>"
1922  * filemaker pro 7 uses "<^^^^=^^^^=^^^^=^^^^=^^^^=^^^^=^^^^^>"
1923  */
1924 static UINT dialog_maskedit_control( msi_dialog *dialog, MSIRECORD *rec )
1925 {
1926     LPWSTR font_mask, val = NULL, font;
1927     struct msi_maskedit_info *info = NULL;
1928     UINT ret = ERROR_SUCCESS;
1929     struct control *control;
1930     LPCWSTR prop, mask;
1931
1932     TRACE("\n");
1933
1934     font_mask = get_deformatted_field( dialog->package, rec, 10 );
1935     font = dialog_get_style( font_mask, &mask );
1936     if( !mask )
1937     {
1938         WARN("mask template is empty\n");
1939         goto end;
1940     }
1941
1942     info = dialog_parse_groups( mask );
1943     if( !info )
1944     {
1945         ERR("template %s is invalid\n", debugstr_w(mask));
1946         goto end;
1947     }
1948
1949     info->dialog = dialog;
1950
1951     control = dialog_add_control( dialog, rec, L"Static", SS_OWNERDRAW | WS_GROUP | WS_VISIBLE );
1952     if( !control )
1953     {
1954         ERR("Failed to create maskedit container\n");
1955         ret = ERROR_FUNCTION_FAILED;
1956         goto end;
1957     }
1958     SetWindowLongPtrW( control->hwnd, GWL_EXSTYLE, WS_EX_CONTROLPARENT );
1959
1960     info->hwnd = control->hwnd;
1961
1962     /* subclass the static control */
1963     info->oldproc = (WNDPROC) SetWindowLongPtrW( info->hwnd, GWLP_WNDPROC,
1964                                           (LONG_PTR)MSIMaskedEdit_WndProc );
1965     SetPropW( control->hwnd, L"MSIDATA", info );
1966
1967     prop = MSI_RecordGetString( rec, 9 );
1968     if( prop )
1969         info->prop = wcsdup( prop );
1970
1971     maskedit_create_children( info, font );
1972
1973     if( prop )
1974     {
1975         val = msi_dup_property( dialog->package->db, prop );
1976         if( val )
1977         {
1978             maskedit_set_text( info, val );
1979             free( val );
1980         }
1981     }
1982
1983 end:
1984     if( ret != ERROR_SUCCESS )
1985         free( info );
1986     free( font_mask );
1987     free( font );
1988     return ret;
1989 }
1990
1991 /******************** Progress Bar *****************************************/
1992
1993 static UINT dialog_progress_bar( msi_dialog *dialog, MSIRECORD *rec )
1994 {
1995     struct control *control;
1996     DWORD attributes, style;
1997
1998     style = WS_VISIBLE;
1999     attributes = MSI_RecordGetInteger( rec, 8 );
2000     if( !(attributes & msidbControlAttributesProgress95) )
2001         style |= PBS_SMOOTH;
2002
2003     control = dialog_add_control( dialog, rec, PROGRESS_CLASSW, style );
2004     if( !control )
2005         return ERROR_FUNCTION_FAILED;
2006
2007     event_subscribe( dialog, L"SetProgress", control->name, L"Progress" );
2008     return ERROR_SUCCESS;
2009 }
2010
2011 /******************** Path Edit ********************************************/
2012
2013 struct msi_pathedit_info
2014 {
2015     msi_dialog *dialog;
2016     struct control *control;
2017     WNDPROC oldproc;
2018 };
2019
2020 static WCHAR *get_path_property( msi_dialog *dialog, struct control *control )
2021 {
2022     WCHAR *prop, *path;
2023     BOOL indirect = control->attributes & msidbControlAttributesIndirect;
2024     if (!(prop = dialog_dup_property( dialog, control->property, indirect ))) return NULL;
2025     path = dialog_dup_property( dialog, prop, TRUE );
2026     free( prop );
2027     return path;
2028 }
2029
2030 static void dialog_update_pathedit( msi_dialog *dialog, struct control *control )
2031 {
2032     WCHAR *path;
2033
2034     if (!control && !(control = dialog_find_control_by_type( dialog, L"PathEdit" )))
2035        return;
2036
2037     if (!(path = get_path_property( dialog, control ))) return;
2038     SetWindowTextW( control->hwnd, path );
2039     SendMessageW( control->hwnd, EM_SETSEL, 0, -1 );
2040     free( path );
2041 }
2042
2043 /* FIXME: test when this should fail */
2044 static BOOL dialog_verify_path( const WCHAR *path )
2045 {
2046     if ( !path[0] )
2047         return FALSE;
2048
2049     if ( PathIsRelativeW( path ) )
2050         return FALSE;
2051
2052     return TRUE;
2053 }
2054
2055 /* returns TRUE if the path is valid, FALSE otherwise */
2056 static BOOL dialog_onkillfocus( msi_dialog *dialog, struct control *control )
2057 {
2058     LPWSTR buf, prop;
2059     BOOL indirect;
2060     BOOL valid;
2061
2062     indirect = control->attributes & msidbControlAttributesIndirect;
2063     prop = dialog_dup_property( dialog, control->property, indirect );
2064
2065     buf = get_window_text( control->hwnd );
2066
2067     if ( !dialog_verify_path( buf ) )
2068     {
2069         /* FIXME: display an error message box */
2070         ERR("Invalid path %s\n", debugstr_w( buf ));
2071         valid = FALSE;
2072         SetFocus( control->hwnd );
2073     }
2074     else
2075     {
2076         valid = TRUE;
2077         dialog_set_property( dialog->package, prop, buf );
2078     }
2079
2080     dialog_update_pathedit( dialog, control );
2081
2082     TRACE("edit %s contents changed, set %s\n", debugstr_w(control->name),
2083           debugstr_w(prop));
2084
2085     free( buf );
2086     free( prop );
2087
2088     return valid;
2089 }
2090
2091 static LRESULT WINAPI MSIPathEdit_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
2092 {
2093     struct msi_pathedit_info *info = GetPropW(hWnd, L"MSIDATA");
2094     LRESULT r = 0;
2095
2096     TRACE("%p %04x %#Ix %#Ix\n", hWnd, msg, wParam, lParam);
2097
2098     if ( msg == WM_KILLFOCUS )
2099     {
2100         /* if the path is invalid, don't handle this message */
2101         if ( !dialog_onkillfocus( info->dialog, info->control ) )
2102             return 0;
2103     }
2104
2105     r = CallWindowProcW(info->oldproc, hWnd, msg, wParam, lParam);
2106
2107     if ( msg == WM_NCDESTROY )
2108     {
2109         free( info );
2110         RemovePropW( hWnd, L"MSIDATA" );
2111     }
2112
2113     return r;
2114 }
2115
2116 static UINT dialog_pathedit_control( msi_dialog *dialog, MSIRECORD *rec )
2117 {
2118     struct msi_pathedit_info *info;
2119     struct control *control;
2120     LPCWSTR prop;
2121
2122     info = malloc( sizeof *info );
2123     if (!info)
2124         return ERROR_FUNCTION_FAILED;
2125
2126     control = dialog_add_control( dialog, rec, L"Edit", WS_BORDER | WS_TABSTOP );
2127     control->attributes = MSI_RecordGetInteger( rec, 8 );
2128     prop = MSI_RecordGetString( rec, 9 );
2129     control->property = dialog_dup_property( dialog, prop, FALSE );
2130     control->update = dialog_update_pathedit;
2131
2132     info->dialog = dialog;
2133     info->control = control;
2134     info->oldproc = (WNDPROC) SetWindowLongPtrW( control->hwnd, GWLP_WNDPROC,
2135                                                  (LONG_PTR)MSIPathEdit_WndProc );
2136     SetPropW( control->hwnd, L"MSIDATA", info );
2137
2138     dialog_update_pathedit( dialog, control );
2139
2140     return ERROR_SUCCESS;
2141 }
2142
2143 static UINT dialog_radiogroup_handler( msi_dialog *dialog, struct control *control, WPARAM param )
2144 {
2145     if (HIWORD(param) != BN_CLICKED)
2146         return ERROR_SUCCESS;
2147
2148     TRACE("clicked radio button %s, set %s\n", debugstr_w(control->name), debugstr_w(control->property));
2149
2150     dialog_set_property( dialog->package, control->property, control->name );
2151
2152     return dialog_button_handler( dialog, control, param );
2153 }
2154
2155 /* radio buttons are a bit different from normal controls */
2156 static UINT dialog_create_radiobutton( MSIRECORD *rec, void *param )
2157 {
2158     struct radio_button_group_descr *group = param;
2159     msi_dialog *dialog = group->dialog;
2160     struct control *control;
2161     LPCWSTR prop, text, name;
2162     DWORD style = WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_AUTORADIOBUTTON | BS_MULTILINE;
2163
2164     name = MSI_RecordGetString( rec, 3 );
2165     text = MSI_RecordGetString( rec, 8 );
2166
2167     control = dialog_create_window( dialog, rec, 0, L"BUTTON", name, text, style,
2168                                     group->parent->hwnd );
2169     if (!control)
2170         return ERROR_FUNCTION_FAILED;
2171     control->handler = dialog_radiogroup_handler;
2172
2173     if (group->propval && !wcscmp( control->name, group->propval ))
2174         SendMessageW(control->hwnd, BM_SETCHECK, BST_CHECKED, 0);
2175
2176     prop = MSI_RecordGetString( rec, 1 );
2177     if( prop )
2178         control->property = wcsdup( prop );
2179
2180     return ERROR_SUCCESS;
2181 }
2182
2183 static BOOL CALLBACK radioground_child_enum( HWND hWnd, LPARAM lParam )
2184 {
2185     EnableWindow( hWnd, lParam );
2186     return TRUE;
2187 }
2188
2189 static LRESULT WINAPI MSIRadioGroup_WndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
2190 {
2191     WNDPROC oldproc = (WNDPROC)GetPropW( hWnd, L"MSIDATA" );
2192     LRESULT r;
2193
2194     TRACE( "hWnd %p msg %04x wParam %#Ix lParam %#Ix\n", hWnd, msg, wParam, lParam );
2195
2196     if (msg == WM_COMMAND) /* Forward notifications to dialog */
2197         SendMessageW( GetParent( hWnd ), msg, wParam, lParam );
2198
2199     r = CallWindowProcW( oldproc, hWnd, msg, wParam, lParam );
2200
2201     /* make sure the radio buttons show as disabled if the parent is disabled */
2202     if (msg == WM_ENABLE)
2203         EnumChildWindows( hWnd, radioground_child_enum, wParam );
2204
2205     return r;
2206 }
2207
2208 static UINT dialog_radiogroup_control( msi_dialog *dialog, MSIRECORD *rec )
2209 {
2210     UINT r;
2211     LPCWSTR prop;
2212     struct control *control;
2213     MSIQUERY *view;
2214     struct radio_button_group_descr group;
2215     MSIPACKAGE *package = dialog->package;
2216     WNDPROC oldproc;
2217     DWORD attr, style = WS_GROUP;
2218
2219     prop = MSI_RecordGetString( rec, 9 );
2220
2221     TRACE("%p %p %s\n", dialog, rec, debugstr_w( prop ));
2222
2223     attr = MSI_RecordGetInteger( rec, 8 );
2224     if (attr & msidbControlAttributesVisible)
2225         style |= WS_VISIBLE;
2226     if (~attr & msidbControlAttributesEnabled)
2227         style |= WS_DISABLED;
2228     if (attr & msidbControlAttributesHasBorder)
2229         style |= BS_GROUPBOX;
2230     else
2231         style |= BS_OWNERDRAW;
2232
2233     /* Create parent group box to hold radio buttons */
2234     control = dialog_add_control( dialog, rec, L"BUTTON", style );
2235     if( !control )
2236         return ERROR_FUNCTION_FAILED;
2237
2238     oldproc = (WNDPROC) SetWindowLongPtrW( control->hwnd, GWLP_WNDPROC,
2239                                            (LONG_PTR)MSIRadioGroup_WndProc );
2240     SetPropW(control->hwnd, L"MSIDATA", oldproc);
2241     SetWindowLongPtrW( control->hwnd, GWL_EXSTYLE, WS_EX_CONTROLPARENT );
2242
2243     if( prop )
2244         control->property = wcsdup( prop );
2245
2246     /* query the Radio Button table for all control in this group */
2247     r = MSI_OpenQuery( package->db, &view, L"SELECT * FROM `RadioButton` WHERE `Property` = '%s'", prop );
2248     if( r != ERROR_SUCCESS )
2249     {
2250         ERR("query failed for dialog %s radio group %s\n",
2251             debugstr_w(dialog->name), debugstr_w(prop));
2252         return ERROR_INVALID_PARAMETER;
2253     }
2254
2255     group.dialog = dialog;
2256     group.parent = control;
2257     group.propval = msi_dup_property( dialog->package->db, control->property );
2258
2259     r = MSI_IterateRecords( view, 0, dialog_create_radiobutton, &group );
2260     msiobj_release( &view->hdr );
2261     free( group.propval );
2262     return r;
2263 }
2264
2265 static void seltree_sync_item_state( HWND hwnd, MSIFEATURE *feature, HTREEITEM hItem )
2266 {
2267     TVITEMW tvi;
2268     DWORD index = feature->ActionRequest;
2269
2270     TRACE("Feature %s -> %d %d %d\n", debugstr_w(feature->Title),
2271         feature->Installed, feature->Action, feature->ActionRequest);
2272
2273     if (index == INSTALLSTATE_UNKNOWN)
2274         index = INSTALLSTATE_ABSENT;
2275
2276     tvi.mask = TVIF_STATE;
2277     tvi.hItem = hItem;
2278     tvi.state = INDEXTOSTATEIMAGEMASK( index );
2279     tvi.stateMask = TVIS_STATEIMAGEMASK;
2280
2281     SendMessageW( hwnd, TVM_SETITEMW, 0, (LPARAM) &tvi );
2282 }
2283
2284 static UINT seltree_popup_menu( HWND hwnd, INT x, INT y )
2285 {
2286     HMENU hMenu;
2287     INT r;
2288
2289     /* create a menu to display */
2290     hMenu = CreatePopupMenu();
2291
2292     /* FIXME: load strings from resources */
2293     AppendMenuA( hMenu, MF_ENABLED, INSTALLSTATE_LOCAL, "Install feature locally");
2294     AppendMenuA( hMenu, MF_ENABLED, USER_INSTALLSTATE_ALL, "Install entire feature");
2295     AppendMenuA( hMenu, MF_ENABLED, INSTALLSTATE_ADVERTISED, "Install on demand");
2296     AppendMenuA( hMenu, MF_ENABLED, INSTALLSTATE_ABSENT, "Don't install");
2297     r = TrackPopupMenu( hMenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD,
2298                         x, y, 0, hwnd, NULL );
2299     DestroyMenu( hMenu );
2300     return r;
2301 }
2302
2303 static void seltree_update_feature_installstate( HWND hwnd, HTREEITEM hItem, MSIPACKAGE *package,
2304                                                  MSIFEATURE *feature, INSTALLSTATE state )
2305 {
2306     feature->ActionRequest = state;
2307     seltree_sync_item_state( hwnd, feature, hItem );
2308     ACTION_UpdateComponentStates( package, feature );
2309 }
2310
2311 static void seltree_update_siblings_and_children_installstate( HWND hwnd, HTREEITEM curr, MSIPACKAGE *package,
2312                                                                INSTALLSTATE state )
2313 {
2314     /* update all siblings */
2315     do
2316     {
2317         MSIFEATURE *feature;
2318         HTREEITEM child;
2319
2320         feature = seltree_feature_from_item( hwnd, curr );
2321         seltree_update_feature_installstate( hwnd, curr, package, feature, state );
2322
2323         /* update this sibling's children */
2324         child = (HTREEITEM)SendMessageW( hwnd, TVM_GETNEXTITEM, (WPARAM)TVGN_CHILD, (LPARAM)curr );
2325         if (child)
2326             seltree_update_siblings_and_children_installstate( hwnd, child, package, state );
2327     }
2328     while ((curr = (HTREEITEM)SendMessageW( hwnd, TVM_GETNEXTITEM, (WPARAM)TVGN_NEXT, (LPARAM)curr )));
2329 }
2330
2331 static LRESULT seltree_menu( HWND hwnd, HTREEITEM hItem )
2332 {
2333     struct msi_selection_tree_info *info;
2334     MSIFEATURE *feature;
2335     MSIPACKAGE *package;
2336     union {
2337         RECT rc;
2338         POINT pt[2];
2339         HTREEITEM hItem;
2340     } u;
2341     UINT r;
2342
2343     info = GetPropW(hwnd, L"MSIDATA");
2344     package = info->dialog->package;
2345
2346     feature = seltree_feature_from_item( hwnd, hItem );
2347     if (!feature)
2348     {
2349         ERR("item %p feature was NULL\n", hItem);
2350         return 0;
2351     }
2352
2353     /* get the item's rectangle to put the menu just below it */
2354     u.hItem = hItem;
2355     SendMessageW( hwnd, TVM_GETITEMRECT, 0, (LPARAM) &u.rc );
2356     MapWindowPoints( hwnd, NULL, u.pt, 2 );
2357
2358     r = seltree_popup_menu( hwnd, u.rc.left, u.rc.top );
2359
2360     switch (r)
2361     {
2362     case USER_INSTALLSTATE_ALL:
2363         r = INSTALLSTATE_LOCAL;
2364         /* fall-through */
2365     case INSTALLSTATE_ADVERTISED:
2366     case INSTALLSTATE_ABSENT:
2367         {
2368             HTREEITEM child;
2369             child = (HTREEITEM)SendMessageW( hwnd, TVM_GETNEXTITEM, (WPARAM)TVGN_CHILD, (LPARAM)hItem );
2370             if (child)
2371                 seltree_update_siblings_and_children_installstate( hwnd, child, package, r );
2372         }
2373         /* fall-through */
2374     case INSTALLSTATE_LOCAL:
2375         seltree_update_feature_installstate( hwnd, hItem, package, feature, r );
2376         break;
2377     }
2378
2379     return 0;
2380 }
2381
2382 static LRESULT WINAPI MSISelectionTree_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
2383 {
2384     struct msi_selection_tree_info *info;
2385     TVHITTESTINFO tvhti;
2386     HRESULT r;
2387
2388     TRACE("%p %04x %#Ix %#Ix\n", hWnd, msg, wParam, lParam);
2389
2390     info = GetPropW(hWnd, L"MSIDATA");
2391
2392     switch( msg )
2393     {
2394     case WM_LBUTTONDOWN:
2395         tvhti.pt.x = (short)LOWORD( lParam );
2396         tvhti.pt.y = (short)HIWORD( lParam );
2397         tvhti.flags = 0;
2398         tvhti.hItem = 0;
2399         CallWindowProcW(info->oldproc, hWnd, TVM_HITTEST, 0, (LPARAM) &tvhti );
2400         if (tvhti.flags & TVHT_ONITEMSTATEICON)
2401             return seltree_menu( hWnd, tvhti.hItem );
2402         break;
2403     }
2404     r = CallWindowProcW(info->oldproc, hWnd, msg, wParam, lParam);
2405
2406     switch( msg )
2407     {
2408     case WM_NCDESTROY:
2409         free( info );
2410         RemovePropW( hWnd, L"MSIDATA" );
2411         break;
2412     }
2413     return r;
2414 }
2415
2416 static void seltree_add_child_features( MSIPACKAGE *package, HWND hwnd, const WCHAR *parent, HTREEITEM hParent )
2417 {
2418     struct msi_selection_tree_info *info = GetPropW( hwnd, L"MSIDATA" );
2419     MSIFEATURE *feature;
2420     TVINSERTSTRUCTW tvis;
2421     HTREEITEM hitem, hfirst = NULL;
2422
2423     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2424     {
2425         if ( parent && feature->Feature_Parent && wcscmp( parent, feature->Feature_Parent ))
2426             continue;
2427         else if ( parent && !feature->Feature_Parent )
2428             continue;
2429         else if ( !parent && feature->Feature_Parent )
2430             continue;
2431
2432         if ( !feature->Title )
2433             continue;
2434
2435         if ( !feature->Display )
2436             continue;
2437
2438         memset( &tvis, 0, sizeof tvis );
2439         tvis.hParent = hParent;
2440         tvis.hInsertAfter = TVI_LAST;
2441         tvis.item.mask = TVIF_TEXT | TVIF_PARAM;
2442         tvis.item.pszText = feature->Title;
2443         tvis.item.lParam = (LPARAM) feature;
2444
2445         hitem = (HTREEITEM) SendMessageW( hwnd, TVM_INSERTITEMW, 0, (LPARAM) &tvis );
2446         if (!hitem)
2447             continue;
2448
2449         if (!hfirst)
2450             hfirst = hitem;
2451
2452         seltree_sync_item_state( hwnd, feature, hitem );
2453         seltree_add_child_features( package, hwnd,
2454                                         feature->Feature, hitem );
2455
2456         /* the node is expanded if Display is odd */
2457         if ( feature->Display % 2 != 0 )
2458             SendMessageW( hwnd, TVM_EXPAND, TVE_EXPAND, (LPARAM) hitem );
2459     }
2460
2461     /* select the first item */
2462     SendMessageW( hwnd, TVM_SELECTITEM, TVGN_CARET | TVGN_DROPHILITE, (LPARAM) hfirst );
2463     info->selected = hfirst;
2464 }
2465
2466 static void seltree_create_imagelist( HWND hwnd )
2467 {
2468     const int bm_width = 32, bm_height = 16, bm_count = 3;
2469     const int bm_resource = 0x1001;
2470     HIMAGELIST himl;
2471     int i;
2472     HBITMAP hbmp;
2473
2474     himl = ImageList_Create( bm_width, bm_height, FALSE, 4, 0 );
2475     if (!himl)
2476     {
2477         ERR("failed to create image list\n");
2478         return;
2479     }
2480
2481     for (i=0; i<bm_count; i++)
2482     {
2483         hbmp = LoadBitmapW( msi_hInstance, MAKEINTRESOURCEW(i+bm_resource) );
2484         if (!hbmp)
2485         {
2486             ERR("failed to load bitmap %d\n", i);
2487             break;
2488         }
2489
2490         /*
2491          * Add a dummy bitmap at offset zero because the treeview
2492          * can't use it as a state mask (zero means no user state).
2493          */
2494         if (!i)
2495             ImageList_Add( himl, hbmp, NULL );
2496
2497         ImageList_Add( himl, hbmp, NULL );
2498     }
2499
2500     SendMessageW( hwnd, TVM_SETIMAGELIST, TVSIL_STATE, (LPARAM)himl );
2501 }
2502
2503 static UINT dialog_seltree_handler( msi_dialog *dialog, struct control *control, WPARAM param )
2504 {
2505     struct msi_selection_tree_info *info = GetPropW( control->hwnd, L"MSIDATA" );
2506     LPNMTREEVIEWW tv = (LPNMTREEVIEWW)param;
2507     MSIRECORD *row, *rec;
2508     MSIFOLDER *folder;
2509     MSIFEATURE *feature;
2510     LPCWSTR dir, title = NULL;
2511     UINT r = ERROR_SUCCESS;
2512
2513     if (tv->hdr.code != TVN_SELCHANGINGW)
2514         return ERROR_SUCCESS;
2515
2516     info->selected = tv->itemNew.hItem;
2517
2518     if (!(tv->itemNew.mask & TVIF_TEXT))
2519     {
2520         feature = seltree_feature_from_item( control->hwnd, tv->itemNew.hItem );
2521         if (feature)
2522             title = feature->Title;
2523     }
2524     else
2525         title = tv->itemNew.pszText;
2526
2527     row = MSI_QueryGetRecord( dialog->package->db, L"SELECT * FROM `Feature` WHERE `Title` = '%s'", title );
2528     if (!row)
2529         return ERROR_FUNCTION_FAILED;
2530
2531     rec = MSI_CreateRecord( 1 );
2532
2533     MSI_RecordSetStringW( rec, 1, MSI_RecordGetString( row, 4 ) );
2534     msi_event_fire( dialog->package, L"SelectionDescription", rec );
2535
2536     dir = MSI_RecordGetString( row, 7 );
2537     if (dir)
2538     {
2539         folder = msi_get_loaded_folder( dialog->package, dir );
2540         if (!folder)
2541         {
2542             r = ERROR_FUNCTION_FAILED;
2543             goto done;
2544         }
2545         MSI_RecordSetStringW( rec, 1, folder->ResolvedTarget );
2546     }
2547     else
2548         MSI_RecordSetStringW( rec, 1, NULL );
2549
2550     msi_event_fire( dialog->package, L"SelectionPath", rec );
2551
2552 done:
2553     msiobj_release(&row->hdr);
2554     msiobj_release(&rec->hdr);
2555
2556     return r;
2557 }
2558
2559 static UINT dialog_selection_tree( msi_dialog *dialog, MSIRECORD *rec )
2560 {
2561     struct control *control;
2562     LPCWSTR prop, control_name;
2563     MSIPACKAGE *package = dialog->package;
2564     DWORD style;
2565     struct msi_selection_tree_info *info;
2566
2567     info = malloc( sizeof *info );
2568     if (!info)
2569         return ERROR_FUNCTION_FAILED;
2570
2571     /* create the treeview control */
2572     style = TVS_HASLINES | TVS_HASBUTTONS | TVS_LINESATROOT;
2573     style |= WS_GROUP | WS_VSCROLL | WS_TABSTOP;
2574     control = dialog_add_control( dialog, rec, WC_TREEVIEWW, style );
2575     if (!control)
2576     {
2577         free(info);
2578         return ERROR_FUNCTION_FAILED;
2579     }
2580
2581     control->handler = dialog_seltree_handler;
2582     control_name = MSI_RecordGetString( rec, 2 );
2583     control->attributes = MSI_RecordGetInteger( rec, 8 );
2584     prop = MSI_RecordGetString( rec, 9 );
2585     control->property = dialog_dup_property( dialog, prop, FALSE );
2586
2587     /* subclass */
2588     info->dialog = dialog;
2589     info->hwnd = control->hwnd;
2590     info->oldproc = (WNDPROC) SetWindowLongPtrW( control->hwnd, GWLP_WNDPROC,
2591                                           (LONG_PTR)MSISelectionTree_WndProc );
2592     SetPropW( control->hwnd, L"MSIDATA", info );
2593
2594     event_subscribe( dialog, L"SelectionPath", control_name, L"Property" );
2595
2596     /* initialize it */
2597     seltree_create_imagelist( control->hwnd );
2598     seltree_add_child_features( package, control->hwnd, NULL, NULL );
2599
2600     return ERROR_SUCCESS;
2601 }
2602
2603 /******************** Group Box ***************************************/
2604
2605 static UINT dialog_group_box( msi_dialog *dialog, MSIRECORD *rec )
2606 {
2607     struct control *control;
2608     DWORD style;
2609
2610     style = BS_GROUPBOX | WS_CHILD | WS_GROUP;
2611     control = dialog_add_control( dialog, rec, WC_BUTTONW, style );
2612     if (!control)
2613         return ERROR_FUNCTION_FAILED;
2614
2615     return ERROR_SUCCESS;
2616 }
2617
2618 /******************** List Box ***************************************/
2619
2620 struct msi_listbox_info
2621 {
2622     msi_dialog *dialog;
2623     HWND hwnd;
2624     WNDPROC oldproc;
2625     DWORD num_items;
2626     DWORD addpos_items;
2627     LPWSTR *items;
2628 };
2629
2630 static LRESULT WINAPI MSIListBox_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
2631 {
2632     struct msi_listbox_info *info;
2633     LRESULT r;
2634     DWORD j;
2635
2636     TRACE("%p %04x %#Ix %#Ix\n", hWnd, msg, wParam, lParam);
2637
2638     info = GetPropW( hWnd, L"MSIDATA" );
2639     if (!info)
2640         return 0;
2641
2642     r = CallWindowProcW( info->oldproc, hWnd, msg, wParam, lParam );
2643
2644     switch( msg )
2645     {
2646     case WM_NCDESTROY:
2647         for (j = 0; j < info->num_items; j++)
2648             free( info->items[j] );
2649         free( info->items );
2650         free( info );
2651         RemovePropW( hWnd, L"MSIDATA" );
2652         break;
2653     }
2654
2655     return r;
2656 }
2657
2658 static UINT listbox_add_item( MSIRECORD *rec, void *param )
2659 {
2660     struct msi_listbox_info *info = param;
2661     LPCWSTR value, text;
2662     int pos;
2663
2664     value = MSI_RecordGetString( rec, 3 );
2665     text = MSI_RecordGetString( rec, 4 );
2666
2667     info->items[info->addpos_items] = wcsdup( value );
2668
2669     pos = SendMessageW( info->hwnd, LB_ADDSTRING, 0, (LPARAM)text );
2670     SendMessageW( info->hwnd, LB_SETITEMDATA, pos, (LPARAM)info->items[info->addpos_items] );
2671     info->addpos_items++;
2672     return ERROR_SUCCESS;
2673 }
2674
2675 static UINT listbox_add_items( struct msi_listbox_info *info, const WCHAR *property )
2676 {
2677     MSIQUERY *view;
2678     DWORD count;
2679     UINT r;
2680
2681     r = MSI_OpenQuery( info->dialog->package->db, &view,
2682                        L"SELECT * FROM `ListBox` WHERE `Property` = '%s' ORDER BY `Order`", property );
2683     if ( r != ERROR_SUCCESS )
2684         return r;
2685
2686     /* just get the number of records */
2687     count = 0;
2688     r = MSI_IterateRecords( view, &count, NULL, NULL );
2689     if (r != ERROR_SUCCESS)
2690     {
2691         msiobj_release( &view->hdr );
2692         return r;
2693     }
2694     info->num_items = count;
2695     info->items = malloc( sizeof(*info->items) * count );
2696
2697     r = MSI_IterateRecords( view, NULL, listbox_add_item, info );
2698     msiobj_release( &view->hdr );
2699     return r;
2700 }
2701
2702 static UINT dialog_listbox_handler( msi_dialog *dialog, struct control *control, WPARAM param )
2703 {
2704     struct msi_listbox_info *info;
2705     int index;
2706     LPCWSTR value;
2707
2708     if( HIWORD(param) != LBN_SELCHANGE )
2709         return ERROR_SUCCESS;
2710
2711     info = GetPropW( control->hwnd, L"MSIDATA" );
2712     index = SendMessageW( control->hwnd, LB_GETCURSEL, 0, 0 );
2713     value = (LPCWSTR) SendMessageW( control->hwnd, LB_GETITEMDATA, index, 0 );
2714
2715     dialog_set_property( info->dialog->package, control->property, value );
2716     dialog_evaluate_control_conditions( info->dialog );
2717
2718     return ERROR_SUCCESS;
2719 }
2720
2721 static UINT dialog_list_box( msi_dialog *dialog, MSIRECORD *rec )
2722 {
2723     struct msi_listbox_info *info;
2724     struct control *control;
2725     DWORD attributes, style;
2726     LPCWSTR prop;
2727
2728     info = malloc( sizeof *info );
2729     if (!info)
2730         return ERROR_FUNCTION_FAILED;
2731
2732     style = WS_TABSTOP | WS_GROUP | WS_CHILD | LBS_NOTIFY | WS_VSCROLL | WS_BORDER;
2733     attributes = MSI_RecordGetInteger( rec, 8 );
2734     if (~attributes & msidbControlAttributesSorted)
2735         style |= LBS_SORT;
2736
2737     control = dialog_add_control( dialog, rec, WC_LISTBOXW, style );
2738     if (!control)
2739     {
2740         free(info);
2741         return ERROR_FUNCTION_FAILED;
2742     }
2743
2744     control->handler = dialog_listbox_handler;
2745
2746     prop = MSI_RecordGetString( rec, 9 );
2747     control->property = dialog_dup_property( dialog, prop, FALSE );
2748
2749     /* subclass */
2750     info->dialog = dialog;
2751     info->hwnd = control->hwnd;
2752     info->items = NULL;
2753     info->addpos_items = 0;
2754     info->oldproc = (WNDPROC)SetWindowLongPtrW( control->hwnd, GWLP_WNDPROC,
2755                                                 (LONG_PTR)MSIListBox_WndProc );
2756     SetPropW( control->hwnd, L"MSIDATA", info );
2757
2758     if ( control->property )
2759         listbox_add_items( info, control->property );
2760
2761     return ERROR_SUCCESS;
2762 }
2763
2764 /******************** Directory Combo ***************************************/
2765
2766 static void dialog_update_directory_combo( msi_dialog *dialog, struct control *control )
2767 {
2768     WCHAR *path;
2769
2770     if (!control && !(control = dialog_find_control_by_type( dialog, L"DirectoryCombo" )))
2771         return;
2772
2773     if (!(path = get_path_property( dialog, control ))) return;
2774     PathStripPathW( path );
2775     PathRemoveBackslashW( path );
2776
2777     SendMessageW( control->hwnd, CB_INSERTSTRING, 0, (LPARAM)path );
2778     SendMessageW( control->hwnd, CB_SETCURSEL, 0, 0 );
2779
2780     free( path );
2781 }
2782
2783 static UINT dialog_directory_combo( msi_dialog *dialog, MSIRECORD *rec )
2784 {
2785     struct control *control;
2786     LPCWSTR prop;
2787     DWORD style;
2788
2789     /* FIXME: use CBS_OWNERDRAWFIXED and add owner draw code */
2790     style = CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_CHILD |
2791             WS_GROUP | WS_TABSTOP | WS_VSCROLL;
2792     control = dialog_add_control( dialog, rec, WC_COMBOBOXW, style );
2793     if (!control)
2794         return ERROR_FUNCTION_FAILED;
2795
2796     control->attributes = MSI_RecordGetInteger( rec, 8 );
2797     prop = MSI_RecordGetString( rec, 9 );
2798     control->property = dialog_dup_property( dialog, prop, FALSE );
2799
2800     dialog_update_directory_combo( dialog, control );
2801
2802     return ERROR_SUCCESS;
2803 }
2804
2805 /******************** Directory List ***************************************/
2806
2807 static void dialog_update_directory_list( msi_dialog *dialog, struct control *control )
2808 {
2809     WCHAR dir_spec[MAX_PATH], *path;
2810     WIN32_FIND_DATAW wfd;
2811     LVITEMW item;
2812     HANDLE file;
2813
2814     if (!control && !(control = dialog_find_control_by_type( dialog, L"DirectoryList" )))
2815         return;
2816
2817     /* clear the list-view */
2818     SendMessageW( control->hwnd, LVM_DELETEALLITEMS, 0, 0 );
2819
2820     if (!(path = get_path_property( dialog, control ))) return;
2821     lstrcpyW( dir_spec, path );
2822     lstrcatW( dir_spec, L"*" );
2823
2824     file = FindFirstFileW( dir_spec, &wfd );
2825     if (file == INVALID_HANDLE_VALUE)
2826     {
2827         free( path );
2828         return;
2829     }
2830
2831     do
2832     {
2833         if ( wfd.dwFileAttributes != FILE_ATTRIBUTE_DIRECTORY )
2834             continue;
2835
2836         if ( !wcscmp( wfd.cFileName, L"." ) || !wcscmp( wfd.cFileName, L".." ) )
2837             continue;
2838
2839         item.mask = LVIF_TEXT;
2840         item.cchTextMax = MAX_PATH;
2841         item.iItem = 0;
2842         item.iSubItem = 0;
2843         item.pszText = wfd.cFileName;
2844
2845         SendMessageW( control->hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item );
2846     } while ( FindNextFileW( file, &wfd ) );
2847
2848     free( path );
2849     FindClose( file );
2850 }
2851
2852 static UINT dialog_directorylist_up( msi_dialog *dialog )
2853 {
2854     struct control *control;
2855     LPWSTR prop, path, ptr;
2856     BOOL indirect;
2857
2858     control = dialog_find_control_by_type( dialog, L"DirectoryList" );
2859     indirect = control->attributes & msidbControlAttributesIndirect;
2860     prop = dialog_dup_property( dialog, control->property, indirect );
2861     path = dialog_dup_property( dialog, prop, TRUE );
2862
2863     /* strip off the last directory */
2864     ptr = PathFindFileNameW( path );
2865     if (ptr != path)
2866     {
2867         *(ptr - 1) = '\0';
2868         PathAddBackslashW( path );
2869     }
2870
2871     dialog_set_property( dialog->package, prop, path );
2872
2873     dialog_update_directory_list( dialog, NULL );
2874     dialog_update_directory_combo( dialog, NULL );
2875     dialog_update_pathedit( dialog, NULL );
2876
2877     free( path );
2878     free( prop );
2879
2880     return ERROR_SUCCESS;
2881 }
2882
2883 static WCHAR *get_unique_folder_name( const WCHAR *root, int *ret_len )
2884 {
2885     WCHAR newfolder[MAX_PATH], *path, *ptr;
2886     int len, count = 2;
2887
2888     len = LoadStringW( msi_hInstance, IDS_NEWFOLDER, newfolder, ARRAY_SIZE(newfolder) );
2889     len += lstrlenW(root) + 1;
2890     if (!(path = malloc( (len + 4) * sizeof(WCHAR) ))) return NULL;
2891     lstrcpyW( path, root );
2892     lstrcatW( path, newfolder );
2893
2894     for (;;)
2895     {
2896         if (GetFileAttributesW( path ) == INVALID_FILE_ATTRIBUTES) break;
2897         if (count > 99)
2898         {
2899             free( path );
2900             return NULL;
2901         }
2902         swprintf( path, len + 4, L"%s%s %u", root, newfolder, count++ );
2903     }
2904
2905     ptr = wcsrchr( path, '\\' ) + 1;
2906     *ret_len = lstrlenW(ptr);
2907     memmove( path, ptr, *ret_len * sizeof(WCHAR) );
2908     return path;
2909 }
2910
2911 static UINT dialog_directorylist_new( msi_dialog *dialog )
2912 {
2913     struct control *control;
2914     WCHAR *path;
2915     LVITEMW item;
2916     int index;
2917
2918     control = dialog_find_control_by_type( dialog, L"DirectoryList" );
2919
2920     if (!(path = get_path_property( dialog, control ))) return ERROR_OUTOFMEMORY;
2921
2922     item.mask = LVIF_TEXT;
2923     item.iItem = 0;
2924     item.iSubItem = 0;
2925     item.pszText = get_unique_folder_name( path, &item.cchTextMax );
2926
2927     index = SendMessageW( control->hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item );
2928     SendMessageW( control->hwnd, LVM_ENSUREVISIBLE, index, 0 );
2929     SendMessageW( control->hwnd, LVM_EDITLABELW, index, -1 );
2930
2931     free( path );
2932     free( item.pszText );
2933     return ERROR_SUCCESS;
2934 }
2935
2936 static UINT dialog_dirlist_handler( msi_dialog *dialog, struct control *control, WPARAM param )
2937 {
2938     NMHDR *nmhdr = (NMHDR *)param;
2939     WCHAR text[MAX_PATH], *new_path, *path, *prop;
2940     BOOL indirect;
2941
2942     switch (nmhdr->code)
2943     {
2944     case LVN_ENDLABELEDITW:
2945     {
2946         NMLVDISPINFOW *info = (NMLVDISPINFOW *)param;
2947         if (!info->item.pszText) return ERROR_SUCCESS;
2948         lstrcpynW( text, info->item.pszText, ARRAY_SIZE(text) );
2949         text[ARRAY_SIZE(text) - 1] = 0;
2950         break;
2951     }
2952     case LVN_ITEMACTIVATE:
2953     {
2954         LVITEMW item;
2955         int index = SendMessageW( control->hwnd, LVM_GETNEXTITEM, -1, LVNI_SELECTED );
2956         if (index < 0)
2957         {
2958             ERR("no list-view item selected\n");
2959             return ERROR_FUNCTION_FAILED;
2960         }
2961
2962         item.iSubItem = 0;
2963         item.pszText = text;
2964         item.cchTextMax = MAX_PATH;
2965         SendMessageW( control->hwnd, LVM_GETITEMTEXTW, index, (LPARAM)&item );
2966         text[ARRAY_SIZE(text) - 1] = 0;
2967         break;
2968     }
2969     default:
2970         return ERROR_SUCCESS;
2971     }
2972
2973     indirect = control->attributes & msidbControlAttributesIndirect;
2974     prop = dialog_dup_property( dialog, control->property, indirect );
2975     path = dialog_dup_property( dialog, prop, TRUE );
2976
2977     if (!(new_path = malloc( (wcslen(path) + wcslen(text) + 2) * sizeof(WCHAR) )))
2978     {
2979         free( prop );
2980         free( path );
2981         return ERROR_OUTOFMEMORY;
2982     }
2983     lstrcpyW( new_path, path );
2984     lstrcatW( new_path, text );
2985     if (nmhdr->code == LVN_ENDLABELEDITW) CreateDirectoryW( new_path, NULL );
2986     lstrcatW( new_path, L"\\" );
2987
2988     dialog_set_property( dialog->package, prop, new_path );
2989
2990     dialog_update_directory_list( dialog, NULL );
2991     dialog_update_directory_combo( dialog, NULL );
2992     dialog_update_pathedit( dialog, NULL );
2993
2994     free( prop );
2995     free( path );
2996     free( new_path );
2997
2998     return ERROR_SUCCESS;
2999 }
3000
3001 static UINT dialog_directory_list( msi_dialog *dialog, MSIRECORD *rec )
3002 {
3003     struct control *control;
3004     LPCWSTR prop;
3005     DWORD style;
3006
3007     style = LVS_LIST | WS_VSCROLL | LVS_SHAREIMAGELISTS | LVS_EDITLABELS |
3008             LVS_AUTOARRANGE | LVS_SINGLESEL | WS_BORDER |
3009             LVS_SORTASCENDING | WS_CHILD | WS_GROUP | WS_TABSTOP;
3010     control = dialog_add_control( dialog, rec, WC_LISTVIEWW, style );
3011     if (!control)
3012         return ERROR_FUNCTION_FAILED;
3013
3014     control->attributes = MSI_RecordGetInteger( rec, 8 );
3015     control->handler = dialog_dirlist_handler;
3016     prop = MSI_RecordGetString( rec, 9 );
3017     control->property = dialog_dup_property( dialog, prop, FALSE );
3018
3019     /* double click to activate an item in the list */
3020     SendMessageW( control->hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE,
3021                   0, LVS_EX_TWOCLICKACTIVATE );
3022
3023     dialog_update_directory_list( dialog, control );
3024
3025     return ERROR_SUCCESS;
3026 }
3027
3028 /******************** VolumeCost List ***************************************/
3029
3030 static BOOL str_is_number( LPCWSTR str )
3031 {
3032     int i;
3033
3034     for (i = 0; i < lstrlenW( str ); i++)
3035         if (!iswdigit(str[i]))
3036             return FALSE;
3037
3038     return TRUE;
3039 }
3040
3041 static const WCHAR column_keys[][80] =
3042 {
3043     L"VolumeCostVolume",
3044     L"VolumeCostSize",
3045     L"VolumeCostAvailable",
3046     L"VolumeCostRequired",
3047     L"VolumeCostDifference",
3048 };
3049
3050 static void dialog_vcl_add_columns( msi_dialog *dialog, struct control *control, MSIRECORD *rec )
3051 {
3052     LPCWSTR text = MSI_RecordGetString( rec, 10 );
3053     LPCWSTR begin = text, end;
3054     WCHAR *num;
3055     LVCOLUMNW lvc;
3056     DWORD count = 0;
3057
3058     if (!text) return;
3059
3060     while ((begin = wcschr( begin, '{' )) && count < 5)
3061     {
3062         if (!(end = wcschr( begin, '}' )))
3063             return;
3064
3065         num = malloc( (end - begin + 1) * sizeof(WCHAR) );
3066         if (!num)
3067             return;
3068
3069         lstrcpynW( num, begin + 1, end - begin );
3070         begin += end - begin + 1;
3071
3072         /* empty braces or '0' hides the column */
3073         if ( !num[0] || !wcscmp( num, L"0" ) )
3074         {
3075             count++;
3076             free( num );
3077             continue;
3078         }
3079
3080         /* the width must be a positive number
3081          * if a width is invalid, all remaining columns are hidden
3082          */
3083         if ( !wcsncmp( num, L"-", 1 ) || !str_is_number( num ) ) {
3084             free( num );
3085             return;
3086         }
3087
3088         ZeroMemory( &lvc, sizeof(lvc) );
3089         lvc.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
3090         lvc.cx = wcstol( num, NULL, 10 );
3091         lvc.pszText = dialog_get_uitext( dialog, column_keys[count] );
3092
3093         SendMessageW( control->hwnd,  LVM_INSERTCOLUMNW, count++, (LPARAM)&lvc );
3094         free( lvc.pszText );
3095         free( num );
3096     }
3097 }
3098
3099 static LONGLONG vcl_get_cost( msi_dialog *dialog )
3100 {
3101     MSIFEATURE *feature;
3102     INT each_cost;
3103     LONGLONG total_cost = 0;
3104
3105     LIST_FOR_EACH_ENTRY( feature, &dialog->package->features, MSIFEATURE, entry )
3106     {
3107         if (ERROR_SUCCESS == (MSI_GetFeatureCost(dialog->package, feature,
3108                 MSICOSTTREE_SELFONLY, INSTALLSTATE_LOCAL, &each_cost)))
3109         {
3110             total_cost += each_cost;
3111         }
3112         if (ERROR_SUCCESS == (MSI_GetFeatureCost(dialog->package, feature,
3113                 MSICOSTTREE_SELFONLY, INSTALLSTATE_ABSENT, &each_cost)))
3114         {
3115             total_cost -= each_cost;
3116         }
3117     }
3118     return total_cost;
3119 }
3120
3121 static void dialog_vcl_add_drives( msi_dialog *dialog, struct control *control )
3122 {
3123     ULARGE_INTEGER total, unused;
3124     LONGLONG difference, cost;
3125     WCHAR size_text[MAX_PATH];
3126     WCHAR cost_text[MAX_PATH];
3127     LPWSTR drives, ptr;
3128     LVITEMW lvitem;
3129     DWORD size, flags;
3130     int i = 0;
3131
3132     cost = vcl_get_cost(dialog) * 512;
3133     StrFormatByteSizeW(cost, cost_text, MAX_PATH);
3134
3135     size = GetLogicalDriveStringsW( 0, NULL );
3136     if ( !size ) return;
3137
3138     drives = malloc( (size + 1) * sizeof(WCHAR) );
3139     if ( !drives ) return;
3140
3141     GetLogicalDriveStringsW( size, drives );
3142
3143     ptr = drives;
3144     while (*ptr)
3145     {
3146         if (GetVolumeInformationW(ptr, NULL, 0, NULL, 0, &flags, NULL, 0) &&
3147             flags & FILE_READ_ONLY_VOLUME)
3148         {
3149             ptr += lstrlenW(ptr) + 1;
3150             continue;
3151         }
3152
3153         lvitem.mask = LVIF_TEXT;
3154         lvitem.iItem = i;
3155         lvitem.iSubItem = 0;
3156         lvitem.pszText = ptr;
3157         lvitem.cchTextMax = lstrlenW(ptr) + 1;
3158         SendMessageW( control->hwnd, LVM_INSERTITEMW, 0, (LPARAM)&lvitem );
3159
3160         GetDiskFreeSpaceExW(ptr, &unused, &total, NULL);
3161         difference = unused.QuadPart - cost;
3162
3163         StrFormatByteSizeW(total.QuadPart, size_text, MAX_PATH);
3164         lvitem.iSubItem = 1;
3165         lvitem.pszText = size_text;
3166         lvitem.cchTextMax = lstrlenW(size_text) + 1;
3167         SendMessageW( control->hwnd, LVM_SETITEMW, 0, (LPARAM)&lvitem );
3168
3169         StrFormatByteSizeW(unused.QuadPart, size_text, MAX_PATH);
3170         lvitem.iSubItem = 2;
3171         lvitem.pszText = size_text;
3172         lvitem.cchTextMax = lstrlenW(size_text) + 1;
3173         SendMessageW( control->hwnd, LVM_SETITEMW, 0, (LPARAM)&lvitem );
3174
3175         lvitem.iSubItem = 3;
3176         lvitem.pszText = cost_text;
3177         lvitem.cchTextMax = lstrlenW(cost_text) + 1;
3178         SendMessageW( control->hwnd, LVM_SETITEMW, 0, (LPARAM)&lvitem );
3179
3180         StrFormatByteSizeW(difference, size_text, MAX_PATH);
3181         lvitem.iSubItem = 4;
3182         lvitem.pszText = size_text;
3183         lvitem.cchTextMax = lstrlenW(size_text) + 1;
3184         SendMessageW( control->hwnd, LVM_SETITEMW, 0, (LPARAM)&lvitem );
3185
3186         ptr += lstrlenW(ptr) + 1;
3187         i++;
3188     }
3189
3190     free( drives );
3191 }
3192
3193 static UINT dialog_volumecost_list( msi_dialog *dialog, MSIRECORD *rec )
3194 {
3195     struct control *control;
3196     DWORD style;
3197
3198     style = LVS_REPORT | WS_VSCROLL | WS_HSCROLL | LVS_SHAREIMAGELISTS |
3199             LVS_AUTOARRANGE | LVS_SINGLESEL | WS_BORDER |
3200             WS_CHILD | WS_TABSTOP | WS_GROUP;
3201     control = dialog_add_control( dialog, rec, WC_LISTVIEWW, style );
3202     if (!control)
3203         return ERROR_FUNCTION_FAILED;
3204
3205     dialog_vcl_add_columns( dialog, control, rec );
3206     dialog_vcl_add_drives( dialog, control );
3207
3208     return ERROR_SUCCESS;
3209 }
3210
3211 /******************** VolumeSelect Combo ***************************************/
3212
3213 static UINT dialog_volsel_handler( msi_dialog *dialog, struct control *control, WPARAM param )
3214 {
3215     WCHAR text[MAX_PATH];
3216     LPWSTR prop;
3217     BOOL indirect;
3218     int index;
3219
3220     if (HIWORD(param) != CBN_SELCHANGE)
3221         return ERROR_SUCCESS;
3222
3223     index = SendMessageW( control->hwnd, CB_GETCURSEL, 0, 0 );
3224     if ( index == CB_ERR )
3225     {
3226         ERR("No ComboBox item selected!\n");
3227         return ERROR_FUNCTION_FAILED;
3228     }
3229
3230     SendMessageW( control->hwnd, CB_GETLBTEXT, index, (LPARAM)text );
3231
3232     indirect = control->attributes & msidbControlAttributesIndirect;
3233     prop = dialog_dup_property( dialog, control->property, indirect );
3234
3235     dialog_set_property( dialog->package, prop, text );
3236
3237     free( prop );
3238     return ERROR_SUCCESS;
3239 }
3240
3241 static void dialog_vsc_add_drives( msi_dialog *dialog, struct control *control )
3242 {
3243     LPWSTR drives, ptr;
3244     DWORD size;
3245
3246     size = GetLogicalDriveStringsW( 0, NULL );
3247     if ( !size ) return;
3248
3249     drives = malloc( (size + 1) * sizeof(WCHAR) );
3250     if ( !drives ) return;
3251
3252     GetLogicalDriveStringsW( size, drives );
3253
3254     ptr = drives;
3255     while (*ptr)
3256     {
3257         SendMessageW( control->hwnd, CB_ADDSTRING, 0, (LPARAM)ptr );
3258         ptr += lstrlenW(ptr) + 1;
3259     }
3260
3261     free( drives );
3262 }
3263
3264 static UINT dialog_volumeselect_combo( msi_dialog *dialog, MSIRECORD *rec )
3265 {
3266     struct control *control;
3267     LPCWSTR prop;
3268     DWORD style;
3269
3270     /* FIXME: CBS_OWNERDRAWFIXED */
3271     style = WS_CHILD | WS_VISIBLE | WS_GROUP | WS_TABSTOP |
3272             CBS_DROPDOWNLIST | CBS_SORT | CBS_HASSTRINGS |
3273             WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR;
3274     control = dialog_add_control( dialog, rec, WC_COMBOBOXW, style );
3275     if (!control)
3276         return ERROR_FUNCTION_FAILED;
3277
3278     control->attributes = MSI_RecordGetInteger( rec, 8 );
3279     control->handler = dialog_volsel_handler;
3280     prop = MSI_RecordGetString( rec, 9 );
3281     control->property = dialog_dup_property( dialog, prop, FALSE );
3282
3283     dialog_vsc_add_drives( dialog, control );
3284
3285     return ERROR_SUCCESS;
3286 }
3287
3288 static UINT dialog_hyperlink_handler( msi_dialog *dialog, struct control *control, WPARAM param )
3289 {
3290     int len, len_href = ARRAY_SIZE( L"href" ) - 1;
3291     const WCHAR *p, *q;
3292     WCHAR quote = 0;
3293     LITEM item;
3294
3295     item.mask     = LIF_ITEMINDEX | LIF_URL;
3296     item.iLink    = 0;
3297     item.szUrl[0] = 0;
3298
3299     SendMessageW( control->hwnd, LM_GETITEM, 0, (LPARAM)&item );
3300
3301     p = item.szUrl;
3302     while (*p && *p != '<') p++;
3303     if (!*p++) return ERROR_SUCCESS;
3304     if (towupper( *p++ ) != 'A' || !iswspace( *p++ )) return ERROR_SUCCESS;
3305     while (*p && iswspace( *p )) p++;
3306
3307     len = lstrlenW( p );
3308     if (len > len_href && !wcsnicmp( p, L"href", len_href ))
3309     {
3310         p += len_href;
3311         while (*p && iswspace( *p )) p++;
3312         if (!*p || *p++ != '=') return ERROR_SUCCESS;
3313         while (*p && iswspace( *p )) p++;
3314
3315         if (*p == '\"' || *p == '\'') quote = *p++;
3316         q = p;
3317         if (quote)
3318         {
3319             while (*q && *q != quote) q++;
3320             if (*q != quote) return ERROR_SUCCESS;
3321         }
3322         else
3323         {
3324             while (*q && *q != '>' && !iswspace( *q )) q++;
3325             if (!*q) return ERROR_SUCCESS;
3326         }
3327         item.szUrl[q - item.szUrl] = 0;
3328         ShellExecuteW( NULL, L"open", p, NULL, NULL, SW_SHOWNORMAL );
3329     }
3330     return ERROR_SUCCESS;
3331 }
3332
3333 static UINT dialog_hyperlink( msi_dialog *dialog, MSIRECORD *rec )
3334 {
3335     struct control *control;
3336     DWORD style = WS_CHILD | WS_TABSTOP | WS_GROUP;
3337     const WCHAR *text = MSI_RecordGetString( rec, 10 );
3338     int len = lstrlenW( text );
3339     LITEM item;
3340
3341     control = dialog_add_control( dialog, rec, WC_LINK, style );
3342     if (!control)
3343         return ERROR_FUNCTION_FAILED;
3344
3345     control->attributes = MSI_RecordGetInteger( rec, 8 );
3346     control->handler    = dialog_hyperlink_handler;
3347
3348     item.mask      = LIF_ITEMINDEX | LIF_STATE | LIF_URL;
3349     item.iLink     = 0;
3350     item.state     = LIS_ENABLED;
3351     item.stateMask = LIS_ENABLED;
3352     if (len < L_MAX_URL_LENGTH) lstrcpyW( item.szUrl, text );
3353     else item.szUrl[0] = 0;
3354
3355     SendMessageW( control->hwnd, LM_SETITEM, 0, (LPARAM)&item );
3356
3357     return ERROR_SUCCESS;
3358 }
3359
3360 /******************** ListView *****************************************/
3361
3362 struct listview_param
3363 {
3364     msi_dialog *dialog;
3365     struct control *control;
3366 };
3367
3368 static UINT dialog_listview_handler( msi_dialog *dialog, struct control *control, WPARAM param )
3369 {
3370     NMHDR *nmhdr = (NMHDR *)param;
3371
3372     FIXME("code %#x (%d)\n", nmhdr->code, nmhdr->code);
3373
3374     return ERROR_SUCCESS;
3375 }
3376
3377 static UINT listview_add_item( MSIRECORD *rec, void *param )
3378 {
3379     struct listview_param *lv_param = (struct listview_param *)param;
3380     LPCWSTR text, binary;
3381     LVITEMW item;
3382     HICON hIcon;
3383
3384     text = MSI_RecordGetString( rec, 4 );
3385     binary = MSI_RecordGetString( rec, 5 );
3386     hIcon = load_icon( lv_param->dialog->package->db, binary, 0 );
3387
3388     TRACE("Adding: text %s, binary %s, icon %p\n", debugstr_w(text), debugstr_w(binary), hIcon);
3389
3390     memset( &item, 0, sizeof(item) );
3391     item.mask = LVIF_TEXT | LVIF_IMAGE;
3392     deformat_string( lv_param->dialog->package, text, &item.pszText );
3393     item.iImage = ImageList_AddIcon( lv_param->control->hImageList, hIcon );
3394     item.iItem = item.iImage;
3395     SendMessageW( lv_param->control->hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item );
3396
3397     DestroyIcon( hIcon );
3398
3399     return ERROR_SUCCESS;
3400 }
3401
3402 static UINT listview_add_items( msi_dialog *dialog, struct control *control )
3403 {
3404     MSIQUERY *view;
3405     struct listview_param lv_param = { dialog, control };
3406
3407     if (MSI_OpenQuery( dialog->package->db, &view, L"SELECT * FROM `ListView` WHERE `Property` = '%s' ORDER BY `Order`",
3408                        control->property ) == ERROR_SUCCESS)
3409     {
3410         MSI_IterateRecords( view, NULL, listview_add_item, &lv_param );
3411         msiobj_release( &view->hdr );
3412     }
3413
3414     return ERROR_SUCCESS;
3415 }
3416
3417 static UINT dialog_listview( msi_dialog *dialog, MSIRECORD *rec )
3418 {
3419     struct control *control;
3420     LPCWSTR prop;
3421     DWORD style, attributes;
3422     LVCOLUMNW col;
3423     RECT rc;
3424
3425     style = LVS_REPORT | LVS_NOCOLUMNHEADER | LVS_SHAREIMAGELISTS | LVS_SINGLESEL |
3426             LVS_SHOWSELALWAYS | WS_VSCROLL | WS_HSCROLL | WS_BORDER | WS_TABSTOP | WS_CHILD;
3427     attributes = MSI_RecordGetInteger( rec, 8 );
3428     if ( ~attributes & msidbControlAttributesSorted )
3429         style |= LVS_SORTASCENDING;
3430     control = dialog_add_control( dialog, rec, WC_LISTVIEWW, style );
3431     if (!control)
3432         return ERROR_FUNCTION_FAILED;
3433
3434     prop = MSI_RecordGetString( rec, 9 );
3435     control->property = dialog_dup_property( dialog, prop, FALSE );
3436
3437     control->hImageList = ImageList_Create( 16, 16, ILC_COLOR32, 0, 1);
3438     SendMessageW( control->hwnd, LVM_SETIMAGELIST, LVSIL_SMALL, (LPARAM)control->hImageList );
3439
3440     col.mask = LVCF_FMT | LVCF_WIDTH;
3441     col.fmt = LVCFMT_LEFT;
3442     col.cx = 16;
3443     SendMessageW( control->hwnd, LVM_INSERTCOLUMNW, 0, (LPARAM)&col );
3444
3445     GetClientRect( control->hwnd, &rc );
3446     col.cx = rc.right - 16;
3447     SendMessageW( control->hwnd, LVM_INSERTCOLUMNW, 0, (LPARAM)&col );
3448
3449     if (control->property)
3450         listview_add_items( dialog, control );
3451
3452     control->handler = dialog_listview_handler;
3453
3454     return ERROR_SUCCESS;
3455 }
3456
3457 static const struct control_handler msi_dialog_handler[] =
3458 {
3459     { L"Text", dialog_text_control },
3460     { L"PushButton", dialog_button_control },
3461     { L"Line", dialog_line_control },
3462     { L"Bitmap", dialog_bitmap_control },
3463     { L"CheckBox", dialog_checkbox_control },
3464     { L"ScrollableText", dialog_scrolltext_control },
3465     { L"ComboBox", dialog_combo_control },
3466     { L"Edit", dialog_edit_control },
3467     { L"MaskedEdit", dialog_maskedit_control },
3468     { L"PathEdit", dialog_pathedit_control },
3469     { L"ProgressBar", dialog_progress_bar },
3470     { L"RadioButtonGroup", dialog_radiogroup_control },
3471     { L"Icon", dialog_icon_control },
3472     { L"SelectionTree", dialog_selection_tree },
3473     { L"GroupBox", dialog_group_box },
3474     { L"ListBox", dialog_list_box },
3475     { L"DirectoryCombo", dialog_directory_combo },
3476     { L"DirectoryList", dialog_directory_list },
3477     { L"VolumeCostList", dialog_volumecost_list },
3478     { L"VolumeSelectCombo", dialog_volumeselect_combo },
3479     { L"HyperLink", dialog_hyperlink },
3480     { L"ListView", dialog_listview }
3481 };
3482
3483 static UINT dialog_create_controls( MSIRECORD *rec, void *param )
3484 {
3485     msi_dialog *dialog = param;
3486     LPCWSTR control_type;
3487     UINT i;
3488
3489     /* find and call the function that can create this type of control */
3490     control_type = MSI_RecordGetString( rec, 3 );
3491     for( i = 0; i < ARRAY_SIZE( msi_dialog_handler ); i++ )
3492         if (!wcsicmp( msi_dialog_handler[i].control_type, control_type ))
3493             break;
3494     if( i != ARRAY_SIZE( msi_dialog_handler  ))
3495         msi_dialog_handler[i].func( dialog, rec );
3496     else
3497         ERR("no handler for element type %s\n", debugstr_w(control_type));
3498
3499     return ERROR_SUCCESS;
3500 }
3501
3502 static UINT dialog_fill_controls( msi_dialog *dialog )
3503 {
3504     UINT r;
3505     MSIQUERY *view;
3506     MSIPACKAGE *package = dialog->package;
3507
3508     TRACE("%p %s\n", dialog, debugstr_w(dialog->name) );
3509
3510     /* query the Control table for all the elements of the control */
3511     r = MSI_OpenQuery( package->db, &view, L"SELECT * FROM `Control` WHERE `Dialog_` = '%s'", dialog->name );
3512     if( r != ERROR_SUCCESS )
3513     {
3514         ERR("query failed for dialog %s\n", debugstr_w(dialog->name));
3515         return ERROR_INVALID_PARAMETER;
3516     }
3517
3518     r = MSI_IterateRecords( view, 0, dialog_create_controls, dialog );
3519     msiobj_release( &view->hdr );
3520     return r;
3521 }
3522
3523 static UINT dialog_reset( msi_dialog *dialog )
3524 {
3525     /* FIXME: should restore the original values of any properties we changed */
3526     return dialog_evaluate_control_conditions( dialog );
3527 }
3528
3529 /* figure out the height of 10 point MS Sans Serif */
3530 static INT dialog_get_sans_serif_height( HWND hwnd )
3531 {
3532     LOGFONTW lf;
3533     TEXTMETRICW tm;
3534     BOOL r;
3535     LONG height = 0;
3536     HFONT hFont, hOldFont;
3537     HDC hdc;
3538
3539     hdc = GetDC( hwnd );
3540     if (hdc)
3541     {
3542         memset( &lf, 0, sizeof lf );
3543         lf.lfHeight = MulDiv(12, GetDeviceCaps(hdc, LOGPIXELSY), 72);
3544         lstrcpyW( lf.lfFaceName, L"MS Sans Serif" );
3545         hFont = CreateFontIndirectW(&lf);
3546         if (hFont)
3547         {
3548             hOldFont = SelectObject( hdc, hFont );
3549             r = GetTextMetricsW( hdc, &tm );
3550             if (r)
3551                 height = tm.tmHeight;
3552             SelectObject( hdc, hOldFont );
3553             DeleteObject( hFont );
3554         }
3555         ReleaseDC( hwnd, hdc );
3556     }
3557     return height;
3558 }
3559
3560 /* fetch the associated record from the Dialog table */
3561 static MSIRECORD *get_dialog_record( msi_dialog *dialog )
3562 {
3563     MSIPACKAGE *package = dialog->package;
3564     MSIRECORD *rec = NULL;
3565
3566     TRACE("%p %s\n", dialog, debugstr_w(dialog->name) );
3567
3568     rec = MSI_QueryGetRecord( package->db, L"SELECT * FROM `Dialog` WHERE `Dialog` = '%s'", dialog->name );
3569     if( !rec )
3570         WARN("query failed for dialog %s\n", debugstr_w(dialog->name));
3571
3572     return rec;
3573 }
3574
3575 static void dialog_adjust_dialog_pos( msi_dialog *dialog, MSIRECORD *rec, RECT *pos )
3576 {
3577     UINT xres, yres;
3578     POINT center;
3579     SIZE sz;
3580     LONG style;
3581
3582     center.x = MSI_RecordGetInteger( rec, 2 );
3583     center.y = MSI_RecordGetInteger( rec, 3 );
3584
3585     sz.cx = MSI_RecordGetInteger( rec, 4 );
3586     sz.cy = MSI_RecordGetInteger( rec, 5 );
3587
3588     sz.cx = dialog_scale_unit( dialog, sz.cx );
3589     sz.cy = dialog_scale_unit( dialog, sz.cy );
3590
3591     xres = msi_get_property_int( dialog->package->db, L"ScreenX", 0 );
3592     yres = msi_get_property_int( dialog->package->db, L"ScreenY", 0 );
3593
3594     center.x = MulDiv( center.x, xres, 100 );
3595     center.y = MulDiv( center.y, yres, 100 );
3596
3597     /* turn the client pos into the window rectangle */
3598     if (dialog->package->center_x && dialog->package->center_y)
3599     {
3600         pos->left = dialog->package->center_x - sz.cx / 2.0;
3601         pos->right = pos->left + sz.cx;
3602         pos->top = dialog->package->center_y - sz.cy / 2.0;
3603         pos->bottom = pos->top + sz.cy;
3604     }
3605     else
3606     {
3607         pos->left = center.x - sz.cx/2;
3608         pos->right = pos->left + sz.cx;
3609         pos->top = center.y - sz.cy/2;
3610         pos->bottom = pos->top + sz.cy;
3611
3612         /* save the center */
3613         dialog->package->center_x = center.x;
3614         dialog->package->center_y = center.y;
3615     }
3616
3617     dialog->size.cx = sz.cx;
3618     dialog->size.cy = sz.cy;
3619
3620     TRACE("%s\n", wine_dbgstr_rect(pos));
3621
3622     style = GetWindowLongPtrW( dialog->hwnd, GWL_STYLE );
3623     AdjustWindowRect( pos, style, FALSE );
3624 }
3625
3626 static void dialog_set_tab_order( msi_dialog *dialog, const WCHAR *first )
3627 {
3628     struct list tab_chain;
3629     struct control *control;
3630     HWND prev = HWND_TOP;
3631
3632     list_init( &tab_chain );
3633     if (!(control = dialog_find_control( dialog, first ))) return;
3634
3635     dialog->hWndFocus = control->hwnd;
3636     while (control)
3637     {
3638         list_remove( &control->entry );
3639         list_add_tail( &tab_chain, &control->entry );
3640         if (!control->tabnext) break;
3641         control = dialog_find_control( dialog, control->tabnext );
3642     }
3643
3644     LIST_FOR_EACH_ENTRY( control, &tab_chain, struct control, entry )
3645     {
3646         SetWindowPos( control->hwnd, prev, 0, 0, 0, 0,
3647                       SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOREDRAW |
3648                       SWP_NOREPOSITION | SWP_NOSENDCHANGING | SWP_NOSIZE );
3649         prev = control->hwnd;
3650     }
3651
3652     /* put them back on the main list */
3653     list_move_head( &dialog->controls, &tab_chain );
3654 }
3655
3656 static LRESULT dialog_oncreate( HWND hwnd, CREATESTRUCTW *cs )
3657 {
3658     msi_dialog *dialog = cs->lpCreateParams;
3659     MSIRECORD *rec = NULL;
3660     LPWSTR title = NULL;
3661     RECT pos;
3662
3663     TRACE("%p %p\n", dialog, dialog->package);
3664
3665     dialog->hwnd = hwnd;
3666     SetWindowLongPtrW( hwnd, GWLP_USERDATA, (LONG_PTR) dialog );
3667
3668     rec = get_dialog_record( dialog );
3669     if( !rec )
3670     {
3671         TRACE("No record found for dialog %s\n", debugstr_w(dialog->name));
3672         return -1;
3673     }
3674
3675     dialog->scale = dialog_get_sans_serif_height(dialog->hwnd);
3676
3677     dialog_adjust_dialog_pos( dialog, rec, &pos );
3678
3679     dialog->attributes = MSI_RecordGetInteger( rec, 6 );
3680
3681     dialog->default_font = msi_dup_property( dialog->package->db, L"DefaultUIFont" );
3682     if (!dialog->default_font)
3683     {
3684         dialog->default_font = wcsdup( L"MS Shell Dlg" );
3685         if (!dialog->default_font)
3686         {
3687             msiobj_release( &rec->hdr );
3688             return -1;
3689         }
3690     }
3691
3692     title = get_deformatted_field( dialog->package, rec, 7 );
3693     SetWindowTextW( hwnd, title );
3694     free( title );
3695
3696     SetWindowPos( hwnd, 0, pos.left, pos.top,
3697                   pos.right - pos.left, pos.bottom - pos.top,
3698                   SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW );
3699
3700     dialog_build_font_list( dialog );
3701     dialog_fill_controls( dialog );
3702     dialog_evaluate_control_conditions( dialog );
3703     dialog_set_tab_order( dialog, MSI_RecordGetString( rec, 8 ) );
3704     msiobj_release( &rec->hdr );
3705
3706     return 0;
3707 }
3708
3709 static LRESULT dialog_oncommand( msi_dialog *dialog, WPARAM param, HWND hwnd )
3710 {
3711     struct control *control = NULL;
3712
3713     TRACE( "%p, %#Ix, %p\n", dialog, param, hwnd );
3714
3715     switch (param)
3716     {
3717     case 1: /* enter */
3718         control = dialog_find_control( dialog, dialog->control_default );
3719         break;
3720     case 2: /* escape */
3721         control = dialog_find_control( dialog, dialog->control_cancel );
3722         break;
3723     default:
3724         control = dialog_find_control_by_hwnd( dialog, hwnd );
3725     }
3726
3727     if( control )
3728     {
3729         if( control->handler )
3730         {
3731             control->handler( dialog, control, param );
3732             dialog_evaluate_control_conditions( dialog );
3733         }
3734     }
3735
3736     return 0;
3737 }
3738
3739 static LRESULT dialog_onnotify( msi_dialog *dialog, LPARAM param )
3740 {
3741     LPNMHDR nmhdr = (LPNMHDR) param;
3742     struct control *control = dialog_find_control_by_hwnd( dialog, nmhdr->hwndFrom );
3743
3744     TRACE("%p %p\n", dialog, nmhdr->hwndFrom);
3745
3746     if ( control && control->handler )
3747         control->handler( dialog, control, param );
3748
3749     return 0;
3750 }
3751
3752 static void dialog_setfocus( msi_dialog *dialog )
3753 {
3754     HWND hwnd = dialog->hWndFocus;
3755
3756     hwnd = GetNextDlgTabItem( dialog->hwnd, hwnd, TRUE);
3757     hwnd = GetNextDlgTabItem( dialog->hwnd, hwnd, FALSE);
3758     SetFocus( hwnd );
3759     dialog->hWndFocus = hwnd;
3760 }
3761
3762 static LRESULT WINAPI MSIDialog_WndProc( HWND hwnd, UINT msg,
3763                 WPARAM wParam, LPARAM lParam )
3764 {
3765     msi_dialog *dialog = (LPVOID) GetWindowLongPtrW( hwnd, GWLP_USERDATA );
3766
3767     TRACE("0x%04x\n", msg);
3768
3769     switch (msg)
3770     {
3771     case WM_MOVE:
3772         dialog->package->center_x = LOWORD(lParam) + dialog->size.cx / 2.0;
3773         dialog->package->center_y = HIWORD(lParam) + dialog->size.cy / 2.0;
3774         break;
3775
3776     case WM_CREATE:
3777         return dialog_oncreate( hwnd, (LPCREATESTRUCTW)lParam );
3778
3779     case WM_COMMAND:
3780         return dialog_oncommand( dialog, wParam, (HWND)lParam );
3781
3782     case WM_CLOSE:
3783         /* Simulate escape press */
3784         return dialog_oncommand(dialog, 2, NULL);
3785
3786     case WM_ACTIVATE:
3787         if( LOWORD(wParam) == WA_INACTIVE )
3788             dialog->hWndFocus = GetFocus();
3789         else
3790             dialog_setfocus( dialog );
3791         return 0;
3792
3793     case WM_SETFOCUS:
3794         dialog_setfocus( dialog );
3795         return 0;
3796
3797     /* bounce back to our subclassed static control */
3798     case WM_CTLCOLORSTATIC:
3799         return SendMessageW( (HWND) lParam, WM_CTLCOLORSTATIC, wParam, lParam );
3800
3801     case WM_DESTROY:
3802         dialog->hwnd = NULL;
3803         return 0;
3804     case WM_NOTIFY:
3805         return dialog_onnotify( dialog, lParam );
3806     }
3807     return DefWindowProcW(hwnd, msg, wParam, lParam);
3808 }
3809
3810 static void process_pending_messages( HWND hdlg )
3811 {
3812     MSG msg;
3813
3814     while (PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ))
3815     {
3816         if (hdlg && IsDialogMessageW( hdlg, &msg )) continue;
3817         TranslateMessage( &msg );
3818         DispatchMessageW( &msg );
3819     }
3820 }
3821
3822 static UINT dialog_run_message_loop( msi_dialog *dialog )
3823 {
3824     DWORD style;
3825     HWND hwnd, parent;
3826
3827     if( uiThreadId != GetCurrentThreadId() )
3828         return SendMessageW( hMsiHiddenWindow, WM_MSI_DIALOG_CREATE, 0, (LPARAM) dialog );
3829
3830     /* create the dialog window, don't show it yet */
3831     style = WS_OVERLAPPED | WS_SYSMENU;
3832     if( dialog->attributes & msidbDialogAttributesVisible )
3833         style |= WS_VISIBLE;
3834
3835     if (dialog->parent == NULL && (dialog->attributes & msidbDialogAttributesMinimize))
3836         style |= WS_MINIMIZEBOX;
3837
3838     parent = dialog->parent ? dialog->parent->hwnd : 0;
3839
3840     hwnd = CreateWindowW( L"MsiDialogCloseClass", dialog->name, style,
3841                      CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
3842                      parent, NULL, NULL, dialog );
3843     if( !hwnd )
3844     {
3845         ERR("Failed to create dialog %s\n", debugstr_w( dialog->name ));
3846         return ERROR_FUNCTION_FAILED;
3847     }
3848
3849     ShowWindow( hwnd, SW_SHOW );
3850     /* UpdateWindow( hwnd ); - and causes the transparent static controls not to paint */
3851
3852     if( dialog->attributes & msidbDialogAttributesModal )
3853     {
3854         while( !dialog->finished )
3855         {
3856             MsgWaitForMultipleObjects( 0, NULL, 0, INFINITE, QS_ALLINPUT );
3857             process_pending_messages( dialog->hwnd );
3858         }
3859     }
3860     else
3861         return ERROR_IO_PENDING;
3862
3863     return ERROR_SUCCESS;
3864 }
3865
3866 static LRESULT WINAPI MSIHiddenWindowProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
3867 {
3868     msi_dialog *dialog = (msi_dialog*) lParam;
3869
3870     TRACE("%d %p\n", msg, dialog);
3871
3872     switch (msg)
3873     {
3874     case WM_MSI_DIALOG_CREATE:
3875         return dialog_run_message_loop( dialog );
3876     case WM_MSI_DIALOG_DESTROY:
3877         msi_dialog_destroy( dialog );
3878         return 0;
3879     }
3880     return DefWindowProcW( hwnd, msg, wParam, lParam );
3881 }
3882
3883 static BOOL dialog_register_class( void )
3884 {
3885     WNDCLASSW cls;
3886
3887     ZeroMemory( &cls, sizeof cls );
3888     cls.lpfnWndProc   = MSIDialog_WndProc;
3889     cls.hInstance     = NULL;
3890     cls.hIcon         = LoadIconW(0, (LPWSTR)IDI_APPLICATION);
3891     cls.hCursor       = LoadCursorW(0, (LPWSTR)IDC_ARROW);
3892     cls.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
3893     cls.lpszMenuName  = NULL;
3894     cls.lpszClassName = L"MsiDialogCloseClass";
3895
3896     if( !RegisterClassW( &cls ) )
3897         return FALSE;
3898
3899     cls.lpfnWndProc   = MSIHiddenWindowProc;
3900     cls.lpszClassName = L"MsiHiddenWindow";
3901
3902     if( !RegisterClassW( &cls ) )
3903         return FALSE;
3904
3905     uiThreadId = GetCurrentThreadId();
3906
3907     hMsiHiddenWindow = CreateWindowW( L"MsiHiddenWindow", NULL, WS_OVERLAPPED,
3908                                    0, 0, 100, 100, NULL, NULL, NULL, NULL );
3909     if( !hMsiHiddenWindow )
3910         return FALSE;
3911
3912     return TRUE;
3913 }
3914
3915 static msi_dialog *dialog_create( MSIPACKAGE *package, const WCHAR *name, msi_dialog *parent,
3916                                   UINT (*event_handler)(msi_dialog *, const WCHAR *, const WCHAR *) )
3917 {
3918     MSIRECORD *rec = NULL;
3919     msi_dialog *dialog;
3920
3921     TRACE("%s\n", debugstr_w(name));
3922
3923     if (!hMsiHiddenWindow) dialog_register_class();
3924
3925     /* allocate the structure for the dialog to use */
3926     dialog = calloc( 1, offsetof( msi_dialog, name[wcslen( name ) + 1] ) );
3927     if( !dialog )
3928         return NULL;
3929     lstrcpyW( dialog->name, name );
3930     dialog->parent = parent;
3931     dialog->package = package;
3932     dialog->event_handler = event_handler;
3933     dialog->finished = 0;
3934     list_init( &dialog->controls );
3935     list_init( &dialog->fonts );
3936
3937     /* verify that the dialog exists */
3938     rec = get_dialog_record( dialog );
3939     if( !rec )
3940     {
3941         free( dialog );
3942         return NULL;
3943     }
3944     dialog->attributes = MSI_RecordGetInteger( rec, 6 );
3945     dialog->control_default = wcsdup( MSI_RecordGetString( rec, 9 ) );
3946     dialog->control_cancel = wcsdup( MSI_RecordGetString( rec, 10 ) );
3947     msiobj_release( &rec->hdr );
3948
3949     rec = MSI_CreateRecord(2);
3950     if (!rec)
3951     {
3952         msi_dialog_destroy(dialog);
3953         return NULL;
3954     }
3955     MSI_RecordSetStringW(rec, 1, name);
3956     MSI_RecordSetStringW(rec, 2, L"Dialog created");
3957     MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONSTART, rec);
3958     msiobj_release(&rec->hdr);
3959
3960     return dialog;
3961 }
3962
3963 static void dialog_end_dialog( msi_dialog *dialog )
3964 {
3965     TRACE("%p\n", dialog);
3966     dialog->finished = 1;
3967     PostMessageW(dialog->hwnd, WM_NULL, 0, 0);
3968 }
3969
3970 void msi_dialog_check_messages( HANDLE handle )
3971 {
3972     DWORD r;
3973
3974     /* in threads other than the UI thread, block */
3975     if( uiThreadId != GetCurrentThreadId() )
3976     {
3977         if (!handle) return;
3978         while (MsgWaitForMultipleObjectsEx( 1, &handle, INFINITE, QS_ALLINPUT, 0 ) == WAIT_OBJECT_0 + 1)
3979         {
3980             MSG msg;
3981             while (PeekMessageW( &msg, NULL, 0, 0, PM_REMOVE ))
3982             {
3983                 TranslateMessage( &msg );
3984                 DispatchMessageW( &msg );
3985             }
3986         }
3987         return;
3988     }
3989
3990     /* there are two choices for the UI thread */
3991     while (1)
3992     {
3993         process_pending_messages( NULL );
3994
3995         if( !handle )
3996             break;
3997
3998         /*
3999          * block here until somebody creates a new dialog or
4000          * the handle we're waiting on becomes ready
4001          */
4002         r = MsgWaitForMultipleObjects( 1, &handle, 0, INFINITE, QS_ALLINPUT );
4003         if( r == WAIT_OBJECT_0 )
4004             break;
4005     }
4006 }
4007
4008 static void dialog_do_preview( msi_dialog *dialog )
4009 {
4010     TRACE("\n");
4011     dialog->attributes |= msidbDialogAttributesVisible;
4012     dialog->attributes &= ~msidbDialogAttributesModal;
4013     dialog_run_message_loop( dialog );
4014 }
4015
4016 static void free_subscriber( struct subscriber *sub )
4017 {
4018     free( sub->event );
4019     free( sub->control );
4020     free( sub->attribute );
4021     free( sub );
4022 }
4023
4024 static void event_cleanup_subscriptions( MSIPACKAGE *package, const WCHAR *dialog )
4025 {
4026     struct list *item, *next;
4027
4028     LIST_FOR_EACH_SAFE( item, next, &package->subscriptions )
4029     {
4030         struct subscriber *sub = LIST_ENTRY( item, struct subscriber, entry );
4031
4032         if (wcscmp( sub->dialog->name, dialog )) continue;
4033         list_remove( &sub->entry );
4034         free_subscriber( sub );
4035     }
4036 }
4037
4038 void msi_dialog_destroy( msi_dialog *dialog )
4039 {
4040     struct font *font, *next;
4041
4042     if( uiThreadId != GetCurrentThreadId() )
4043     {
4044         SendMessageW( hMsiHiddenWindow, WM_MSI_DIALOG_DESTROY, 0, (LPARAM) dialog );
4045         return;
4046     }
4047
4048     if( dialog->hwnd )
4049     {
4050         ShowWindow( dialog->hwnd, SW_HIDE );
4051         DestroyWindow( dialog->hwnd );
4052     }
4053
4054     /* unsubscribe events */
4055     event_cleanup_subscriptions( dialog->package, dialog->name );
4056
4057     /* destroy the list of controls */
4058     while( !list_empty( &dialog->controls ) )
4059     {
4060         struct control *t;
4061
4062         t = LIST_ENTRY( list_head( &dialog->controls ), struct control, entry );
4063         destroy_control( t );
4064     }
4065
4066     /* destroy the list of fonts */
4067     LIST_FOR_EACH_ENTRY_SAFE( font, next, &dialog->fonts, struct font, entry )
4068     {
4069         list_remove( &font->entry );
4070         DeleteObject( font->hfont );
4071         free( font );
4072     }
4073     free( dialog->default_font );
4074
4075     free( dialog->control_default );
4076     free( dialog->control_cancel );
4077     dialog->package = NULL;
4078     free( dialog );
4079 }
4080
4081 void msi_dialog_unregister_class( void )
4082 {
4083     DestroyWindow( hMsiHiddenWindow );
4084     hMsiHiddenWindow = NULL;
4085     UnregisterClassW( L"MsiDialogCloseClass", NULL );
4086     UnregisterClassW( L"MsiHiddenWindow", NULL );
4087     uiThreadId = 0;
4088 }
4089
4090 void msi_event_cleanup_all_subscriptions( MSIPACKAGE *package )
4091 {
4092     struct list *item, *next;
4093
4094     LIST_FOR_EACH_SAFE( item, next, &package->subscriptions )
4095     {
4096         struct subscriber *sub = LIST_ENTRY( item, struct subscriber, entry );
4097         list_remove( &sub->entry );
4098         free_subscriber( sub );
4099     }
4100 }
4101
4102 static void MSI_ClosePreview( MSIOBJECTHDR *arg )
4103 {
4104     MSIPREVIEW *preview = (MSIPREVIEW *)arg;
4105     msiobj_release( &preview->package->hdr );
4106 }
4107
4108 static MSIPREVIEW *MSI_EnableUIPreview( MSIDATABASE *db )
4109 {
4110     MSIPREVIEW *preview = NULL;
4111     MSIPACKAGE *package;
4112
4113     package = MSI_CreatePackage( db );
4114     if (package)
4115     {
4116         preview = alloc_msiobject( MSIHANDLETYPE_PREVIEW, sizeof(MSIPREVIEW), MSI_ClosePreview );
4117         if (preview)
4118         {
4119             preview->package = package;
4120             msiobj_addref( &package->hdr );
4121         }
4122         msiobj_release( &package->hdr );
4123     }
4124     return preview;
4125 }
4126
4127 UINT WINAPI MsiEnableUIPreview( MSIHANDLE hdb, MSIHANDLE *phPreview )
4128 {
4129     MSIDATABASE *db;
4130     MSIPREVIEW *preview;
4131     UINT r = ERROR_FUNCTION_FAILED;
4132
4133     TRACE( "%lu %p\n", hdb, phPreview );
4134
4135     if (!(db = msihandle2msiinfo(hdb, MSIHANDLETYPE_DATABASE)))
4136         return ERROR_INVALID_HANDLE;
4137
4138     preview = MSI_EnableUIPreview( db );
4139     if (preview)
4140     {
4141         *phPreview = alloc_msihandle( &preview->hdr );
4142         msiobj_release( &preview->hdr );
4143         r = ERROR_SUCCESS;
4144         if (!*phPreview)
4145             r = ERROR_NOT_ENOUGH_MEMORY;
4146     }
4147     msiobj_release( &db->hdr );
4148     return r;
4149 }
4150
4151 static UINT preview_event_handler( msi_dialog *dialog, const WCHAR *event, const WCHAR *argument )
4152 {
4153     MESSAGE("Preview dialog event '%s' (arg='%s')\n", debugstr_w(event), debugstr_w(argument));
4154     return ERROR_SUCCESS;
4155 }
4156
4157 static UINT MSI_PreviewDialogW( MSIPREVIEW *preview, LPCWSTR szDialogName )
4158 {
4159     msi_dialog *dialog = NULL;
4160     UINT r = ERROR_SUCCESS;
4161
4162     if (preview->dialog)
4163         msi_dialog_destroy( preview->dialog );
4164
4165     /* an empty name means we should just destroy the current preview dialog */
4166     if (szDialogName)
4167     {
4168         dialog = dialog_create( preview->package, szDialogName, NULL, preview_event_handler );
4169         if (dialog)
4170             dialog_do_preview( dialog );
4171         else
4172             r = ERROR_FUNCTION_FAILED;
4173     }
4174     preview->dialog = dialog;
4175     return r;
4176 }
4177
4178 UINT WINAPI MsiPreviewDialogW( MSIHANDLE hPreview, LPCWSTR szDialogName )
4179 {
4180     MSIPREVIEW *preview;
4181     UINT r;
4182
4183     TRACE( "%lu %s\n", hPreview, debugstr_w(szDialogName) );
4184
4185     preview = msihandle2msiinfo( hPreview, MSIHANDLETYPE_PREVIEW );
4186     if (!preview)
4187         return ERROR_INVALID_HANDLE;
4188
4189     r = MSI_PreviewDialogW( preview, szDialogName );
4190     msiobj_release( &preview->hdr );
4191     return r;
4192 }
4193
4194 UINT WINAPI MsiPreviewDialogA( MSIHANDLE hPreview, LPCSTR szDialogName )
4195 {
4196     UINT r;
4197     LPWSTR strW = NULL;
4198
4199     TRACE( "%lu %s\n", hPreview, debugstr_a(szDialogName) );
4200
4201     if (szDialogName)
4202     {
4203         strW = strdupAtoW( szDialogName );
4204         if (!strW)
4205             return ERROR_OUTOFMEMORY;
4206     }
4207     r = MsiPreviewDialogW( hPreview, strW );
4208     free( strW );
4209     return r;
4210 }
4211
4212 UINT WINAPI MsiPreviewBillboardW( MSIHANDLE hPreview, const WCHAR *szControlName, const WCHAR *szBillboard )
4213 {
4214     FIXME( "%lu %s %s\n", hPreview, debugstr_w(szControlName), debugstr_w(szBillboard) );
4215     return ERROR_CALL_NOT_IMPLEMENTED;
4216 }
4217
4218 UINT WINAPI MsiPreviewBillboardA( MSIHANDLE hPreview, const char *szControlName, const char *szBillboard )
4219 {
4220     FIXME( "%lu %s %s\n", hPreview, debugstr_a(szControlName), debugstr_a(szBillboard) );
4221     return ERROR_CALL_NOT_IMPLEMENTED;
4222 }
4223
4224 struct control_event
4225 {
4226     const WCHAR  *event;
4227     UINT (*handler)( msi_dialog *, const WCHAR * );
4228 };
4229
4230 static UINT dialog_event_handler( msi_dialog *, const WCHAR *, const WCHAR * );
4231
4232 /* create a dialog box and run it if it's modal */
4233 static INT event_do_dialog( MSIPACKAGE *package, const WCHAR *name, msi_dialog *parent, BOOL destroy_modeless )
4234 {
4235     msi_dialog *dialog;
4236     UINT r;
4237     INT retval;
4238
4239     /* create a new dialog */
4240     dialog = dialog_create( package, name, parent, dialog_event_handler );
4241     if (dialog)
4242     {
4243         /* kill the current modeless dialog */
4244         if (destroy_modeless && package->dialog)
4245         {
4246             msi_dialog_destroy( package->dialog );
4247             package->dialog = NULL;
4248         }
4249
4250         /* modeless dialogs return an error message */
4251         r = dialog_run_message_loop( dialog );
4252         if (r == ERROR_SUCCESS)
4253         {
4254             retval = dialog->retval;
4255             msi_dialog_destroy( dialog );
4256             return retval;
4257         }
4258         else
4259         {
4260             package->dialog = dialog;
4261             return IDOK;
4262         }
4263     }
4264     else return 0;
4265 }
4266
4267 /* end a modal dialog box */
4268 static UINT event_end_dialog( msi_dialog *dialog, const WCHAR *argument )
4269 {
4270     if (!wcscmp( argument, L"Exit" ))
4271         dialog->retval = IDCANCEL;
4272     else if (!wcscmp( argument, L"Retry" ))
4273         dialog->retval = IDRETRY;
4274     else if (!wcscmp( argument, L"Ignore" ))
4275         dialog->retval = IDOK;
4276     else if (!wcscmp( argument, L"Return" ))
4277         dialog->retval = 0;
4278     else
4279     {
4280         ERR("Unknown argument string %s\n", debugstr_w(argument));
4281         dialog->retval = IDABORT;
4282     }
4283     event_cleanup_subscriptions( dialog->package, dialog->name );
4284     dialog_end_dialog( dialog );
4285     return ERROR_SUCCESS;
4286 }
4287
4288 static UINT pending_event_end_dialog( msi_dialog *dialog, const WCHAR *argument )
4289 {
4290     dialog->pending_event = event_end_dialog;
4291     free( dialog->pending_argument );
4292     dialog->pending_argument = wcsdup( argument );
4293     return ERROR_SUCCESS;
4294 }
4295
4296 /* transition from one modal dialog to another modal dialog */
4297 static UINT event_new_dialog( msi_dialog *dialog, const WCHAR *argument )
4298 {
4299     /* store the name of the next dialog, and signal this one to end */
4300     dialog->package->next_dialog = wcsdup( argument );
4301     msi_event_cleanup_all_subscriptions( dialog->package );
4302     dialog_end_dialog( dialog );
4303     return ERROR_SUCCESS;
4304 }
4305
4306 static UINT pending_event_new_dialog( msi_dialog *dialog, const WCHAR *argument )
4307 {
4308     dialog->pending_event = event_new_dialog;
4309     free( dialog->pending_argument );
4310     dialog->pending_argument = wcsdup( argument );
4311     return ERROR_SUCCESS;
4312 }
4313
4314 /* create a new child dialog of an existing modal dialog */
4315 static UINT event_spawn_dialog( msi_dialog *dialog, const WCHAR *argument )
4316 {
4317     INT r;
4318     /* don't destroy a modeless dialogs that might be our parent */
4319     r = event_do_dialog( dialog->package, argument, dialog, FALSE );
4320     if (r != 0)
4321     {
4322         dialog->retval = r;
4323         dialog_end_dialog( dialog );
4324     }
4325     else
4326         dialog_update_all_controls(dialog);
4327
4328     return ERROR_SUCCESS;
4329 }
4330
4331 static UINT pending_event_spawn_dialog( msi_dialog *dialog, const WCHAR *argument )
4332 {
4333     dialog->pending_event = event_spawn_dialog;
4334     free( dialog->pending_argument );
4335     dialog->pending_argument = wcsdup( argument );
4336     return ERROR_SUCCESS;
4337 }
4338
4339 /* creates a dialog that remains up for a period of time based on a condition */
4340 static UINT event_spawn_wait_dialog( msi_dialog *dialog, const WCHAR *argument )
4341 {
4342     FIXME("doing nothing\n");
4343     return ERROR_SUCCESS;
4344 }
4345
4346 static UINT event_do_action( msi_dialog *dialog, const WCHAR *argument )
4347 {
4348     ACTION_PerformAction(dialog->package, argument);
4349     return ERROR_SUCCESS;
4350 }
4351
4352 static UINT event_add_local( msi_dialog *dialog, const WCHAR *argument )
4353 {
4354     MSIFEATURE *feature;
4355
4356     LIST_FOR_EACH_ENTRY( feature, &dialog->package->features, MSIFEATURE, entry )
4357     {
4358         if (!wcscmp( argument, feature->Feature ) || !wcscmp( argument, L"ALL" ))
4359         {
4360             if (feature->ActionRequest != INSTALLSTATE_LOCAL)
4361                 msi_set_property( dialog->package->db, L"Preselected", L"1", -1 );
4362             MSI_SetFeatureStateW( dialog->package, feature->Feature, INSTALLSTATE_LOCAL );
4363         }
4364     }
4365     return ERROR_SUCCESS;
4366 }
4367
4368 static UINT event_remove( msi_dialog *dialog, const WCHAR *argument )
4369 {
4370     MSIFEATURE *feature;
4371
4372     LIST_FOR_EACH_ENTRY( feature, &dialog->package->features, MSIFEATURE, entry )
4373     {
4374         if (!wcscmp( argument, feature->Feature ) || !wcscmp( argument, L"ALL" ))
4375         {
4376             if (feature->ActionRequest != INSTALLSTATE_ABSENT)
4377                 msi_set_property( dialog->package->db, L"Preselected", L"1", -1 );
4378             MSI_SetFeatureStateW( dialog->package, feature->Feature, INSTALLSTATE_ABSENT );
4379         }
4380     }
4381     return ERROR_SUCCESS;
4382 }
4383
4384 static UINT event_add_source( msi_dialog *dialog, const WCHAR *argument )
4385 {
4386     MSIFEATURE *feature;
4387
4388     LIST_FOR_EACH_ENTRY( feature, &dialog->package->features, MSIFEATURE, entry )
4389     {
4390         if (!wcscmp( argument, feature->Feature ) || !wcscmp( argument, L"ALL" ))
4391         {
4392             if (feature->ActionRequest != INSTALLSTATE_SOURCE)
4393                 msi_set_property( dialog->package->db, L"Preselected", L"1", -1 );
4394             MSI_SetFeatureStateW( dialog->package, feature->Feature, INSTALLSTATE_SOURCE );
4395         }
4396     }
4397     return ERROR_SUCCESS;
4398 }
4399
4400 void msi_event_fire( MSIPACKAGE *package, const WCHAR *event, MSIRECORD *rec )
4401 {
4402     struct subscriber *sub;
4403
4404     TRACE("firing event %s\n", debugstr_w(event));
4405
4406     LIST_FOR_EACH_ENTRY( sub, &package->subscriptions, struct subscriber, entry )
4407     {
4408         if (wcsicmp( sub->event, event )) continue;
4409         dialog_handle_event( sub->dialog, sub->control, sub->attribute, rec );
4410     }
4411 }
4412
4413 static UINT event_set_target_path( msi_dialog *dialog, const WCHAR *argument )
4414 {
4415     WCHAR *path = msi_dup_property( dialog->package->db, argument );
4416     MSIRECORD *rec = MSI_CreateRecord( 1 );
4417     UINT r = ERROR_SUCCESS;
4418
4419     MSI_RecordSetStringW( rec, 1, path );
4420     msi_event_fire( dialog->package, L"SelectionPath", rec );
4421     if (path)
4422     {
4423         /* failure to set the path halts the executing of control events */
4424         r = MSI_SetTargetPathW( dialog->package, argument, path );
4425         free( path );
4426     }
4427     msiobj_release( &rec->hdr );
4428     return r;
4429 }
4430
4431 static UINT event_reset( msi_dialog *dialog, const WCHAR *argument )
4432 {
4433     dialog_reset( dialog );
4434     return ERROR_SUCCESS;
4435 }
4436
4437 INT ACTION_ShowDialog( MSIPACKAGE *package, const WCHAR *dialog )
4438 {
4439     MSIRECORD *row;
4440     INT rc;
4441
4442     if (!TABLE_Exists(package->db, L"Dialog")) return 0;
4443
4444     row = MSI_CreateRecord(0);
4445     if (!row) return -1;
4446     MSI_RecordSetStringW(row, 0, dialog);
4447     rc = MSI_ProcessMessage(package, INSTALLMESSAGE_SHOWDIALOG, row);
4448     msiobj_release(&row->hdr);
4449
4450     if (rc == -2) rc = 0;
4451
4452     if (!rc)
4453     {
4454         MSIRECORD *row = MSI_CreateRecord(2);
4455         if (!row) return -1;
4456         MSI_RecordSetInteger(row, 1, 2726);
4457         MSI_RecordSetStringW(row, 2, dialog);
4458         MSI_ProcessMessage(package, INSTALLMESSAGE_INFO, row);
4459
4460         msiobj_release(&row->hdr);
4461     }
4462     return rc;
4463 }
4464
4465 INT ACTION_DialogBox( MSIPACKAGE *package, const WCHAR *dialog )
4466 {
4467     INT r;
4468
4469     if (package->next_dialog) ERR("Already got next dialog... ignoring it\n");
4470     package->next_dialog = NULL;
4471
4472     /* Dialogs are chained through NewDialog, which sets the next_dialog member.
4473      * We fall out of the loop if we reach a modeless dialog, which immediately
4474      * returns IDOK, or an EndDialog event, which returns the value corresponding
4475      * to its argument.
4476      */
4477     r = event_do_dialog( package, dialog, NULL, TRUE );
4478     while (package->next_dialog)
4479     {
4480         WCHAR *name = package->next_dialog;
4481
4482         package->next_dialog = NULL;
4483         r = event_do_dialog( package, name, NULL, TRUE );
4484         free( name );
4485     }
4486     return r;
4487 }
4488
4489 static UINT event_set_install_level( msi_dialog *dialog, const WCHAR *argument )
4490 {
4491     int level = wcstol( argument, NULL, 10 );
4492
4493     TRACE("setting install level to %d\n", level);
4494     return MSI_SetInstallLevel( dialog->package, level );
4495 }
4496
4497 static UINT event_directory_list_up( msi_dialog *dialog, const WCHAR *argument )
4498 {
4499     return dialog_directorylist_up( dialog );
4500 }
4501
4502 static UINT event_directory_list_new( msi_dialog *dialog, const WCHAR *argument )
4503 {
4504     return dialog_directorylist_new( dialog );
4505 }
4506
4507 static UINT event_reinstall_mode( msi_dialog *dialog, const WCHAR *argument )
4508 {
4509     return msi_set_property( dialog->package->db, L"REINSTALLMODE", argument, -1 );
4510 }
4511
4512 static UINT event_reinstall( msi_dialog *dialog, const WCHAR *argument )
4513 {
4514     return msi_set_property( dialog->package->db, L"REINSTALL", argument, -1 );
4515 }
4516
4517 static UINT event_validate_product_id( msi_dialog *dialog, const WCHAR *argument )
4518 {
4519     return msi_validate_product_id( dialog->package );
4520 }
4521
4522 static const struct control_event control_events[] =
4523 {
4524     { L"EndDialog", pending_event_end_dialog },
4525     { L"NewDialog", pending_event_new_dialog },
4526     { L"SpawnDialog", pending_event_spawn_dialog },
4527     { L"SpawnWaitDialog", event_spawn_wait_dialog },
4528     { L"DoAction", event_do_action },
4529     { L"AddLocal", event_add_local },
4530     { L"Remove", event_remove },
4531     { L"AddSource", event_add_source },
4532     { L"SetTargetPath", event_set_target_path },
4533     { L"Reset", event_reset },
4534     { L"SetInstallLevel", event_set_install_level },
4535     { L"DirectoryListUp", event_directory_list_up },
4536     { L"DirectoryListNew", event_directory_list_new },
4537     { L"SelectionBrowse", event_spawn_dialog },
4538     { L"ReinstallMode", event_reinstall_mode },
4539     { L"Reinstall", event_reinstall },
4540     { L"ValidateProductID", event_validate_product_id },
4541     { NULL, NULL }
4542 };
4543
4544 static UINT dialog_event_handler( msi_dialog *dialog, const WCHAR *event, const WCHAR *argument )
4545 {
4546     unsigned int i;
4547
4548     TRACE("handling event %s\n", debugstr_w(event));
4549
4550     if (!event) return ERROR_SUCCESS;
4551
4552     for (i = 0; control_events[i].event; i++)
4553     {
4554         if (!wcscmp( control_events[i].event, event ))
4555             return control_events[i].handler( dialog, argument );
4556     }
4557     FIXME("unhandled event %s arg(%s)\n", debugstr_w(event), debugstr_w(argument));
4558     return ERROR_SUCCESS;
4559 }