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) *(ptr - 1) = '\0';
2866     PathAddBackslashW( path );
2867
2868     dialog_set_property( dialog->package, prop, path );
2869
2870     dialog_update_directory_list( dialog, NULL );
2871     dialog_update_directory_combo( dialog, NULL );
2872     dialog_update_pathedit( dialog, NULL );
2873
2874     free( path );
2875     free( prop );
2876
2877     return ERROR_SUCCESS;
2878 }
2879
2880 static WCHAR *get_unique_folder_name( const WCHAR *root, int *ret_len )
2881 {
2882     WCHAR newfolder[MAX_PATH], *path, *ptr;
2883     int len, count = 2;
2884
2885     len = LoadStringW( msi_hInstance, IDS_NEWFOLDER, newfolder, ARRAY_SIZE(newfolder) );
2886     len += lstrlenW(root) + 1;
2887     if (!(path = malloc( (len + 4) * sizeof(WCHAR) ))) return NULL;
2888     lstrcpyW( path, root );
2889     lstrcatW( path, newfolder );
2890
2891     for (;;)
2892     {
2893         if (GetFileAttributesW( path ) == INVALID_FILE_ATTRIBUTES) break;
2894         if (count > 99)
2895         {
2896             free( path );
2897             return NULL;
2898         }
2899         swprintf( path, len + 4, L"%s%s %u", root, newfolder, count++ );
2900     }
2901
2902     ptr = wcsrchr( path, '\\' ) + 1;
2903     *ret_len = lstrlenW(ptr);
2904     memmove( path, ptr, *ret_len * sizeof(WCHAR) );
2905     return path;
2906 }
2907
2908 static UINT dialog_directorylist_new( msi_dialog *dialog )
2909 {
2910     struct control *control;
2911     WCHAR *path;
2912     LVITEMW item;
2913     int index;
2914
2915     control = dialog_find_control_by_type( dialog, L"DirectoryList" );
2916
2917     if (!(path = get_path_property( dialog, control ))) return ERROR_OUTOFMEMORY;
2918
2919     item.mask = LVIF_TEXT;
2920     item.iItem = 0;
2921     item.iSubItem = 0;
2922     item.pszText = get_unique_folder_name( path, &item.cchTextMax );
2923
2924     index = SendMessageW( control->hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item );
2925     SendMessageW( control->hwnd, LVM_ENSUREVISIBLE, index, 0 );
2926     SendMessageW( control->hwnd, LVM_EDITLABELW, index, -1 );
2927
2928     free( path );
2929     free( item.pszText );
2930     return ERROR_SUCCESS;
2931 }
2932
2933 static UINT dialog_dirlist_handler( msi_dialog *dialog, struct control *control, WPARAM param )
2934 {
2935     NMHDR *nmhdr = (NMHDR *)param;
2936     WCHAR text[MAX_PATH], *new_path, *path, *prop;
2937     BOOL indirect;
2938
2939     switch (nmhdr->code)
2940     {
2941     case LVN_ENDLABELEDITW:
2942     {
2943         NMLVDISPINFOW *info = (NMLVDISPINFOW *)param;
2944         if (!info->item.pszText) return ERROR_SUCCESS;
2945         lstrcpynW( text, info->item.pszText, ARRAY_SIZE(text) );
2946         text[ARRAY_SIZE(text) - 1] = 0;
2947         break;
2948     }
2949     case LVN_ITEMACTIVATE:
2950     {
2951         LVITEMW item;
2952         int index = SendMessageW( control->hwnd, LVM_GETNEXTITEM, -1, LVNI_SELECTED );
2953         if (index < 0)
2954         {
2955             ERR("no list-view item selected\n");
2956             return ERROR_FUNCTION_FAILED;
2957         }
2958
2959         item.iSubItem = 0;
2960         item.pszText = text;
2961         item.cchTextMax = MAX_PATH;
2962         SendMessageW( control->hwnd, LVM_GETITEMTEXTW, index, (LPARAM)&item );
2963         text[ARRAY_SIZE(text) - 1] = 0;
2964         break;
2965     }
2966     default:
2967         return ERROR_SUCCESS;
2968     }
2969
2970     indirect = control->attributes & msidbControlAttributesIndirect;
2971     prop = dialog_dup_property( dialog, control->property, indirect );
2972     path = dialog_dup_property( dialog, prop, TRUE );
2973
2974     if (!(new_path = malloc( (wcslen(path) + wcslen(text) + 2) * sizeof(WCHAR) )))
2975     {
2976         free( prop );
2977         free( path );
2978         return ERROR_OUTOFMEMORY;
2979     }
2980     lstrcpyW( new_path, path );
2981     lstrcatW( new_path, text );
2982     if (nmhdr->code == LVN_ENDLABELEDITW) CreateDirectoryW( new_path, NULL );
2983     lstrcatW( new_path, L"\\" );
2984
2985     dialog_set_property( dialog->package, prop, new_path );
2986
2987     dialog_update_directory_list( dialog, NULL );
2988     dialog_update_directory_combo( dialog, NULL );
2989     dialog_update_pathedit( dialog, NULL );
2990
2991     free( prop );
2992     free( path );
2993     free( new_path );
2994
2995     return ERROR_SUCCESS;
2996 }
2997
2998 static UINT dialog_directory_list( msi_dialog *dialog, MSIRECORD *rec )
2999 {
3000     struct control *control;
3001     LPCWSTR prop;
3002     DWORD style;
3003
3004     style = LVS_LIST | WS_VSCROLL | LVS_SHAREIMAGELISTS | LVS_EDITLABELS |
3005             LVS_AUTOARRANGE | LVS_SINGLESEL | WS_BORDER |
3006             LVS_SORTASCENDING | WS_CHILD | WS_GROUP | WS_TABSTOP;
3007     control = dialog_add_control( dialog, rec, WC_LISTVIEWW, style );
3008     if (!control)
3009         return ERROR_FUNCTION_FAILED;
3010
3011     control->attributes = MSI_RecordGetInteger( rec, 8 );
3012     control->handler = dialog_dirlist_handler;
3013     prop = MSI_RecordGetString( rec, 9 );
3014     control->property = dialog_dup_property( dialog, prop, FALSE );
3015
3016     /* double click to activate an item in the list */
3017     SendMessageW( control->hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE,
3018                   0, LVS_EX_TWOCLICKACTIVATE );
3019
3020     dialog_update_directory_list( dialog, control );
3021
3022     return ERROR_SUCCESS;
3023 }
3024
3025 /******************** VolumeCost List ***************************************/
3026
3027 static BOOL str_is_number( LPCWSTR str )
3028 {
3029     int i;
3030
3031     for (i = 0; i < lstrlenW( str ); i++)
3032         if (!iswdigit(str[i]))
3033             return FALSE;
3034
3035     return TRUE;
3036 }
3037
3038 static const WCHAR column_keys[][80] =
3039 {
3040     L"VolumeCostVolume",
3041     L"VolumeCostSize",
3042     L"VolumeCostAvailable",
3043     L"VolumeCostRequired",
3044     L"VolumeCostDifference",
3045 };
3046
3047 static void dialog_vcl_add_columns( msi_dialog *dialog, struct control *control, MSIRECORD *rec )
3048 {
3049     LPCWSTR text = MSI_RecordGetString( rec, 10 );
3050     LPCWSTR begin = text, end;
3051     WCHAR *num;
3052     LVCOLUMNW lvc;
3053     DWORD count = 0;
3054
3055     if (!text) return;
3056
3057     while ((begin = wcschr( begin, '{' )) && count < 5)
3058     {
3059         if (!(end = wcschr( begin, '}' )))
3060             return;
3061
3062         num = malloc( (end - begin + 1) * sizeof(WCHAR) );
3063         if (!num)
3064             return;
3065
3066         lstrcpynW( num, begin + 1, end - begin );
3067         begin += end - begin + 1;
3068
3069         /* empty braces or '0' hides the column */
3070         if ( !num[0] || !wcscmp( num, L"0" ) )
3071         {
3072             count++;
3073             free( num );
3074             continue;
3075         }
3076
3077         /* the width must be a positive number
3078          * if a width is invalid, all remaining columns are hidden
3079          */
3080         if ( !wcsncmp( num, L"-", 1 ) || !str_is_number( num ) ) {
3081             free( num );
3082             return;
3083         }
3084
3085         ZeroMemory( &lvc, sizeof(lvc) );
3086         lvc.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
3087         lvc.cx = wcstol( num, NULL, 10 );
3088         lvc.pszText = dialog_get_uitext( dialog, column_keys[count] );
3089
3090         SendMessageW( control->hwnd,  LVM_INSERTCOLUMNW, count++, (LPARAM)&lvc );
3091         free( lvc.pszText );
3092         free( num );
3093     }
3094 }
3095
3096 static LONGLONG vcl_get_cost( msi_dialog *dialog )
3097 {
3098     MSIFEATURE *feature;
3099     INT each_cost;
3100     LONGLONG total_cost = 0;
3101
3102     LIST_FOR_EACH_ENTRY( feature, &dialog->package->features, MSIFEATURE, entry )
3103     {
3104         if (ERROR_SUCCESS == (MSI_GetFeatureCost(dialog->package, feature,
3105                 MSICOSTTREE_SELFONLY, INSTALLSTATE_LOCAL, &each_cost)))
3106         {
3107             /* each_cost is in 512-byte units */
3108             total_cost += each_cost * 512;
3109         }
3110         if (ERROR_SUCCESS == (MSI_GetFeatureCost(dialog->package, feature,
3111                 MSICOSTTREE_SELFONLY, INSTALLSTATE_ABSENT, &each_cost)))
3112         {
3113             /* each_cost is in 512-byte units */
3114             total_cost -= each_cost * 512;
3115         }
3116     }
3117     return total_cost;
3118 }
3119
3120 static void dialog_vcl_add_drives( msi_dialog *dialog, struct control *control )
3121 {
3122     ULARGE_INTEGER total, unused;
3123     LONGLONG difference, cost;
3124     WCHAR size_text[MAX_PATH];
3125     WCHAR cost_text[MAX_PATH];
3126     LPWSTR drives, ptr;
3127     LVITEMW lvitem;
3128     DWORD size, flags;
3129     int i = 0;
3130
3131     cost = vcl_get_cost(dialog);
3132     StrFormatByteSizeW(cost, cost_text, MAX_PATH);
3133
3134     size = GetLogicalDriveStringsW( 0, NULL );
3135     if ( !size ) return;
3136
3137     drives = malloc( (size + 1) * sizeof(WCHAR) );
3138     if ( !drives ) return;
3139
3140     GetLogicalDriveStringsW( size, drives );
3141
3142     ptr = drives;
3143     while (*ptr)
3144     {
3145         if (GetVolumeInformationW(ptr, NULL, 0, NULL, 0, &flags, NULL, 0) &&
3146             flags & FILE_READ_ONLY_VOLUME)
3147         {
3148             ptr += lstrlenW(ptr) + 1;
3149             continue;
3150         }
3151
3152         lvitem.mask = LVIF_TEXT;
3153         lvitem.iItem = i;
3154         lvitem.iSubItem = 0;
3155         lvitem.pszText = ptr;
3156         lvitem.cchTextMax = lstrlenW(ptr) + 1;
3157         SendMessageW( control->hwnd, LVM_INSERTITEMW, 0, (LPARAM)&lvitem );
3158
3159         GetDiskFreeSpaceExW(ptr, &unused, &total, NULL);
3160         difference = unused.QuadPart - cost;
3161
3162         StrFormatByteSizeW(total.QuadPart, size_text, MAX_PATH);
3163         lvitem.iSubItem = 1;
3164         lvitem.pszText = size_text;
3165         lvitem.cchTextMax = lstrlenW(size_text) + 1;
3166         SendMessageW( control->hwnd, LVM_SETITEMW, 0, (LPARAM)&lvitem );
3167
3168         StrFormatByteSizeW(unused.QuadPart, size_text, MAX_PATH);
3169         lvitem.iSubItem = 2;
3170         lvitem.pszText = size_text;
3171         lvitem.cchTextMax = lstrlenW(size_text) + 1;
3172         SendMessageW( control->hwnd, LVM_SETITEMW, 0, (LPARAM)&lvitem );
3173
3174         lvitem.iSubItem = 3;
3175         lvitem.pszText = cost_text;
3176         lvitem.cchTextMax = lstrlenW(cost_text) + 1;
3177         SendMessageW( control->hwnd, LVM_SETITEMW, 0, (LPARAM)&lvitem );
3178
3179         StrFormatByteSizeW(difference, size_text, MAX_PATH);
3180         lvitem.iSubItem = 4;
3181         lvitem.pszText = size_text;
3182         lvitem.cchTextMax = lstrlenW(size_text) + 1;
3183         SendMessageW( control->hwnd, LVM_SETITEMW, 0, (LPARAM)&lvitem );
3184
3185         ptr += lstrlenW(ptr) + 1;
3186         i++;
3187     }
3188
3189     free( drives );
3190 }
3191
3192 static UINT dialog_volumecost_list( msi_dialog *dialog, MSIRECORD *rec )
3193 {
3194     struct control *control;
3195     DWORD style;
3196
3197     style = LVS_REPORT | WS_VSCROLL | WS_HSCROLL | LVS_SHAREIMAGELISTS |
3198             LVS_AUTOARRANGE | LVS_SINGLESEL | WS_BORDER |
3199             WS_CHILD | WS_TABSTOP | WS_GROUP;
3200     control = dialog_add_control( dialog, rec, WC_LISTVIEWW, style );
3201     if (!control)
3202         return ERROR_FUNCTION_FAILED;
3203
3204     dialog_vcl_add_columns( dialog, control, rec );
3205     dialog_vcl_add_drives( dialog, control );
3206
3207     return ERROR_SUCCESS;
3208 }
3209
3210 /******************** VolumeSelect Combo ***************************************/
3211
3212 static UINT dialog_volsel_handler( msi_dialog *dialog, struct control *control, WPARAM param )
3213 {
3214     WCHAR text[MAX_PATH];
3215     LPWSTR prop;
3216     BOOL indirect;
3217     int index;
3218
3219     if (HIWORD(param) != CBN_SELCHANGE)
3220         return ERROR_SUCCESS;
3221
3222     index = SendMessageW( control->hwnd, CB_GETCURSEL, 0, 0 );
3223     if ( index == CB_ERR )
3224     {
3225         ERR("No ComboBox item selected!\n");
3226         return ERROR_FUNCTION_FAILED;
3227     }
3228
3229     SendMessageW( control->hwnd, CB_GETLBTEXT, index, (LPARAM)text );
3230
3231     indirect = control->attributes & msidbControlAttributesIndirect;
3232     prop = dialog_dup_property( dialog, control->property, indirect );
3233
3234     dialog_set_property( dialog->package, prop, text );
3235
3236     free( prop );
3237     return ERROR_SUCCESS;
3238 }
3239
3240 static void dialog_vsc_add_drives( msi_dialog *dialog, struct control *control )
3241 {
3242     LPWSTR drives, ptr;
3243     DWORD size;
3244
3245     size = GetLogicalDriveStringsW( 0, NULL );
3246     if ( !size ) return;
3247
3248     drives = malloc( (size + 1) * sizeof(WCHAR) );
3249     if ( !drives ) return;
3250
3251     GetLogicalDriveStringsW( size, drives );
3252
3253     ptr = drives;
3254     while (*ptr)
3255     {
3256         SendMessageW( control->hwnd, CB_ADDSTRING, 0, (LPARAM)ptr );
3257         ptr += lstrlenW(ptr) + 1;
3258     }
3259
3260     free( drives );
3261 }
3262
3263 static UINT dialog_volumeselect_combo( msi_dialog *dialog, MSIRECORD *rec )
3264 {
3265     struct control *control;
3266     LPCWSTR prop;
3267     DWORD style;
3268
3269     /* FIXME: CBS_OWNERDRAWFIXED */
3270     style = WS_CHILD | WS_VISIBLE | WS_GROUP | WS_TABSTOP |
3271             CBS_DROPDOWNLIST | CBS_SORT | CBS_HASSTRINGS |
3272             WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR;
3273     control = dialog_add_control( dialog, rec, WC_COMBOBOXW, style );
3274     if (!control)
3275         return ERROR_FUNCTION_FAILED;
3276
3277     control->attributes = MSI_RecordGetInteger( rec, 8 );
3278     control->handler = dialog_volsel_handler;
3279     prop = MSI_RecordGetString( rec, 9 );
3280     control->property = dialog_dup_property( dialog, prop, FALSE );
3281
3282     dialog_vsc_add_drives( dialog, control );
3283
3284     return ERROR_SUCCESS;
3285 }
3286
3287 static UINT dialog_hyperlink_handler( msi_dialog *dialog, struct control *control, WPARAM param )
3288 {
3289     int len, len_href = ARRAY_SIZE( L"href" ) - 1;
3290     const WCHAR *p, *q;
3291     WCHAR quote = 0;
3292     LITEM item;
3293
3294     item.mask     = LIF_ITEMINDEX | LIF_URL;
3295     item.iLink    = 0;
3296     item.szUrl[0] = 0;
3297
3298     SendMessageW( control->hwnd, LM_GETITEM, 0, (LPARAM)&item );
3299
3300     p = item.szUrl;
3301     while (*p && *p != '<') p++;
3302     if (!*p++) return ERROR_SUCCESS;
3303     if (towupper( *p++ ) != 'A' || !iswspace( *p++ )) return ERROR_SUCCESS;
3304     while (*p && iswspace( *p )) p++;
3305
3306     len = lstrlenW( p );
3307     if (len > len_href && !wcsnicmp( p, L"href", len_href ))
3308     {
3309         p += len_href;
3310         while (*p && iswspace( *p )) p++;
3311         if (!*p || *p++ != '=') return ERROR_SUCCESS;
3312         while (*p && iswspace( *p )) p++;
3313
3314         if (*p == '\"' || *p == '\'') quote = *p++;
3315         q = p;
3316         if (quote)
3317         {
3318             while (*q && *q != quote) q++;
3319             if (*q != quote) return ERROR_SUCCESS;
3320         }
3321         else
3322         {
3323             while (*q && *q != '>' && !iswspace( *q )) q++;
3324             if (!*q) return ERROR_SUCCESS;
3325         }
3326         item.szUrl[q - item.szUrl] = 0;
3327         ShellExecuteW( NULL, L"open", p, NULL, NULL, SW_SHOWNORMAL );
3328     }
3329     return ERROR_SUCCESS;
3330 }
3331
3332 static UINT dialog_hyperlink( msi_dialog *dialog, MSIRECORD *rec )
3333 {
3334     struct control *control;
3335     DWORD style = WS_CHILD | WS_TABSTOP | WS_GROUP;
3336     const WCHAR *text = MSI_RecordGetString( rec, 10 );
3337     int len = lstrlenW( text );
3338     LITEM item;
3339
3340     control = dialog_add_control( dialog, rec, WC_LINK, style );
3341     if (!control)
3342         return ERROR_FUNCTION_FAILED;
3343
3344     control->attributes = MSI_RecordGetInteger( rec, 8 );
3345     control->handler    = dialog_hyperlink_handler;
3346
3347     item.mask      = LIF_ITEMINDEX | LIF_STATE | LIF_URL;
3348     item.iLink     = 0;
3349     item.state     = LIS_ENABLED;
3350     item.stateMask = LIS_ENABLED;
3351     if (len < L_MAX_URL_LENGTH) lstrcpyW( item.szUrl, text );
3352     else item.szUrl[0] = 0;
3353
3354     SendMessageW( control->hwnd, LM_SETITEM, 0, (LPARAM)&item );
3355
3356     return ERROR_SUCCESS;
3357 }
3358
3359 /******************** ListView *****************************************/
3360
3361 struct listview_param
3362 {
3363     msi_dialog *dialog;
3364     struct control *control;
3365 };
3366
3367 static UINT dialog_listview_handler( msi_dialog *dialog, struct control *control, WPARAM param )
3368 {
3369     NMHDR *nmhdr = (NMHDR *)param;
3370
3371     FIXME("code %#x (%d)\n", nmhdr->code, nmhdr->code);
3372
3373     return ERROR_SUCCESS;
3374 }
3375
3376 static UINT listview_add_item( MSIRECORD *rec, void *param )
3377 {
3378     struct listview_param *lv_param = (struct listview_param *)param;
3379     LPCWSTR text, binary;
3380     LVITEMW item;
3381     HICON hIcon;
3382
3383     text = MSI_RecordGetString( rec, 4 );
3384     binary = MSI_RecordGetString( rec, 5 );
3385     hIcon = load_icon( lv_param->dialog->package->db, binary, 0 );
3386
3387     TRACE("Adding: text %s, binary %s, icon %p\n", debugstr_w(text), debugstr_w(binary), hIcon);
3388
3389     memset( &item, 0, sizeof(item) );
3390     item.mask = LVIF_TEXT | LVIF_IMAGE;
3391     deformat_string( lv_param->dialog->package, text, &item.pszText );
3392     item.iImage = ImageList_AddIcon( lv_param->control->hImageList, hIcon );
3393     item.iItem = item.iImage;
3394     SendMessageW( lv_param->control->hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item );
3395
3396     DestroyIcon( hIcon );
3397
3398     return ERROR_SUCCESS;
3399 }
3400
3401 static UINT listview_add_items( msi_dialog *dialog, struct control *control )
3402 {
3403     MSIQUERY *view;
3404     struct listview_param lv_param = { dialog, control };
3405
3406     if (MSI_OpenQuery( dialog->package->db, &view, L"SELECT * FROM `ListView` WHERE `Property` = '%s' ORDER BY `Order`",
3407                        control->property ) == ERROR_SUCCESS)
3408     {
3409         MSI_IterateRecords( view, NULL, listview_add_item, &lv_param );
3410         msiobj_release( &view->hdr );
3411     }
3412
3413     return ERROR_SUCCESS;
3414 }
3415
3416 static UINT dialog_listview( msi_dialog *dialog, MSIRECORD *rec )
3417 {
3418     struct control *control;
3419     LPCWSTR prop;
3420     DWORD style, attributes;
3421     LVCOLUMNW col;
3422     RECT rc;
3423
3424     style = LVS_REPORT | LVS_NOCOLUMNHEADER | LVS_SHAREIMAGELISTS | LVS_SINGLESEL |
3425             LVS_SHOWSELALWAYS | WS_VSCROLL | WS_HSCROLL | WS_BORDER | WS_TABSTOP | WS_CHILD;
3426     attributes = MSI_RecordGetInteger( rec, 8 );
3427     if ( ~attributes & msidbControlAttributesSorted )
3428         style |= LVS_SORTASCENDING;
3429     control = dialog_add_control( dialog, rec, WC_LISTVIEWW, style );
3430     if (!control)
3431         return ERROR_FUNCTION_FAILED;
3432
3433     prop = MSI_RecordGetString( rec, 9 );
3434     control->property = dialog_dup_property( dialog, prop, FALSE );
3435
3436     control->hImageList = ImageList_Create( 16, 16, ILC_COLOR32, 0, 1);
3437     SendMessageW( control->hwnd, LVM_SETIMAGELIST, LVSIL_SMALL, (LPARAM)control->hImageList );
3438
3439     col.mask = LVCF_FMT | LVCF_WIDTH;
3440     col.fmt = LVCFMT_LEFT;
3441     col.cx = 16;
3442     SendMessageW( control->hwnd, LVM_INSERTCOLUMNW, 0, (LPARAM)&col );
3443
3444     GetClientRect( control->hwnd, &rc );
3445     col.cx = rc.right - 16;
3446     SendMessageW( control->hwnd, LVM_INSERTCOLUMNW, 0, (LPARAM)&col );
3447
3448     if (control->property)
3449         listview_add_items( dialog, control );
3450
3451     control->handler = dialog_listview_handler;
3452
3453     return ERROR_SUCCESS;
3454 }
3455
3456 static const struct control_handler msi_dialog_handler[] =
3457 {
3458     { L"Text", dialog_text_control },
3459     { L"PushButton", dialog_button_control },
3460     { L"Line", dialog_line_control },
3461     { L"Bitmap", dialog_bitmap_control },
3462     { L"CheckBox", dialog_checkbox_control },
3463     { L"ScrollableText", dialog_scrolltext_control },
3464     { L"ComboBox", dialog_combo_control },
3465     { L"Edit", dialog_edit_control },
3466     { L"MaskedEdit", dialog_maskedit_control },
3467     { L"PathEdit", dialog_pathedit_control },
3468     { L"ProgressBar", dialog_progress_bar },
3469     { L"RadioButtonGroup", dialog_radiogroup_control },
3470     { L"Icon", dialog_icon_control },
3471     { L"SelectionTree", dialog_selection_tree },
3472     { L"GroupBox", dialog_group_box },
3473     { L"ListBox", dialog_list_box },
3474     { L"DirectoryCombo", dialog_directory_combo },
3475     { L"DirectoryList", dialog_directory_list },
3476     { L"VolumeCostList", dialog_volumecost_list },
3477     { L"VolumeSelectCombo", dialog_volumeselect_combo },
3478     { L"HyperLink", dialog_hyperlink },
3479     { L"ListView", dialog_listview }
3480 };
3481
3482 static UINT dialog_create_controls( MSIRECORD *rec, void *param )
3483 {
3484     msi_dialog *dialog = param;
3485     LPCWSTR control_type;
3486     UINT i;
3487
3488     /* find and call the function that can create this type of control */
3489     control_type = MSI_RecordGetString( rec, 3 );
3490     for( i = 0; i < ARRAY_SIZE( msi_dialog_handler ); i++ )
3491         if (!wcsicmp( msi_dialog_handler[i].control_type, control_type ))
3492             break;
3493     if( i != ARRAY_SIZE( msi_dialog_handler  ))
3494         msi_dialog_handler[i].func( dialog, rec );
3495     else
3496         ERR("no handler for element type %s\n", debugstr_w(control_type));
3497
3498     return ERROR_SUCCESS;
3499 }
3500
3501 static UINT dialog_fill_controls( msi_dialog *dialog )
3502 {
3503     UINT r;
3504     MSIQUERY *view;
3505     MSIPACKAGE *package = dialog->package;
3506
3507     TRACE("%p %s\n", dialog, debugstr_w(dialog->name) );
3508
3509     /* query the Control table for all the elements of the control */
3510     r = MSI_OpenQuery( package->db, &view, L"SELECT * FROM `Control` WHERE `Dialog_` = '%s'", dialog->name );
3511     if( r != ERROR_SUCCESS )
3512     {
3513         ERR("query failed for dialog %s\n", debugstr_w(dialog->name));
3514         return ERROR_INVALID_PARAMETER;
3515     }
3516
3517     r = MSI_IterateRecords( view, 0, dialog_create_controls, dialog );
3518     msiobj_release( &view->hdr );
3519     return r;
3520 }
3521
3522 static UINT dialog_reset( msi_dialog *dialog )
3523 {
3524     /* FIXME: should restore the original values of any properties we changed */
3525     return dialog_evaluate_control_conditions( dialog );
3526 }
3527
3528 /* figure out the height of 10 point MS Sans Serif */
3529 static INT dialog_get_sans_serif_height( HWND hwnd )
3530 {
3531     LOGFONTW lf;
3532     TEXTMETRICW tm;
3533     BOOL r;
3534     LONG height = 0;
3535     HFONT hFont, hOldFont;
3536     HDC hdc;
3537
3538     hdc = GetDC( hwnd );
3539     if (hdc)
3540     {
3541         memset( &lf, 0, sizeof lf );
3542         lf.lfHeight = MulDiv(12, GetDeviceCaps(hdc, LOGPIXELSY), 72);
3543         lstrcpyW( lf.lfFaceName, L"MS Sans Serif" );
3544         hFont = CreateFontIndirectW(&lf);
3545         if (hFont)
3546         {
3547             hOldFont = SelectObject( hdc, hFont );
3548             r = GetTextMetricsW( hdc, &tm );
3549             if (r)
3550                 height = tm.tmHeight;
3551             SelectObject( hdc, hOldFont );
3552             DeleteObject( hFont );
3553         }
3554         ReleaseDC( hwnd, hdc );
3555     }
3556     return height;
3557 }
3558
3559 /* fetch the associated record from the Dialog table */
3560 static MSIRECORD *get_dialog_record( msi_dialog *dialog )
3561 {
3562     MSIPACKAGE *package = dialog->package;
3563     MSIRECORD *rec = NULL;
3564
3565     TRACE("%p %s\n", dialog, debugstr_w(dialog->name) );
3566
3567     rec = MSI_QueryGetRecord( package->db, L"SELECT * FROM `Dialog` WHERE `Dialog` = '%s'", dialog->name );
3568     if( !rec )
3569         WARN("query failed for dialog %s\n", debugstr_w(dialog->name));
3570
3571     return rec;
3572 }
3573
3574 static void dialog_adjust_dialog_pos( msi_dialog *dialog, MSIRECORD *rec, RECT *pos )
3575 {
3576     UINT xres, yres;
3577     POINT center;
3578     SIZE sz;
3579     LONG style;
3580
3581     center.x = MSI_RecordGetInteger( rec, 2 );
3582     center.y = MSI_RecordGetInteger( rec, 3 );
3583
3584     sz.cx = MSI_RecordGetInteger( rec, 4 );
3585     sz.cy = MSI_RecordGetInteger( rec, 5 );
3586
3587     sz.cx = dialog_scale_unit( dialog, sz.cx );
3588     sz.cy = dialog_scale_unit( dialog, sz.cy );
3589
3590     xres = msi_get_property_int( dialog->package->db, L"ScreenX", 0 );
3591     yres = msi_get_property_int( dialog->package->db, L"ScreenY", 0 );
3592
3593     center.x = MulDiv( center.x, xres, 100 );
3594     center.y = MulDiv( center.y, yres, 100 );
3595
3596     /* turn the client pos into the window rectangle */
3597     if (dialog->package->center_x && dialog->package->center_y)
3598     {
3599         pos->left = dialog->package->center_x - sz.cx / 2.0;
3600         pos->right = pos->left + sz.cx;
3601         pos->top = dialog->package->center_y - sz.cy / 2.0;
3602         pos->bottom = pos->top + sz.cy;
3603     }
3604     else
3605     {
3606         pos->left = center.x - sz.cx/2;
3607         pos->right = pos->left + sz.cx;
3608         pos->top = center.y - sz.cy/2;
3609         pos->bottom = pos->top + sz.cy;
3610
3611         /* save the center */
3612         dialog->package->center_x = center.x;
3613         dialog->package->center_y = center.y;
3614     }
3615
3616     dialog->size.cx = sz.cx;
3617     dialog->size.cy = sz.cy;
3618
3619     TRACE("%s\n", wine_dbgstr_rect(pos));
3620
3621     style = GetWindowLongPtrW( dialog->hwnd, GWL_STYLE );
3622     AdjustWindowRect( pos, style, FALSE );
3623 }
3624
3625 static void dialog_set_tab_order( msi_dialog *dialog, const WCHAR *first )
3626 {
3627     struct list tab_chain;
3628     struct control *control;
3629     HWND prev = HWND_TOP;
3630
3631     list_init( &tab_chain );
3632     if (!(control = dialog_find_control( dialog, first ))) return;
3633
3634     dialog->hWndFocus = control->hwnd;
3635     while (control)
3636     {
3637         list_remove( &control->entry );
3638         list_add_tail( &tab_chain, &control->entry );
3639         if (!control->tabnext) break;
3640         control = dialog_find_control( dialog, control->tabnext );
3641     }
3642
3643     LIST_FOR_EACH_ENTRY( control, &tab_chain, struct control, entry )
3644     {
3645         SetWindowPos( control->hwnd, prev, 0, 0, 0, 0,
3646                       SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOREDRAW |
3647                       SWP_NOREPOSITION | SWP_NOSENDCHANGING | SWP_NOSIZE );
3648         prev = control->hwnd;
3649     }
3650
3651     /* put them back on the main list */
3652     list_move_head( &dialog->controls, &tab_chain );
3653 }
3654
3655 static LRESULT dialog_oncreate( HWND hwnd, CREATESTRUCTW *cs )
3656 {
3657     msi_dialog *dialog = cs->lpCreateParams;
3658     MSIRECORD *rec = NULL;
3659     LPWSTR title = NULL;
3660     RECT pos;
3661
3662     TRACE("%p %p\n", dialog, dialog->package);
3663
3664     dialog->hwnd = hwnd;
3665     SetWindowLongPtrW( hwnd, GWLP_USERDATA, (LONG_PTR) dialog );
3666
3667     rec = get_dialog_record( dialog );
3668     if( !rec )
3669     {
3670         TRACE("No record found for dialog %s\n", debugstr_w(dialog->name));
3671         return -1;
3672     }
3673
3674     dialog->scale = dialog_get_sans_serif_height(dialog->hwnd);
3675
3676     dialog_adjust_dialog_pos( dialog, rec, &pos );
3677
3678     dialog->attributes = MSI_RecordGetInteger( rec, 6 );
3679
3680     dialog->default_font = msi_dup_property( dialog->package->db, L"DefaultUIFont" );
3681     if (!dialog->default_font)
3682     {
3683         dialog->default_font = wcsdup( L"MS Shell Dlg" );
3684         if (!dialog->default_font)
3685         {
3686             msiobj_release( &rec->hdr );
3687             return -1;
3688         }
3689     }
3690
3691     title = get_deformatted_field( dialog->package, rec, 7 );
3692     SetWindowTextW( hwnd, title );
3693     free( title );
3694
3695     SetWindowPos( hwnd, 0, pos.left, pos.top,
3696                   pos.right - pos.left, pos.bottom - pos.top,
3697                   SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW );
3698
3699     dialog_build_font_list( dialog );
3700     dialog_fill_controls( dialog );
3701     dialog_evaluate_control_conditions( dialog );
3702     dialog_set_tab_order( dialog, MSI_RecordGetString( rec, 8 ) );
3703     msiobj_release( &rec->hdr );
3704
3705     return 0;
3706 }
3707
3708 static LRESULT dialog_oncommand( msi_dialog *dialog, WPARAM param, HWND hwnd )
3709 {
3710     struct control *control = NULL;
3711
3712     TRACE( "%p, %#Ix, %p\n", dialog, param, hwnd );
3713
3714     switch (param)
3715     {
3716     case 1: /* enter */
3717         control = dialog_find_control( dialog, dialog->control_default );
3718         break;
3719     case 2: /* escape */
3720         control = dialog_find_control( dialog, dialog->control_cancel );
3721         break;
3722     default:
3723         control = dialog_find_control_by_hwnd( dialog, hwnd );
3724     }
3725
3726     if( control )
3727     {
3728         if( control->handler )
3729         {
3730             control->handler( dialog, control, param );
3731             dialog_evaluate_control_conditions( dialog );
3732         }
3733     }
3734
3735     return 0;
3736 }
3737
3738 static LRESULT dialog_onnotify( msi_dialog *dialog, LPARAM param )
3739 {
3740     LPNMHDR nmhdr = (LPNMHDR) param;
3741     struct control *control = dialog_find_control_by_hwnd( dialog, nmhdr->hwndFrom );
3742
3743     TRACE("%p %p\n", dialog, nmhdr->hwndFrom);
3744
3745     if ( control && control->handler )
3746         control->handler( dialog, control, param );
3747
3748     return 0;
3749 }
3750
3751 static void dialog_setfocus( msi_dialog *dialog )
3752 {
3753     HWND hwnd = dialog->hWndFocus;
3754
3755     hwnd = GetNextDlgTabItem( dialog->hwnd, hwnd, TRUE);
3756     hwnd = GetNextDlgTabItem( dialog->hwnd, hwnd, FALSE);
3757     SetFocus( hwnd );
3758     dialog->hWndFocus = hwnd;
3759 }
3760
3761 static LRESULT WINAPI MSIDialog_WndProc( HWND hwnd, UINT msg,
3762                 WPARAM wParam, LPARAM lParam )
3763 {
3764     msi_dialog *dialog = (LPVOID) GetWindowLongPtrW( hwnd, GWLP_USERDATA );
3765
3766     TRACE("0x%04x\n", msg);
3767
3768     switch (msg)
3769     {
3770     case WM_MOVE:
3771         dialog->package->center_x = LOWORD(lParam) + dialog->size.cx / 2.0;
3772         dialog->package->center_y = HIWORD(lParam) + dialog->size.cy / 2.0;
3773         break;
3774
3775     case WM_CREATE:
3776         return dialog_oncreate( hwnd, (LPCREATESTRUCTW)lParam );
3777
3778     case WM_COMMAND:
3779         return dialog_oncommand( dialog, wParam, (HWND)lParam );
3780
3781     case WM_CLOSE:
3782         /* Simulate escape press */
3783         return dialog_oncommand(dialog, 2, NULL);
3784
3785     case WM_ACTIVATE:
3786         if( LOWORD(wParam) == WA_INACTIVE )
3787             dialog->hWndFocus = GetFocus();
3788         else
3789             dialog_setfocus( dialog );
3790         return 0;
3791
3792     case WM_SETFOCUS:
3793         dialog_setfocus( dialog );
3794         return 0;
3795
3796     /* bounce back to our subclassed static control */
3797     case WM_CTLCOLORSTATIC:
3798         return SendMessageW( (HWND) lParam, WM_CTLCOLORSTATIC, wParam, lParam );
3799
3800     case WM_DESTROY:
3801         dialog->hwnd = NULL;
3802         return 0;
3803     case WM_NOTIFY:
3804         return dialog_onnotify( dialog, lParam );
3805     }
3806     return DefWindowProcW(hwnd, msg, wParam, lParam);
3807 }
3808
3809 static void process_pending_messages( HWND hdlg )
3810 {
3811     MSG msg;
3812
3813     while (PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ))
3814     {
3815         if (hdlg && IsDialogMessageW( hdlg, &msg )) continue;
3816         TranslateMessage( &msg );
3817         DispatchMessageW( &msg );
3818     }
3819 }
3820
3821 static UINT dialog_run_message_loop( msi_dialog *dialog )
3822 {
3823     DWORD style;
3824     HWND hwnd, parent;
3825
3826     if( uiThreadId != GetCurrentThreadId() )
3827         return SendMessageW( hMsiHiddenWindow, WM_MSI_DIALOG_CREATE, 0, (LPARAM) dialog );
3828
3829     /* create the dialog window, don't show it yet */
3830     style = WS_OVERLAPPED | WS_SYSMENU;
3831     if( dialog->attributes & msidbDialogAttributesVisible )
3832         style |= WS_VISIBLE;
3833
3834     if (dialog->parent == NULL && (dialog->attributes & msidbDialogAttributesMinimize))
3835         style |= WS_MINIMIZEBOX;
3836
3837     parent = dialog->parent ? dialog->parent->hwnd : 0;
3838
3839     hwnd = CreateWindowW( L"MsiDialogCloseClass", dialog->name, style,
3840                      CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
3841                      parent, NULL, NULL, dialog );
3842     if( !hwnd )
3843     {
3844         ERR("Failed to create dialog %s\n", debugstr_w( dialog->name ));
3845         return ERROR_FUNCTION_FAILED;
3846     }
3847
3848     ShowWindow( hwnd, SW_SHOW );
3849     /* UpdateWindow( hwnd ); - and causes the transparent static controls not to paint */
3850
3851     if( dialog->attributes & msidbDialogAttributesModal )
3852     {
3853         while( !dialog->finished )
3854         {
3855             MsgWaitForMultipleObjects( 0, NULL, 0, INFINITE, QS_ALLINPUT );
3856             process_pending_messages( dialog->hwnd );
3857         }
3858     }
3859     else
3860         return ERROR_IO_PENDING;
3861
3862     return ERROR_SUCCESS;
3863 }
3864
3865 static LRESULT WINAPI MSIHiddenWindowProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
3866 {
3867     msi_dialog *dialog = (msi_dialog*) lParam;
3868
3869     TRACE("%d %p\n", msg, dialog);
3870
3871     switch (msg)
3872     {
3873     case WM_MSI_DIALOG_CREATE:
3874         return dialog_run_message_loop( dialog );
3875     case WM_MSI_DIALOG_DESTROY:
3876         msi_dialog_destroy( dialog );
3877         return 0;
3878     }
3879     return DefWindowProcW( hwnd, msg, wParam, lParam );
3880 }
3881
3882 static BOOL dialog_register_class( void )
3883 {
3884     WNDCLASSW cls;
3885
3886     ZeroMemory( &cls, sizeof cls );
3887     cls.lpfnWndProc   = MSIDialog_WndProc;
3888     cls.hInstance     = NULL;
3889     cls.hIcon         = LoadIconW(0, (LPWSTR)IDI_APPLICATION);
3890     cls.hCursor       = LoadCursorW(0, (LPWSTR)IDC_ARROW);
3891     cls.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
3892     cls.lpszMenuName  = NULL;
3893     cls.lpszClassName = L"MsiDialogCloseClass";
3894
3895     if( !RegisterClassW( &cls ) )
3896         return FALSE;
3897
3898     cls.lpfnWndProc   = MSIHiddenWindowProc;
3899     cls.lpszClassName = L"MsiHiddenWindow";
3900
3901     if( !RegisterClassW( &cls ) )
3902         return FALSE;
3903
3904     uiThreadId = GetCurrentThreadId();
3905
3906     hMsiHiddenWindow = CreateWindowW( L"MsiHiddenWindow", NULL, WS_OVERLAPPED,
3907                                    0, 0, 100, 100, NULL, NULL, NULL, NULL );
3908     if( !hMsiHiddenWindow )
3909         return FALSE;
3910
3911     return TRUE;
3912 }
3913
3914 static msi_dialog *dialog_create( MSIPACKAGE *package, const WCHAR *name, msi_dialog *parent,
3915                                   UINT (*event_handler)(msi_dialog *, const WCHAR *, const WCHAR *) )
3916 {
3917     MSIRECORD *rec = NULL;
3918     msi_dialog *dialog;
3919
3920     TRACE("%s\n", debugstr_w(name));
3921
3922     if (!hMsiHiddenWindow) dialog_register_class();
3923
3924     /* allocate the structure for the dialog to use */
3925     dialog = calloc( 1, offsetof( msi_dialog, name[wcslen( name ) + 1] ) );
3926     if( !dialog )
3927         return NULL;
3928     lstrcpyW( dialog->name, name );
3929     dialog->parent = parent;
3930     dialog->package = package;
3931     dialog->event_handler = event_handler;
3932     dialog->finished = 0;
3933     list_init( &dialog->controls );
3934     list_init( &dialog->fonts );
3935
3936     /* verify that the dialog exists */
3937     rec = get_dialog_record( dialog );
3938     if( !rec )
3939     {
3940         free( dialog );
3941         return NULL;
3942     }
3943     dialog->attributes = MSI_RecordGetInteger( rec, 6 );
3944     dialog->control_default = wcsdup( MSI_RecordGetString( rec, 9 ) );
3945     dialog->control_cancel = wcsdup( MSI_RecordGetString( rec, 10 ) );
3946     msiobj_release( &rec->hdr );
3947
3948     rec = MSI_CreateRecord(2);
3949     if (!rec)
3950     {
3951         msi_dialog_destroy(dialog);
3952         return NULL;
3953     }
3954     MSI_RecordSetStringW(rec, 1, name);
3955     MSI_RecordSetStringW(rec, 2, L"Dialog created");
3956     MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONSTART, rec);
3957     msiobj_release(&rec->hdr);
3958
3959     return dialog;
3960 }
3961
3962 static void dialog_end_dialog( msi_dialog *dialog )
3963 {
3964     TRACE("%p\n", dialog);
3965     dialog->finished = 1;
3966     PostMessageW(dialog->hwnd, WM_NULL, 0, 0);
3967 }
3968
3969 void msi_dialog_check_messages( HANDLE handle )
3970 {
3971     DWORD r;
3972
3973     /* in threads other than the UI thread, block */
3974     if( uiThreadId != GetCurrentThreadId() )
3975     {
3976         if (!handle) return;
3977         while (MsgWaitForMultipleObjectsEx( 1, &handle, INFINITE, QS_ALLINPUT, 0 ) == WAIT_OBJECT_0 + 1)
3978         {
3979             MSG msg;
3980             while (PeekMessageW( &msg, NULL, 0, 0, PM_REMOVE ))
3981             {
3982                 TranslateMessage( &msg );
3983                 DispatchMessageW( &msg );
3984             }
3985         }
3986         return;
3987     }
3988
3989     /* there are two choices for the UI thread */
3990     while (1)
3991     {
3992         process_pending_messages( NULL );
3993
3994         if( !handle )
3995             break;
3996
3997         /*
3998          * block here until somebody creates a new dialog or
3999          * the handle we're waiting on becomes ready
4000          */
4001         r = MsgWaitForMultipleObjects( 1, &handle, 0, INFINITE, QS_ALLINPUT );
4002         if( r == WAIT_OBJECT_0 )
4003             break;
4004     }
4005 }
4006
4007 static void dialog_do_preview( msi_dialog *dialog )
4008 {
4009     TRACE("\n");
4010     dialog->attributes |= msidbDialogAttributesVisible;
4011     dialog->attributes &= ~msidbDialogAttributesModal;
4012     dialog_run_message_loop( dialog );
4013 }
4014
4015 static void free_subscriber( struct subscriber *sub )
4016 {
4017     free( sub->event );
4018     free( sub->control );
4019     free( sub->attribute );
4020     free( sub );
4021 }
4022
4023 static void event_cleanup_subscriptions( MSIPACKAGE *package, const WCHAR *dialog )
4024 {
4025     struct list *item, *next;
4026
4027     LIST_FOR_EACH_SAFE( item, next, &package->subscriptions )
4028     {
4029         struct subscriber *sub = LIST_ENTRY( item, struct subscriber, entry );
4030
4031         if (wcscmp( sub->dialog->name, dialog )) continue;
4032         list_remove( &sub->entry );
4033         free_subscriber( sub );
4034     }
4035 }
4036
4037 void msi_dialog_destroy( msi_dialog *dialog )
4038 {
4039     struct font *font, *next;
4040
4041     if( uiThreadId != GetCurrentThreadId() )
4042     {
4043         SendMessageW( hMsiHiddenWindow, WM_MSI_DIALOG_DESTROY, 0, (LPARAM) dialog );
4044         return;
4045     }
4046
4047     if( dialog->hwnd )
4048     {
4049         ShowWindow( dialog->hwnd, SW_HIDE );
4050         DestroyWindow( dialog->hwnd );
4051     }
4052
4053     /* unsubscribe events */
4054     event_cleanup_subscriptions( dialog->package, dialog->name );
4055
4056     /* destroy the list of controls */
4057     while( !list_empty( &dialog->controls ) )
4058     {
4059         struct control *t;
4060
4061         t = LIST_ENTRY( list_head( &dialog->controls ), struct control, entry );
4062         destroy_control( t );
4063     }
4064
4065     /* destroy the list of fonts */
4066     LIST_FOR_EACH_ENTRY_SAFE( font, next, &dialog->fonts, struct font, entry )
4067     {
4068         list_remove( &font->entry );
4069         DeleteObject( font->hfont );
4070         free( font );
4071     }
4072     free( dialog->default_font );
4073
4074     free( dialog->control_default );
4075     free( dialog->control_cancel );
4076     dialog->package = NULL;
4077     free( dialog );
4078 }
4079
4080 void msi_dialog_unregister_class( void )
4081 {
4082     DestroyWindow( hMsiHiddenWindow );
4083     hMsiHiddenWindow = NULL;
4084     UnregisterClassW( L"MsiDialogCloseClass", NULL );
4085     UnregisterClassW( L"MsiHiddenWindow", NULL );
4086     uiThreadId = 0;
4087 }
4088
4089 void msi_event_cleanup_all_subscriptions( MSIPACKAGE *package )
4090 {
4091     struct list *item, *next;
4092
4093     LIST_FOR_EACH_SAFE( item, next, &package->subscriptions )
4094     {
4095         struct subscriber *sub = LIST_ENTRY( item, struct subscriber, entry );
4096         list_remove( &sub->entry );
4097         free_subscriber( sub );
4098     }
4099 }
4100
4101 static void MSI_ClosePreview( MSIOBJECTHDR *arg )
4102 {
4103     MSIPREVIEW *preview = (MSIPREVIEW *)arg;
4104     msiobj_release( &preview->package->hdr );
4105 }
4106
4107 static MSIPREVIEW *MSI_EnableUIPreview( MSIDATABASE *db )
4108 {
4109     MSIPREVIEW *preview = NULL;
4110     MSIPACKAGE *package;
4111
4112     package = MSI_CreatePackage( db );
4113     if (package)
4114     {
4115         preview = alloc_msiobject( MSIHANDLETYPE_PREVIEW, sizeof(MSIPREVIEW), MSI_ClosePreview );
4116         if (preview)
4117         {
4118             preview->package = package;
4119             msiobj_addref( &package->hdr );
4120         }
4121         msiobj_release( &package->hdr );
4122     }
4123     return preview;
4124 }
4125
4126 UINT WINAPI MsiEnableUIPreview( MSIHANDLE hdb, MSIHANDLE *phPreview )
4127 {
4128     MSIDATABASE *db;
4129     MSIPREVIEW *preview;
4130     UINT r = ERROR_FUNCTION_FAILED;
4131
4132     TRACE( "%lu %p\n", hdb, phPreview );
4133
4134     if (!(db = msihandle2msiinfo(hdb, MSIHANDLETYPE_DATABASE)))
4135         return ERROR_INVALID_HANDLE;
4136
4137     preview = MSI_EnableUIPreview( db );
4138     if (preview)
4139     {
4140         *phPreview = alloc_msihandle( &preview->hdr );
4141         msiobj_release( &preview->hdr );
4142         r = ERROR_SUCCESS;
4143         if (!*phPreview)
4144             r = ERROR_NOT_ENOUGH_MEMORY;
4145     }
4146     msiobj_release( &db->hdr );
4147     return r;
4148 }
4149
4150 static UINT preview_event_handler( msi_dialog *dialog, const WCHAR *event, const WCHAR *argument )
4151 {
4152     MESSAGE("Preview dialog event '%s' (arg='%s')\n", debugstr_w(event), debugstr_w(argument));
4153     return ERROR_SUCCESS;
4154 }
4155
4156 static UINT MSI_PreviewDialogW( MSIPREVIEW *preview, LPCWSTR szDialogName )
4157 {
4158     msi_dialog *dialog = NULL;
4159     UINT r = ERROR_SUCCESS;
4160
4161     if (preview->dialog)
4162         msi_dialog_destroy( preview->dialog );
4163
4164     /* an empty name means we should just destroy the current preview dialog */
4165     if (szDialogName)
4166     {
4167         dialog = dialog_create( preview->package, szDialogName, NULL, preview_event_handler );
4168         if (dialog)
4169             dialog_do_preview( dialog );
4170         else
4171             r = ERROR_FUNCTION_FAILED;
4172     }
4173     preview->dialog = dialog;
4174     return r;
4175 }
4176
4177 UINT WINAPI MsiPreviewDialogW( MSIHANDLE hPreview, LPCWSTR szDialogName )
4178 {
4179     MSIPREVIEW *preview;
4180     UINT r;
4181
4182     TRACE( "%lu %s\n", hPreview, debugstr_w(szDialogName) );
4183
4184     preview = msihandle2msiinfo( hPreview, MSIHANDLETYPE_PREVIEW );
4185     if (!preview)
4186         return ERROR_INVALID_HANDLE;
4187
4188     r = MSI_PreviewDialogW( preview, szDialogName );
4189     msiobj_release( &preview->hdr );
4190     return r;
4191 }
4192
4193 UINT WINAPI MsiPreviewDialogA( MSIHANDLE hPreview, LPCSTR szDialogName )
4194 {
4195     UINT r;
4196     LPWSTR strW = NULL;
4197
4198     TRACE( "%lu %s\n", hPreview, debugstr_a(szDialogName) );
4199
4200     if (szDialogName)
4201     {
4202         strW = strdupAtoW( szDialogName );
4203         if (!strW)
4204             return ERROR_OUTOFMEMORY;
4205     }
4206     r = MsiPreviewDialogW( hPreview, strW );
4207     free( strW );
4208     return r;
4209 }
4210
4211 UINT WINAPI MsiPreviewBillboardW( MSIHANDLE hPreview, const WCHAR *szControlName, const WCHAR *szBillboard )
4212 {
4213     FIXME( "%lu %s %s\n", hPreview, debugstr_w(szControlName), debugstr_w(szBillboard) );
4214     return ERROR_CALL_NOT_IMPLEMENTED;
4215 }
4216
4217 UINT WINAPI MsiPreviewBillboardA( MSIHANDLE hPreview, const char *szControlName, const char *szBillboard )
4218 {
4219     FIXME( "%lu %s %s\n", hPreview, debugstr_a(szControlName), debugstr_a(szBillboard) );
4220     return ERROR_CALL_NOT_IMPLEMENTED;
4221 }
4222
4223 struct control_event
4224 {
4225     const WCHAR  *event;
4226     UINT (*handler)( msi_dialog *, const WCHAR * );
4227 };
4228
4229 static UINT dialog_event_handler( msi_dialog *, const WCHAR *, const WCHAR * );
4230
4231 /* create a dialog box and run it if it's modal */
4232 static INT event_do_dialog( MSIPACKAGE *package, const WCHAR *name, msi_dialog *parent, BOOL destroy_modeless )
4233 {
4234     msi_dialog *dialog;
4235     UINT r;
4236     INT retval;
4237
4238     /* create a new dialog */
4239     dialog = dialog_create( package, name, parent, dialog_event_handler );
4240     if (dialog)
4241     {
4242         /* kill the current modeless dialog */
4243         if (destroy_modeless && package->dialog)
4244         {
4245             msi_dialog_destroy( package->dialog );
4246             package->dialog = NULL;
4247         }
4248
4249         /* modeless dialogs return an error message */
4250         r = dialog_run_message_loop( dialog );
4251         if (r == ERROR_SUCCESS)
4252         {
4253             retval = dialog->retval;
4254             msi_dialog_destroy( dialog );
4255             return retval;
4256         }
4257         else
4258         {
4259             package->dialog = dialog;
4260             return IDOK;
4261         }
4262     }
4263     else return 0;
4264 }
4265
4266 /* end a modal dialog box */
4267 static UINT event_end_dialog( msi_dialog *dialog, const WCHAR *argument )
4268 {
4269     if (!wcscmp( argument, L"Exit" ))
4270         dialog->retval = IDCANCEL;
4271     else if (!wcscmp( argument, L"Retry" ))
4272         dialog->retval = IDRETRY;
4273     else if (!wcscmp( argument, L"Ignore" ))
4274         dialog->retval = IDOK;
4275     else if (!wcscmp( argument, L"Return" ))
4276         dialog->retval = 0;
4277     else
4278     {
4279         ERR("Unknown argument string %s\n", debugstr_w(argument));
4280         dialog->retval = IDABORT;
4281     }
4282     event_cleanup_subscriptions( dialog->package, dialog->name );
4283     dialog_end_dialog( dialog );
4284     return ERROR_SUCCESS;
4285 }
4286
4287 static UINT pending_event_end_dialog( msi_dialog *dialog, const WCHAR *argument )
4288 {
4289     dialog->pending_event = event_end_dialog;
4290     free( dialog->pending_argument );
4291     dialog->pending_argument = wcsdup( argument );
4292     return ERROR_SUCCESS;
4293 }
4294
4295 /* transition from one modal dialog to another modal dialog */
4296 static UINT event_new_dialog( msi_dialog *dialog, const WCHAR *argument )
4297 {
4298     /* store the name of the next dialog, and signal this one to end */
4299     dialog->package->next_dialog = wcsdup( argument );
4300     msi_event_cleanup_all_subscriptions( dialog->package );
4301     dialog_end_dialog( dialog );
4302     return ERROR_SUCCESS;
4303 }
4304
4305 static UINT pending_event_new_dialog( msi_dialog *dialog, const WCHAR *argument )
4306 {
4307     dialog->pending_event = event_new_dialog;
4308     free( dialog->pending_argument );
4309     dialog->pending_argument = wcsdup( argument );
4310     return ERROR_SUCCESS;
4311 }
4312
4313 /* create a new child dialog of an existing modal dialog */
4314 static UINT event_spawn_dialog( msi_dialog *dialog, const WCHAR *argument )
4315 {
4316     INT r;
4317     /* don't destroy a modeless dialogs that might be our parent */
4318     r = event_do_dialog( dialog->package, argument, dialog, FALSE );
4319     if (r != 0)
4320     {
4321         dialog->retval = r;
4322         dialog_end_dialog( dialog );
4323     }
4324     else
4325         dialog_update_all_controls(dialog);
4326
4327     return ERROR_SUCCESS;
4328 }
4329
4330 static UINT pending_event_spawn_dialog( msi_dialog *dialog, const WCHAR *argument )
4331 {
4332     dialog->pending_event = event_spawn_dialog;
4333     free( dialog->pending_argument );
4334     dialog->pending_argument = wcsdup( argument );
4335     return ERROR_SUCCESS;
4336 }
4337
4338 /* creates a dialog that remains up for a period of time based on a condition */
4339 static UINT event_spawn_wait_dialog( msi_dialog *dialog, const WCHAR *argument )
4340 {
4341     FIXME("doing nothing\n");
4342     return ERROR_SUCCESS;
4343 }
4344
4345 static UINT event_do_action( msi_dialog *dialog, const WCHAR *argument )
4346 {
4347     ACTION_PerformAction(dialog->package, argument);
4348     return ERROR_SUCCESS;
4349 }
4350
4351 static UINT event_add_local( msi_dialog *dialog, const WCHAR *argument )
4352 {
4353     MSIFEATURE *feature;
4354
4355     LIST_FOR_EACH_ENTRY( feature, &dialog->package->features, MSIFEATURE, entry )
4356     {
4357         if (!wcscmp( argument, feature->Feature ) || !wcscmp( argument, L"ALL" ))
4358         {
4359             if (feature->ActionRequest != INSTALLSTATE_LOCAL)
4360                 msi_set_property( dialog->package->db, L"Preselected", L"1", -1 );
4361             MSI_SetFeatureStateW( dialog->package, feature->Feature, INSTALLSTATE_LOCAL );
4362         }
4363     }
4364     return ERROR_SUCCESS;
4365 }
4366
4367 static UINT event_remove( msi_dialog *dialog, const WCHAR *argument )
4368 {
4369     MSIFEATURE *feature;
4370
4371     LIST_FOR_EACH_ENTRY( feature, &dialog->package->features, MSIFEATURE, entry )
4372     {
4373         if (!wcscmp( argument, feature->Feature ) || !wcscmp( argument, L"ALL" ))
4374         {
4375             if (feature->ActionRequest != INSTALLSTATE_ABSENT)
4376                 msi_set_property( dialog->package->db, L"Preselected", L"1", -1 );
4377             MSI_SetFeatureStateW( dialog->package, feature->Feature, INSTALLSTATE_ABSENT );
4378         }
4379     }
4380     return ERROR_SUCCESS;
4381 }
4382
4383 static UINT event_add_source( msi_dialog *dialog, const WCHAR *argument )
4384 {
4385     MSIFEATURE *feature;
4386
4387     LIST_FOR_EACH_ENTRY( feature, &dialog->package->features, MSIFEATURE, entry )
4388     {
4389         if (!wcscmp( argument, feature->Feature ) || !wcscmp( argument, L"ALL" ))
4390         {
4391             if (feature->ActionRequest != INSTALLSTATE_SOURCE)
4392                 msi_set_property( dialog->package->db, L"Preselected", L"1", -1 );
4393             MSI_SetFeatureStateW( dialog->package, feature->Feature, INSTALLSTATE_SOURCE );
4394         }
4395     }
4396     return ERROR_SUCCESS;
4397 }
4398
4399 void msi_event_fire( MSIPACKAGE *package, const WCHAR *event, MSIRECORD *rec )
4400 {
4401     struct subscriber *sub;
4402
4403     TRACE("firing event %s\n", debugstr_w(event));
4404
4405     LIST_FOR_EACH_ENTRY( sub, &package->subscriptions, struct subscriber, entry )
4406     {
4407         if (wcsicmp( sub->event, event )) continue;
4408         dialog_handle_event( sub->dialog, sub->control, sub->attribute, rec );
4409     }
4410 }
4411
4412 static UINT event_set_target_path( msi_dialog *dialog, const WCHAR *argument )
4413 {
4414     WCHAR *path = msi_dup_property( dialog->package->db, argument );
4415     MSIRECORD *rec = MSI_CreateRecord( 1 );
4416     UINT r = ERROR_SUCCESS;
4417
4418     MSI_RecordSetStringW( rec, 1, path );
4419     msi_event_fire( dialog->package, L"SelectionPath", rec );
4420     if (path)
4421     {
4422         /* failure to set the path halts the executing of control events */
4423         r = MSI_SetTargetPathW( dialog->package, argument, path );
4424         free( path );
4425     }
4426     msiobj_release( &rec->hdr );
4427     return r;
4428 }
4429
4430 static UINT event_reset( msi_dialog *dialog, const WCHAR *argument )
4431 {
4432     dialog_reset( dialog );
4433     return ERROR_SUCCESS;
4434 }
4435
4436 INT ACTION_ShowDialog( MSIPACKAGE *package, const WCHAR *dialog )
4437 {
4438     MSIRECORD *row;
4439     INT rc;
4440
4441     if (!TABLE_Exists(package->db, L"Dialog")) return 0;
4442
4443     row = MSI_CreateRecord(0);
4444     if (!row) return -1;
4445     MSI_RecordSetStringW(row, 0, dialog);
4446     rc = MSI_ProcessMessage(package, INSTALLMESSAGE_SHOWDIALOG, row);
4447     msiobj_release(&row->hdr);
4448
4449     if (rc == -2) rc = 0;
4450
4451     if (!rc)
4452     {
4453         MSIRECORD *row = MSI_CreateRecord(2);
4454         if (!row) return -1;
4455         MSI_RecordSetInteger(row, 1, 2726);
4456         MSI_RecordSetStringW(row, 2, dialog);
4457         MSI_ProcessMessage(package, INSTALLMESSAGE_INFO, row);
4458
4459         msiobj_release(&row->hdr);
4460     }
4461     return rc;
4462 }
4463
4464 INT ACTION_DialogBox( MSIPACKAGE *package, const WCHAR *dialog )
4465 {
4466     INT r;
4467
4468     if (package->next_dialog) ERR("Already got next dialog... ignoring it\n");
4469     package->next_dialog = NULL;
4470
4471     /* Dialogs are chained through NewDialog, which sets the next_dialog member.
4472      * We fall out of the loop if we reach a modeless dialog, which immediately
4473      * returns IDOK, or an EndDialog event, which returns the value corresponding
4474      * to its argument.
4475      */
4476     r = event_do_dialog( package, dialog, NULL, TRUE );
4477     while (package->next_dialog)
4478     {
4479         WCHAR *name = package->next_dialog;
4480
4481         package->next_dialog = NULL;
4482         r = event_do_dialog( package, name, NULL, TRUE );
4483         free( name );
4484     }
4485     return r;
4486 }
4487
4488 static UINT event_set_install_level( msi_dialog *dialog, const WCHAR *argument )
4489 {
4490     int level = wcstol( argument, NULL, 10 );
4491
4492     TRACE("setting install level to %d\n", level);
4493     return MSI_SetInstallLevel( dialog->package, level );
4494 }
4495
4496 static UINT event_directory_list_up( msi_dialog *dialog, const WCHAR *argument )
4497 {
4498     return dialog_directorylist_up( dialog );
4499 }
4500
4501 static UINT event_directory_list_new( msi_dialog *dialog, const WCHAR *argument )
4502 {
4503     return dialog_directorylist_new( dialog );
4504 }
4505
4506 static UINT event_reinstall_mode( msi_dialog *dialog, const WCHAR *argument )
4507 {
4508     return msi_set_property( dialog->package->db, L"REINSTALLMODE", argument, -1 );
4509 }
4510
4511 static UINT event_reinstall( msi_dialog *dialog, const WCHAR *argument )
4512 {
4513     return msi_set_property( dialog->package->db, L"REINSTALL", argument, -1 );
4514 }
4515
4516 static UINT event_validate_product_id( msi_dialog *dialog, const WCHAR *argument )
4517 {
4518     return msi_validate_product_id( dialog->package );
4519 }
4520
4521 static const struct control_event control_events[] =
4522 {
4523     { L"EndDialog", pending_event_end_dialog },
4524     { L"NewDialog", pending_event_new_dialog },
4525     { L"SpawnDialog", pending_event_spawn_dialog },
4526     { L"SpawnWaitDialog", event_spawn_wait_dialog },
4527     { L"DoAction", event_do_action },
4528     { L"AddLocal", event_add_local },
4529     { L"Remove", event_remove },
4530     { L"AddSource", event_add_source },
4531     { L"SetTargetPath", event_set_target_path },
4532     { L"Reset", event_reset },
4533     { L"SetInstallLevel", event_set_install_level },
4534     { L"DirectoryListUp", event_directory_list_up },
4535     { L"DirectoryListNew", event_directory_list_new },
4536     { L"SelectionBrowse", event_spawn_dialog },
4537     { L"ReinstallMode", event_reinstall_mode },
4538     { L"Reinstall", event_reinstall },
4539     { L"ValidateProductID", event_validate_product_id },
4540     { NULL, NULL }
4541 };
4542
4543 static UINT dialog_event_handler( msi_dialog *dialog, const WCHAR *event, const WCHAR *argument )
4544 {
4545     unsigned int i;
4546
4547     TRACE("handling event %s\n", debugstr_w(event));
4548
4549     if (!event) return ERROR_SUCCESS;
4550
4551     for (i = 0; control_events[i].event; i++)
4552     {
4553         if (!wcscmp( control_events[i].event, event ))
4554             return control_events[i].handler( dialog, argument );
4555     }
4556     FIXME("unhandled event %s arg(%s)\n", debugstr_w(event), debugstr_w(argument));
4557     return ERROR_SUCCESS;
4558 }