ReactOS  0.4.15-dev-5112-g22d8c0f
dialog.c
Go to the documentation of this file.
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 #define NONAMELESSUNION
24 
25 #include <stdarg.h>
26 
27 #include "windef.h"
28 #include "winbase.h"
29 #include "wingdi.h"
30 #include "winuser.h"
31 #include "winnls.h"
32 #include "msi.h"
33 #include "msidefs.h"
34 #include "ocidl.h"
35 #include "olectl.h"
36 #include "richedit.h"
37 #include "commctrl.h"
38 #include "winreg.h"
39 #include "shlwapi.h"
40 #include "shellapi.h"
41 
42 #include "wine/debug.h"
43 
44 #include "msipriv.h"
45 #include "msiserver.h"
46 #include "resource.h"
47 
49 
51 
52 struct msi_control_tag;
56 typedef UINT (*control_event_handler)( msi_dialog *, const WCHAR *, const WCHAR * );
57 typedef UINT (*event_handler)( msi_dialog *, const WCHAR * );
58 
60 {
61  struct list entry;
74  float progress_max;
77  WCHAR name[1];
78 };
79 
80 typedef struct msi_font_tag
81 {
82  struct list entry;
85  WCHAR name[1];
86 } msi_font;
87 
89 {
99  struct list fonts;
100  struct list controls;
108 };
109 
111 {
112  struct list entry;
117 };
118 
121 {
124 };
125 
126 typedef struct
127 {
132 
133 /* dialog sequencing */
134 
135 #define WM_MSI_DIALOG_CREATE (WM_USER+0x100)
136 #define WM_MSI_DIALOG_DESTROY (WM_USER+0x101)
137 
138 #define USER_INSTALLSTATE_ALL 0x1000
139 
142 
144 {
145  UINT sz, r;
146  LPWSTR buf;
147 
148  sz = 0x20;
149  buf = msi_alloc( sz*sizeof(WCHAR) );
150  while ( buf )
151  {
152  r = GetWindowTextW( hwnd, buf, sz );
153  if ( r < (sz - 1) )
154  break;
155  sz *= 2;
156  buf = msi_realloc( buf, sz*sizeof(WCHAR) );
157  }
158 
159  return buf;
160 }
161 
163 {
164  return MulDiv( val, dialog->scale, 12 );
165 }
166 
168 {
169  msi_control *control;
170 
171  if( !name )
172  return NULL;
173  if( !dialog->hwnd )
174  return NULL;
175  LIST_FOR_EACH_ENTRY( control, &dialog->controls, msi_control, entry )
176  if( !wcscmp( control->name, name ) ) /* FIXME: case sensitive? */
177  return control;
178  return NULL;
179 }
180 
182 {
183  msi_control *control;
184 
185  if( !type )
186  return NULL;
187  if( !dialog->hwnd )
188  return NULL;
189  LIST_FOR_EACH_ENTRY( control, &dialog->controls, msi_control, entry )
190  if( !wcscmp( control->type, type ) ) /* FIXME: case sensitive? */
191  return control;
192  return NULL;
193 }
194 
196 {
197  msi_control *control;
198 
199  if( !dialog->hwnd )
200  return NULL;
201  LIST_FOR_EACH_ENTRY( control, &dialog->controls, msi_control, entry )
202  if( hwnd == control->hwnd )
203  return control;
204  return NULL;
205 }
206 
208 {
210  LPWSTR ret = NULL;
211 
212  if (str)
213  deformat_string( package, str, &ret );
214  return ret;
215 }
216 
218 {
219  LPWSTR prop = NULL;
220 
221  if (!property)
222  return NULL;
223 
224  if (indirect)
225  prop = msi_dup_property( dialog->package->db, property );
226 
227  if (!prop)
228  prop = strdupW( property );
229 
230  return prop;
231 }
232 
233 /*
234  * msi_dialog_get_style
235  *
236  * Extract the {\style} string from the front of the text to display and
237  * update the pointer. Only the last style in a list is applied.
238  */
240 {
241  LPWSTR ret;
242  LPCWSTR q, i, first;
243  DWORD len;
244 
245  q = NULL;
246  *rest = p;
247  if( !p )
248  return NULL;
249 
250  while ((first = wcschr( p, '{' )) && (q = wcschr( first + 1, '}' )))
251  {
252  p = first + 1;
253  if( *p != '\\' && *p != '&' )
254  return NULL;
255 
256  /* little bit of sanity checking to stop us getting confused with RTF */
257  for( i=++p; i<q; i++ )
258  if( *i == '}' || *i == '\\' )
259  return NULL;
260  }
261 
262  if (!q)
263  return NULL;
264 
265  *rest = ++q;
266  len = q - p;
267 
268  ret = msi_alloc( len*sizeof(WCHAR) );
269  if( !ret )
270  return ret;
271  memcpy( ret, p, len*sizeof(WCHAR) );
272  ret[len-1] = 0;
273  return ret;
274 }
275 
277 {
279  msi_font *font;
280  LPCWSTR face, name;
281  LOGFONTW lf;
282  INT style;
283  HDC hdc;
284 
285  /* create a font and add it to the list */
286  name = MSI_RecordGetString( rec, 1 );
288  lstrcpyW( font->name, name );
289  list_add_head( &dialog->fonts, &font->entry );
290 
291  font->color = MSI_RecordGetInteger( rec, 4 );
292 
293  memset( &lf, 0, sizeof lf );
294  face = MSI_RecordGetString( rec, 2 );
295  lf.lfHeight = MSI_RecordGetInteger( rec, 3 );
296  style = MSI_RecordGetInteger( rec, 5 );
298  lf.lfWeight = FW_BOLD;
300  lf.lfItalic = TRUE;
302  lf.lfUnderline = TRUE;
304  lf.lfStrikeOut = TRUE;
306 
307  /* adjust the height */
308  hdc = GetDC( dialog->hwnd );
309  if (hdc)
310  {
312  ReleaseDC( dialog->hwnd, hdc );
313  }
314 
315  font->hfont = CreateFontIndirectW( &lf );
316 
317  TRACE("Adding font style %s\n", debugstr_w(font->name) );
318 
319  return ERROR_SUCCESS;
320 }
321 
323 {
324  msi_font *font = NULL;
325 
327  if( !wcscmp( font->name, name ) ) /* FIXME: case sensitive? */
328  break;
329 
330  return font;
331 }
332 
334 {
335  msi_font *font;
336 
338  if( font )
339  SendMessageW( hwnd, WM_SETFONT, (WPARAM) font->hfont, TRUE );
340  else
341  ERR("No font entry for %s\n", debugstr_w(name));
342  return ERROR_SUCCESS;
343 }
344 
346 {
347  MSIQUERY *view;
348  UINT r;
349 
350  TRACE("dialog %p\n", dialog );
351 
352  r = MSI_OpenQuery( dialog->package->db, &view, L"SELECT * FROM `TextStyle`" );
353  if( r != ERROR_SUCCESS )
354  return r;
355 
357  msiobj_release( &view->hdr );
358  return r;
359 }
360 
362 {
363  list_remove( &t->entry );
364  /* leave dialog->hwnd - destroying parent destroys child windows */
365  msi_free( t->property );
366  msi_free( t->value );
367  if( t->hBitmap )
368  DeleteObject( t->hBitmap );
369  if( t->hIcon )
370  DestroyIcon( t->hIcon );
371  if ( t->hImageList )
372  ImageList_Destroy( t->hImageList );
373  msi_free( t->tabnext );
374  msi_free( t->type );
375  if (t->hDll)
376  FreeLibrary( t->hDll );
377  msi_free( t );
378 }
379 
381  const WCHAR *szCls, const WCHAR *name, const WCHAR *text,
383 {
384  DWORD x, y, width, height;
385  LPWSTR font = NULL, title_font = NULL;
386  LPCWSTR title = NULL;
387  msi_control *control;
388 
389  style |= WS_CHILD;
390 
391  control = msi_alloc( FIELD_OFFSET( msi_control, name[lstrlenW( name ) + 1] ));
392  if (!control)
393  return NULL;
394 
395  lstrcpyW( control->name, name );
396  list_add_tail( &dialog->controls, &control->entry );
397  control->handler = NULL;
398  control->update = NULL;
399  control->property = NULL;
400  control->value = NULL;
401  control->hBitmap = NULL;
402  control->hIcon = NULL;
403  control->hImageList = NULL;
404  control->hDll = NULL;
405  control->tabnext = strdupW( MSI_RecordGetString( rec, 11) );
406  control->type = strdupW( MSI_RecordGetString( rec, 3 ) );
407  control->progress_current = 0;
408  control->progress_max = 100;
409  control->progress_backwards = FALSE;
410 
411  x = MSI_RecordGetInteger( rec, 4 );
412  y = MSI_RecordGetInteger( rec, 5 );
413  width = MSI_RecordGetInteger( rec, 6 );
414  height = MSI_RecordGetInteger( rec, 7 );
415 
420 
421  if( text )
422  {
423  deformat_string( dialog->package, text, &title_font );
424  font = msi_dialog_get_style( title_font, &title );
425  }
426 
427  control->hwnd = CreateWindowExW( exstyle, szCls, title, style,
428  x, y, width, height, parent, NULL, NULL, NULL );
429 
430  TRACE("Dialog %s control %s hwnd %p\n",
431  debugstr_w(dialog->name), debugstr_w(text), control->hwnd );
432 
433  msi_dialog_set_font( dialog, control->hwnd,
434  font ? font : dialog->default_font );
435 
436  msi_free( title_font );
437  msi_free( font );
438 
439  return control;
440 }
441 
443 {
444  MSIRECORD *rec;
445  LPWSTR text;
446 
447  rec = MSI_QueryGetRecord( dialog->package->db, L"SELECT * FROM `UIText` WHERE `Key` = '%s'", key );
448  if (!rec) return NULL;
449  text = strdupW( MSI_RecordGetString( rec, 2 ) );
450  msiobj_release( &rec->hdr );
451  return text;
452 }
453 
455  UINT cx, UINT cy, UINT flags )
456 {
457  MSIRECORD *rec;
458  HANDLE himage = NULL;
459  LPWSTR tmp;
460  UINT r;
461 
462  TRACE("%p %s %u %u %08x\n", db, debugstr_w(name), cx, cy, flags);
463 
464  if (!(tmp = msi_create_temp_file( db ))) return NULL;
465 
466  rec = MSI_QueryGetRecord( db, L"SELECT * FROM `Binary` WHERE `Name` = '%s'", name );
467  if( rec )
468  {
469  r = MSI_RecordStreamToFile( rec, 2, tmp );
470  if( r == ERROR_SUCCESS )
471  {
472  himage = LoadImageW( 0, tmp, type, cx, cy, flags );
473  }
474  msiobj_release( &rec->hdr );
475  }
476  DeleteFileW( tmp );
477 
478  msi_free( tmp );
479  return himage;
480 }
481 
482 static HICON msi_load_icon( MSIDATABASE *db, LPCWSTR text, UINT attributes )
483 {
484  DWORD cx = 0, cy = 0, flags;
485 
487  if( attributes & msidbControlAttributesFixedSize )
488  {
489  flags &= ~LR_DEFAULTSIZE;
490  if( attributes & msidbControlAttributesIconSize16 )
491  {
492  cx += 16;
493  cy += 16;
494  }
495  if( attributes & msidbControlAttributesIconSize32 )
496  {
497  cx += 32;
498  cy += 32;
499  }
500  /* msidbControlAttributesIconSize48 handled by above logic */
501  }
502  return msi_load_image( db, text, IMAGE_ICON, cx, cy, flags );
503 }
504 
506 {
507  msi_control *control;
508 
509  LIST_FOR_EACH_ENTRY( control, &dialog->controls, msi_control, entry )
510  {
511  if ( control->property && !wcscmp( control->property, property ) && control->update )
512  control->update( dialog, control );
513  }
514 }
515 
517 {
518  msi_control *control;
519 
520  LIST_FOR_EACH_ENTRY( control, &dialog->controls, msi_control, entry )
521  {
522  if ( control->property && control->update )
523  control->update( dialog, control );
524  }
525 }
526 
528 {
529  UINT r = msi_set_property( package->db, property, value, -1 );
530  if (r == ERROR_SUCCESS && !wcscmp( property, L"SourceDir" ))
531  msi_reset_source_folders( package );
532 }
533 
535 {
536  TVITEMW tvi;
537 
538  /* get the feature from the item */
539  memset( &tvi, 0, sizeof tvi );
540  tvi.hItem = hItem;
541  tvi.mask = TVIF_PARAM | TVIF_HANDLE;
542  SendMessageW( hwnd, TVM_GETITEMW, 0, (LPARAM)&tvi );
543  return (MSIFEATURE *)tvi.lParam;
544 }
545 
547 {
552 };
553 
555 {
556  struct msi_selection_tree_info *info = GetPropW( control->hwnd, L"MSIDATA" );
557  return msi_seltree_feature_from_item( control->hwnd, info->selected );
558 }
559 
560 static void dialog_handle_event( msi_dialog *dialog, const WCHAR *control,
561  const WCHAR *attribute, MSIRECORD *rec )
562 {
563  msi_control* ctrl;
564 
565  ctrl = msi_dialog_find_control( dialog, control );
566  if (!ctrl)
567  return;
568  if( !wcscmp( attribute, L"Text" ) )
569  {
570  const WCHAR *font_text, *text = NULL;
571  WCHAR *font, *text_fmt = NULL;
572 
573  font_text = MSI_RecordGetString( rec , 1 );
574  font = msi_dialog_get_style( font_text, &text );
575  deformat_string( dialog->package, text, &text_fmt );
576  if (text_fmt) text = text_fmt;
577  else text = L"";
578 
579  SetWindowTextW( ctrl->hwnd, text );
580 
581  msi_free( font );
582  msi_free( text_fmt );
584  }
585  else if( !wcscmp( attribute, L"Progress" ) )
586  {
587  DWORD func, val1, val2, units;
588 
589  func = MSI_RecordGetInteger( rec, 1 );
590  val1 = MSI_RecordGetInteger( rec, 2 );
591  val2 = MSI_RecordGetInteger( rec, 3 );
592 
593  TRACE( "progress: func %lu val1 %lu val2 %lu\n", func, val1, val2 );
594 
595  units = val1 / 512;
596  switch (func)
597  {
598  case 0: /* init */
599  SendMessageW( ctrl->hwnd, PBM_SETRANGE, 0, MAKELPARAM(0,100) );
600  if (val2)
601  {
602  ctrl->progress_max = units ? units : 100;
603  ctrl->progress_current = units;
604  ctrl->progress_backwards = TRUE;
605  SendMessageW( ctrl->hwnd, PBM_SETPOS, 100, 0 );
606  }
607  else
608  {
609  ctrl->progress_max = units ? units : 100;
610  ctrl->progress_current = 0;
611  ctrl->progress_backwards = FALSE;
612  SendMessageW( ctrl->hwnd, PBM_SETPOS, 0, 0 );
613  }
614  break;
615  case 1: /* action data increment */
616  if (val2) dialog->package->action_progress_increment = val1;
617  else dialog->package->action_progress_increment = 0;
618  break;
619  case 2: /* move */
620  if (ctrl->progress_backwards)
621  {
622  if (units >= ctrl->progress_current) ctrl->progress_current -= units;
623  else ctrl->progress_current = 0;
624  }
625  else
626  {
627  if (ctrl->progress_current + units < ctrl->progress_max) ctrl->progress_current += units;
628  else ctrl->progress_current = ctrl->progress_max;
629  }
630  SendMessageW( ctrl->hwnd, PBM_SETPOS, MulDiv(100, ctrl->progress_current, ctrl->progress_max), 0 );
631  break;
632  case 3: /* add */
633  ctrl->progress_max += units;
634  break;
635  default:
636  FIXME( "unknown progress message %lu\n", func );
637  break;
638  }
639  }
640  else if ( !wcscmp( attribute, L"Property" ) )
641  {
643  if (feature) msi_dialog_set_property( dialog->package, ctrl->property, feature->Directory );
644  }
645  else if ( !wcscmp( attribute, L"SelectionPath" ) )
646  {
649  if (!path) return;
650  SetWindowTextW( ctrl->hwnd, path );
651  msi_free(path);
652  }
653  else
654  {
655  FIXME("Attribute %s not being set\n", debugstr_w(attribute));
656  return;
657  }
658 }
659 
660 static void event_subscribe( msi_dialog *dialog, const WCHAR *event, const WCHAR *control, const WCHAR *attribute )
661 {
662  struct subscriber *sub;
663 
664  TRACE("dialog %s event %s control %s attribute %s\n", debugstr_w(dialog->name), debugstr_w(event),
666 
667  LIST_FOR_EACH_ENTRY( sub, &dialog->package->subscriptions, struct subscriber, entry )
668  {
669  if (sub->dialog == dialog &&
670  !wcsicmp( sub->event, event ) &&
671  !wcsicmp( sub->control, control ) &&
672  !wcsicmp( sub->attribute, attribute ))
673  {
674  TRACE("already subscribed\n");
675  return;
676  };
677  }
678  if (!(sub = msi_alloc( sizeof(*sub) ))) return;
679  sub->dialog = dialog;
680  sub->event = strdupW( event );
681  sub->control = strdupW( control );
682  sub->attribute = strdupW( attribute );
683  list_add_tail( &dialog->package->subscriptions, &sub->entry );
684 }
685 
687 {
689  const WCHAR *control;
690 };
691 
692 static UINT map_event( MSIRECORD *row, void *param )
693 {
694  struct dialog_control *dc = param;
695  const WCHAR *event = MSI_RecordGetString( row, 3 );
696  const WCHAR *attribute = MSI_RecordGetString( row, 4 );
697 
698  event_subscribe( dc->dialog, event, dc->control, attribute );
699  return ERROR_SUCCESS;
700 }
701 
703 {
704  MSIQUERY *view;
706  {
707  dialog,
708  control
709  };
710 
711  if (!MSI_OpenQuery( dialog->package->db, &view,
712  L"SELECT * FROM `EventMapping` WHERE `Dialog_` = '%s' AND `Control_` = '%s'",
713  dialog->name, control ))
714  {
716  msiobj_release( &view->hdr );
717  }
718 }
719 
720 /* everything except radio buttons */
722  MSIRECORD *rec, LPCWSTR szCls, DWORD style )
723 {
724  DWORD attributes;
725  const WCHAR *text = NULL, *name, *control_type;
726  DWORD exstyle = 0;
727 
728  name = MSI_RecordGetString( rec, 2 );
729  control_type = MSI_RecordGetString( rec, 3 );
730  attributes = MSI_RecordGetInteger( rec, 8 );
731  if (wcscmp( control_type, L"ScrollableText" )) text = MSI_RecordGetString( rec, 10 );
732 
733  TRACE( "%s, %s, %#lx, %s, %#lx\n", debugstr_w(szCls), debugstr_w(name), attributes, debugstr_w(text), style );
734 
735  if( attributes & msidbControlAttributesVisible )
736  style |= WS_VISIBLE;
737  if( ~attributes & msidbControlAttributesEnabled )
738  style |= WS_DISABLED;
739  if( attributes & msidbControlAttributesSunken )
740  exstyle |= WS_EX_CLIENTEDGE;
741 
743 
744  return dialog_create_window( dialog, rec, exstyle, szCls, name, text, style, dialog->hwnd );
745 }
746 
748 {
752 };
753 
754 /*
755  * we don't erase our own background,
756  * so we have to make sure that the parent window redraws first
757  */
759 {
760  HWND hParent;
761  RECT rc;
762 
763  hParent = GetParent( hWnd );
764  GetWindowRect( hWnd, &rc );
765  MapWindowPoints( NULL, hParent, (LPPOINT) &rc, 2 );
766  InvalidateRect( hParent, &rc, TRUE );
767 }
768 
769 static LRESULT WINAPI
771 {
772  struct msi_text_info *info;
773  LRESULT r = 0;
774 
775  TRACE( "%p %04x %#Ix %#Ix\n", hWnd, msg, wParam, lParam );
776 
777  info = GetPropW(hWnd, L"MSIDATA");
778 
779  if( msg == WM_CTLCOLORSTATIC &&
780  ( info->attributes & msidbControlAttributesTransparent ) )
781  {
784  }
785 
786  r = CallWindowProcW(info->oldproc, hWnd, msg, wParam, lParam);
787  if ( info->font )
788  SetTextColor( (HDC)wParam, info->font->color );
789 
790  switch( msg )
791  {
792  case WM_SETTEXT:
794  break;
795  case WM_NCDESTROY:
796  msi_free( info );
797  RemovePropW( hWnd, L"MSIDATA" );
798  break;
799  }
800 
801  return r;
802 }
803 
805 {
806  msi_control *control;
807  struct msi_text_info *info;
808  LPCWSTR text, ptr, prop, control_name;
809  LPWSTR font_name;
810 
811  TRACE("%p %p\n", dialog, rec);
812 
813  control = msi_dialog_add_control( dialog, rec, L"Static", SS_LEFT | WS_GROUP );
814  if( !control )
815  return ERROR_FUNCTION_FAILED;
816 
817  info = msi_alloc( sizeof *info );
818  if( !info )
819  return ERROR_SUCCESS;
820 
821  control_name = MSI_RecordGetString( rec, 2 );
822  control->attributes = MSI_RecordGetInteger( rec, 8 );
823  prop = MSI_RecordGetString( rec, 9 );
824  control->property = msi_dialog_dup_property( dialog, prop, FALSE );
825 
826  text = MSI_RecordGetString( rec, 10 );
827  font_name = msi_dialog_get_style( text, &ptr );
828  info->font = ( font_name ) ? msi_dialog_find_font( dialog, font_name ) : NULL;
829  msi_free( font_name );
830 
831  info->attributes = MSI_RecordGetInteger( rec, 8 );
832  if( info->attributes & msidbControlAttributesTransparent )
834 
835  info->oldproc = (WNDPROC) SetWindowLongPtrW( control->hwnd, GWLP_WNDPROC,
837  SetPropW( control->hwnd, L"MSIDATA", info );
838 
839  event_subscribe( dialog, L"SelectionPath", control_name, L"SelectionPath" );
840  return ERROR_SUCCESS;
841 }
842 
843 /* strip any leading text style label from text field */
845 {
846  WCHAR *p, *text;
847 
848  text = msi_get_deformatted_field( package, rec, 10 );
849  if (!text)
850  return NULL;
851 
852  p = text;
853  while (*p && *p != '{') p++;
854  if (!*p++) return text;
855 
856  while (*p && *p != '}') p++;
857  if (!*p++) return text;
858 
859  p = strdupW( p );
860  msi_free( text );
861  return p;
862 }
863 
865 {
866  LPWSTR p, prop, arg_fmt = NULL;
867  UINT len;
868 
869  len = lstrlenW( event );
870  prop = msi_alloc( len * sizeof(WCHAR) );
871  lstrcpyW( prop, &event[1] );
872  p = wcschr( prop, ']' );
873  if (p && (p[1] == 0 || p[1] == ' '))
874  {
875  *p = 0;
876  if (wcscmp( L"{}", arg )) deformat_string( dialog->package, arg, &arg_fmt );
877  msi_dialog_set_property( dialog->package, prop, arg_fmt );
879  msi_free( arg_fmt );
880  }
881  else ERR("Badly formatted property string - what happens?\n");
882  msi_free( prop );
883  return ERROR_SUCCESS;
884 }
885 
887 {
888  LPWSTR event_fmt = NULL, arg_fmt = NULL;
889 
890  TRACE("Sending control event %s %s\n", debugstr_w(event), debugstr_w(arg));
891 
892  deformat_string( dialog->package, event, &event_fmt );
893  deformat_string( dialog->package, arg, &arg_fmt );
894 
895  dialog->event_handler( dialog, event_fmt, arg_fmt );
896 
897  msi_free( event_fmt );
898  msi_free( arg_fmt );
899 
900  return ERROR_SUCCESS;
901 }
902 
904 {
907  UINT r;
908 
909  condition = MSI_RecordGetString( rec, 5 );
910  r = MSI_EvaluateConditionW( dialog->package, condition );
911  if (r == MSICONDITION_TRUE || r == MSICONDITION_NONE)
912  {
913  event = MSI_RecordGetString( rec, 3 );
914  arg = MSI_RecordGetString( rec, 4 );
915  if (event[0] == '[')
917  else
919  }
920  return ERROR_SUCCESS;
921 }
922 
924 {
925  MSIQUERY *view;
926  UINT r;
927 
928  if (HIWORD(param) != BN_CLICKED)
929  return ERROR_SUCCESS;
930 
931  r = MSI_OpenQuery( dialog->package->db, &view,
932  L"SELECT * FROM `ControlEvent` WHERE `Dialog_` = '%s' AND `Control_` = '%s' ORDER BY `Ordering`",
933  dialog->name, control->name );
934  if (r != ERROR_SUCCESS)
935  {
936  ERR("query failed\n");
937  return ERROR_SUCCESS;
938  }
940  msiobj_release( &view->hdr );
941 
942  /* dialog control events must be processed last regardless of ordering */
943  if (dialog->pending_event)
944  {
945  r = dialog->pending_event( dialog, dialog->pending_argument );
946 
947  msi_free( dialog->pending_argument );
948  dialog->pending_event = NULL;
949  dialog->pending_argument = NULL;
950  }
951  return r;
952 }
953 
955 {
956  HBITMAP hOleBitmap = 0, hBitmap = 0, hOldSrcBitmap, hOldDestBitmap;
957  MSIRECORD *rec = NULL;
958  IStream *stm = NULL;
959  IPicture *pic = NULL;
960  HDC srcdc, destdc;
961  BITMAP bm;
962  UINT r;
963 
964  rec = MSI_QueryGetRecord( db, L"SELECT * FROM `Binary` WHERE `Name` = '%s'", name );
965  if (!rec)
966  goto end;
967 
968  r = MSI_RecordGetIStream( rec, 2, &stm );
969  msiobj_release( &rec->hdr );
970  if (r != ERROR_SUCCESS)
971  goto end;
972 
973  r = OleLoadPicture( stm, 0, TRUE, &IID_IPicture, (void **)&pic );
974  IStream_Release( stm );
975  if (FAILED( r ))
976  {
977  ERR("failed to load picture\n");
978  goto end;
979  }
980 
981  r = IPicture_get_Handle( pic, (OLE_HANDLE *)&hOleBitmap );
982  if (FAILED( r ))
983  {
984  ERR("failed to get bitmap handle\n");
985  goto end;
986  }
987 
988  /* make the bitmap the desired size */
989  r = GetObjectW( hOleBitmap, sizeof(bm), &bm );
990  if (r != sizeof(bm))
991  {
992  ERR("failed to get bitmap size\n");
993  goto end;
994  }
995 
996  if (flags & LR_DEFAULTSIZE)
997  {
998  cx = bm.bmWidth;
999  cy = bm.bmHeight;
1000  }
1001 
1002  srcdc = CreateCompatibleDC( NULL );
1003  hOldSrcBitmap = SelectObject( srcdc, hOleBitmap );
1004  destdc = CreateCompatibleDC( NULL );
1005  hBitmap = CreateCompatibleBitmap( srcdc, cx, cy );
1006  hOldDestBitmap = SelectObject( destdc, hBitmap );
1007  StretchBlt( destdc, 0, 0, cx, cy, srcdc, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY );
1008  SelectObject( srcdc, hOldSrcBitmap );
1009  SelectObject( destdc, hOldDestBitmap );
1010  DeleteDC( srcdc );
1011  DeleteDC( destdc );
1012 
1013 end:
1014  if (pic) IPicture_Release( pic );
1015  return hBitmap;
1016 }
1017 
1019 {
1020  msi_control *control;
1021  UINT attributes, style, cx = 0, cy = 0, flags = 0;
1022  WCHAR *name = NULL;
1023 
1024  TRACE("%p %p\n", dialog, rec);
1025 
1026  style = WS_TABSTOP;
1027  attributes = MSI_RecordGetInteger( rec, 8 );
1030  {
1031  style |= BS_BITMAP;
1033  else
1034  {
1037  }
1038  }
1039 
1040  control = msi_dialog_add_control( dialog, rec, L"BUTTON", style );
1041  if (!control)
1042  return ERROR_FUNCTION_FAILED;
1043 
1045 
1047  {
1048  name = msi_get_binary_name( dialog->package, rec );
1049  control->hIcon = msi_load_icon( dialog->package->db, name, attributes );
1050  if (control->hIcon)
1051  {
1052  SendMessageW( control->hwnd, BM_SETIMAGE, IMAGE_ICON, (LPARAM) control->hIcon );
1053  }
1054  else ERR("Failed to load icon %s\n", debugstr_w(name));
1055  }
1057  {
1058  name = msi_get_binary_name( dialog->package, rec );
1059  control->hBitmap = msi_load_picture( dialog->package->db, name, cx, cy, flags );
1060  if (control->hBitmap)
1061  {
1062  SendMessageW( control->hwnd, BM_SETIMAGE, IMAGE_BITMAP, (LPARAM) control->hBitmap );
1063  }
1064  else ERR("Failed to load bitmap %s\n", debugstr_w(name));
1065  }
1066 
1067  msi_free( name );
1068  return ERROR_SUCCESS;
1069 }
1070 
1072 {
1073  MSIRECORD *rec = NULL;
1074  LPWSTR ret = NULL;
1075 
1076  /* find if there is a value associated with the checkbox */
1077  rec = MSI_QueryGetRecord( dialog->package->db, L"SELECT * FROM `CheckBox` WHERE `Property` = '%s'", prop );
1078  if (!rec)
1079  return ret;
1080 
1081  ret = msi_get_deformatted_field( dialog->package, rec, 2 );
1082  if( ret && !ret[0] )
1083  {
1084  msi_free( ret );
1085  ret = NULL;
1086  }
1087  msiobj_release( &rec->hdr );
1088  if (ret)
1089  return ret;
1090 
1091  ret = msi_dup_property( dialog->package->db, prop );
1092  if( ret && !ret[0] )
1093  {
1094  msi_free( ret );
1095  ret = NULL;
1096  }
1097 
1098  return ret;
1099 }
1100 
1102 {
1103  WCHAR state[2] = {0};
1104  DWORD sz = 2;
1105 
1106  msi_get_property( dialog->package->db, control->property, state, &sz );
1107  return state[0] ? 1 : 0;
1108 }
1109 
1111 {
1112  LPCWSTR val;
1113 
1114  /* if uncheck then the property is set to NULL */
1115  if (!state)
1116  {
1117  msi_dialog_set_property( dialog->package, control->property, NULL );
1118  return;
1119  }
1120 
1121  /* check for a custom state */
1122  if (control->value && control->value[0])
1123  val = control->value;
1124  else
1125  val = L"1";
1126 
1127  msi_dialog_set_property( dialog->package, control->property, val );
1128 }
1129 
1131 {
1134 }
1135 
1137 {
1138  UINT state;
1139 
1140  if (HIWORD(param) != BN_CLICKED)
1141  return ERROR_SUCCESS;
1142 
1143  TRACE("clicked checkbox %s, set %s\n", debugstr_w(control->name), debugstr_w(control->property));
1144 
1146  state = state ? 0 : 1;
1149 
1150  return msi_dialog_button_handler( dialog, control, param );
1151 }
1152 
1154 {
1155  msi_control *control;
1156  LPCWSTR prop;
1157 
1158  TRACE("%p %p\n", dialog, rec);
1159 
1160  control = msi_dialog_add_control( dialog, rec, L"BUTTON", BS_CHECKBOX | BS_MULTILINE | WS_TABSTOP );
1163  prop = MSI_RecordGetString( rec, 9 );
1164  if (prop)
1165  {
1166  control->property = strdupW( prop );
1167  control->value = msi_get_checkbox_value( dialog, prop );
1168  TRACE("control %s value %s\n", debugstr_w(control->property), debugstr_w(control->value));
1169  }
1171  return ERROR_SUCCESS;
1172 }
1173 
1175 {
1176  DWORD attributes;
1177  LPCWSTR name;
1178  DWORD style, exstyle = 0;
1179  DWORD x, y, width, height;
1180  msi_control *control;
1181 
1182  TRACE("%p %p\n", dialog, rec);
1183 
1185 
1186  name = MSI_RecordGetString( rec, 2 );
1187  attributes = MSI_RecordGetInteger( rec, 8 );
1188 
1190  style |= WS_VISIBLE;
1192  style |= WS_DISABLED;
1194  exstyle |= WS_EX_CLIENTEDGE;
1195 
1197 
1198  control = msi_alloc( FIELD_OFFSET(msi_control, name[lstrlenW( name ) + 1] ));
1199  if (!control)
1200  return ERROR_OUTOFMEMORY;
1201 
1202  lstrcpyW( control->name, name );
1203  list_add_head( &dialog->controls, &control->entry );
1204  control->handler = NULL;
1205  control->property = NULL;
1206  control->value = NULL;
1207  control->hBitmap = NULL;
1208  control->hIcon = NULL;
1209  control->hDll = NULL;
1210  control->tabnext = strdupW( MSI_RecordGetString( rec, 11) );
1211  control->type = strdupW( MSI_RecordGetString( rec, 3 ) );
1212  control->progress_current = 0;
1213  control->progress_max = 100;
1214  control->progress_backwards = FALSE;
1215 
1216  x = MSI_RecordGetInteger( rec, 4 );
1217  y = MSI_RecordGetInteger( rec, 5 );
1218  width = MSI_RecordGetInteger( rec, 6 );
1219 
1223  height = 2; /* line is exactly 2 units in height */
1224 
1225  control->hwnd = CreateWindowExW( exstyle, L"Static", NULL, style,
1226  x, y, width, height, dialog->hwnd, NULL, NULL, NULL );
1227 
1228  TRACE("Dialog %s control %s hwnd %p\n",
1229  debugstr_w(dialog->name), debugstr_w(name), control->hwnd );
1230 
1231  return ERROR_SUCCESS;
1232 }
1233 
1234 /******************** Scroll Text ********************************************/
1235 
1237 {
1241 };
1242 
1243 static LRESULT WINAPI
1245 {
1246  struct msi_scrolltext_info *info;
1247  HRESULT r;
1248 
1249  TRACE( "%p %04x %#Ix %#Ix\n", hWnd, msg, wParam, lParam );
1250 
1251  info = GetPropW( hWnd, L"MSIDATA" );
1252 
1253  r = CallWindowProcW( info->oldproc, hWnd, msg, wParam, lParam );
1254 
1255  switch( msg )
1256  {
1257  case WM_GETDLGCODE:
1258  return DLGC_WANTARROWS;
1259  case WM_NCDESTROY:
1260  msi_free( info );
1261  RemovePropW( hWnd, L"MSIDATA" );
1262  break;
1263  case WM_PAINT:
1264  /* native MSI sets a wait cursor here */
1265  msi_dialog_button_handler( info->dialog, info->control, BN_CLICKED );
1266  break;
1267  }
1268  return r;
1269 }
1270 
1272 {
1276 };
1277 
1278 static DWORD CALLBACK
1280 {
1281  struct msi_streamin_info *info = (struct msi_streamin_info*) arg;
1282 
1283  if( (count + info->offset) > info->length )
1284  count = info->length - info->offset;
1285  memcpy( buffer, &info->string[ info->offset ], count );
1286  *pcb = count;
1287  info->offset += count;
1288 
1289  TRACE( "%lu/%lu\n", info->offset, info->length );
1290 
1291  return 0;
1292 }
1293 
1295 {
1296  struct msi_streamin_info info;
1297  EDITSTREAM es;
1298 
1299  info.string = strdupWtoA( text );
1300  info.offset = 0;
1301  info.length = lstrlenA( info.string ) + 1;
1302 
1303  es.dwCookie = (DWORD_PTR) &info;
1304  es.dwError = 0;
1305  es.pfnCallback = msi_richedit_stream_in;
1306 
1307  SendMessageW( control->hwnd, EM_STREAMIN, SF_RTF, (LPARAM) &es );
1308 
1309  msi_free( info.string );
1310 }
1311 
1313 {
1314  struct msi_scrolltext_info *info;
1316  HMODULE hRichedit;
1317  LPCWSTR text;
1318  DWORD style;
1319 
1320  info = msi_alloc( sizeof *info );
1321  if (!info)
1322  return ERROR_FUNCTION_FAILED;
1323 
1324  hRichedit = LoadLibraryA("riched20");
1325 
1328  control = msi_dialog_add_control( dialog, rec, L"RichEdit20W", style );
1329  if (!control)
1330  {
1331  FreeLibrary( hRichedit );
1332  msi_free( info );
1333  return ERROR_FUNCTION_FAILED;
1334  }
1335 
1336  control->hDll = hRichedit;
1337 
1338  info->dialog = dialog;
1339  info->control = control;
1340 
1341  /* subclass the static control */
1344  SetPropW( control->hwnd, L"MSIDATA", info );
1345 
1346  /* add the text into the richedit */
1347  text = MSI_RecordGetString( rec, 10 );
1348  if (text)
1350 
1351  return ERROR_SUCCESS;
1352 }
1353 
1354 
1356 {
1357  UINT cx, cy, flags, style, attributes;
1359  LPWSTR name;
1360 
1363 
1364  attributes = MSI_RecordGetInteger( rec, 8 );
1365  if( attributes & msidbControlAttributesFixedSize )
1366  {
1367  flags |= LR_DEFAULTSIZE;
1368  style |= SS_CENTERIMAGE;
1369  }
1370 
1371  control = msi_dialog_add_control( dialog, rec, L"Static", style );
1372  cx = MSI_RecordGetInteger( rec, 6 );
1373  cy = MSI_RecordGetInteger( rec, 7 );
1376 
1377  name = msi_get_binary_name( dialog->package, rec );
1378  control->hBitmap = msi_load_picture( dialog->package->db, name, cx, cy, flags );
1379  if( control->hBitmap )
1382  else
1383  ERR("Failed to load bitmap %s\n", debugstr_w(name));
1384 
1385  msi_free( name );
1386 
1387  return ERROR_SUCCESS;
1388 }
1389 
1391 {
1393  DWORD attributes;
1394  LPWSTR name;
1395 
1396  TRACE("\n");
1397 
1398  control = msi_dialog_add_control( dialog, rec, L"Static",
1400 
1401  attributes = MSI_RecordGetInteger( rec, 8 );
1402  name = msi_get_binary_name( dialog->package, rec );
1403  control->hIcon = msi_load_icon( dialog->package->db, name, attributes );
1404  if( control->hIcon )
1406  else
1407  ERR("Failed to load bitmap %s\n", debugstr_w(name));
1408  msi_free( name );
1409  return ERROR_SUCCESS;
1410 }
1411 
1412 /******************** Combo Box ***************************************/
1413 
1415 {
1422 };
1423 
1425 {
1426  struct msi_combobox_info *info;
1427  LRESULT r;
1428  DWORD j;
1429 
1430  TRACE( "%p %04x %#Ix %#Ix\n", hWnd, msg, wParam, lParam );
1431 
1432  info = GetPropW( hWnd, L"MSIDATA" );
1433  if (!info)
1434  return 0;
1435 
1436  r = CallWindowProcW( info->oldproc, hWnd, msg, wParam, lParam );
1437 
1438  switch (msg)
1439  {
1440  case WM_NCDESTROY:
1441  for (j = 0; j < info->num_items; j++)
1442  msi_free( info->items[j] );
1443  msi_free( info->items );
1444  msi_free( info );
1445  RemovePropW( hWnd, L"MSIDATA" );
1446  break;
1447  }
1448 
1449  return r;
1450 }
1451 
1453 {
1454  struct msi_combobox_info *info = param;
1455  LPCWSTR value, text;
1456  int pos;
1457 
1458  value = MSI_RecordGetString( rec, 3 );
1459  text = MSI_RecordGetString( rec, 4 );
1460 
1461  info->items[info->addpos_items] = strdupW( value );
1462 
1463  pos = SendMessageW( info->hwnd, CB_ADDSTRING, 0, (LPARAM)text );
1464  SendMessageW( info->hwnd, CB_SETITEMDATA, pos, (LPARAM)info->items[info->addpos_items] );
1465  info->addpos_items++;
1466 
1467  return ERROR_SUCCESS;
1468 }
1469 
1471 {
1472  MSIQUERY *view;
1473  DWORD count;
1474  UINT r;
1475 
1476  r = MSI_OpenQuery( info->dialog->package->db, &view,
1477  L"SELECT * FROM `ComboBox` WHERE `Property` = '%s' ORDER BY `Order`", property );
1478  if (r != ERROR_SUCCESS)
1479  return r;
1480 
1481  /* just get the number of records */
1482  count = 0;
1484  if (r != ERROR_SUCCESS)
1485  {
1486  msiobj_release( &view->hdr );
1487  return r;
1488  }
1489  info->num_items = count;
1490  info->items = msi_alloc( sizeof(*info->items) * count );
1491 
1493  msiobj_release( &view->hdr );
1494  return r;
1495 }
1496 
1498 {
1499  msi_dialog *dialog = param;
1500  msi_control *control;
1502  UINT r;
1503 
1504  name = MSI_RecordGetString( rec, 2 );
1505  action = MSI_RecordGetString( rec, 3 );
1506  condition = MSI_RecordGetString( rec, 4 );
1507  r = MSI_EvaluateConditionW( dialog->package, condition );
1508  control = msi_dialog_find_control( dialog, name );
1509  if (r == MSICONDITION_TRUE && control)
1510  {
1511  TRACE("%s control %s\n", debugstr_w(action), debugstr_w(name));
1512 
1513  /* FIXME: case sensitive? */
1514  if (!wcscmp( action, L"Hide" ))
1515  ShowWindow(control->hwnd, SW_HIDE);
1516  else if (!wcscmp( action, L"Show" ))
1517  ShowWindow(control->hwnd, SW_SHOW);
1518  else if (!wcscmp( action, L"Disable" ))
1519  EnableWindow(control->hwnd, FALSE);
1520  else if (!wcscmp( action, L"Enable" ))
1521  EnableWindow(control->hwnd, TRUE);
1522  else if (!wcscmp( action, L"Default" ))
1523  SetFocus(control->hwnd);
1524  else
1525  FIXME("Unhandled action %s\n", debugstr_w(action));
1526  }
1527  return ERROR_SUCCESS;
1528 }
1529 
1531 {
1532  UINT r;
1533  MSIQUERY *view;
1534  MSIPACKAGE *package = dialog->package;
1535 
1536  TRACE("%p %s\n", dialog, debugstr_w(dialog->name));
1537 
1538  /* query the Control table for all the elements of the control */
1539  r = MSI_OpenQuery( package->db, &view, L"SELECT * FROM `ControlCondition` WHERE `Dialog_` = '%s'", dialog->name );
1540  if (r != ERROR_SUCCESS)
1541  return ERROR_SUCCESS;
1542 
1544  msiobj_release( &view->hdr );
1545  return r;
1546 }
1547 
1549 {
1550  struct msi_combobox_info *info;
1551  int index;
1552  LPWSTR value;
1553 
1555  return ERROR_SUCCESS;
1556 
1557  info = GetPropW( control->hwnd, L"MSIDATA" );
1558  index = SendMessageW( control->hwnd, CB_GETCURSEL, 0, 0 );
1559  if (index == CB_ERR)
1560  value = msi_get_window_text( control->hwnd );
1561  else
1562  value = (LPWSTR) SendMessageW( control->hwnd, CB_GETITEMDATA, index, 0 );
1563 
1564  msi_dialog_set_property( info->dialog->package, control->property, value );
1566 
1567  if (index == CB_ERR)
1568  msi_free( value );
1569 
1570  return ERROR_SUCCESS;
1571 }
1572 
1574 {
1575  struct msi_combobox_info *info;
1576  LPWSTR value, tmp;
1577  DWORD j;
1578 
1579  info = GetPropW( control->hwnd, L"MSIDATA" );
1580 
1581  value = msi_dup_property( dialog->package->db, control->property );
1582  if (!value)
1583  {
1584  SendMessageW( control->hwnd, CB_SETCURSEL, -1, 0 );
1585  return;
1586  }
1587 
1588  for (j = 0; j < info->num_items; j++)
1589  {
1590  tmp = (LPWSTR) SendMessageW( control->hwnd, CB_GETITEMDATA, j, 0 );
1591  if (!wcscmp( value, tmp ))
1592  break;
1593  }
1594 
1595  if (j < info->num_items)
1596  {
1597  SendMessageW( control->hwnd, CB_SETCURSEL, j, 0 );
1598  }
1599  else
1600  {
1601  SendMessageW( control->hwnd, CB_SETCURSEL, -1, 0 );
1602  SetWindowTextW( control->hwnd, value );
1603  }
1604 
1605  msi_free(value);
1606 }
1607 
1609 {
1610  struct msi_combobox_info *info;
1611  msi_control *control;
1612  DWORD attributes, style;
1613  LPCWSTR prop;
1614 
1615  info = msi_alloc( sizeof *info );
1616  if (!info)
1617  return ERROR_FUNCTION_FAILED;
1618 
1620  attributes = MSI_RecordGetInteger( rec, 8 );
1621  if ( ~attributes & msidbControlAttributesSorted)
1622  style |= CBS_SORT;
1623  if ( attributes & msidbControlAttributesComboList)
1625  else
1626  style |= CBS_DROPDOWN;
1627 
1628  control = msi_dialog_add_control( dialog, rec, WC_COMBOBOXW, style );
1629  if (!control)
1630  {
1631  msi_free( info );
1632  return ERROR_FUNCTION_FAILED;
1633  }
1634 
1637 
1638  prop = MSI_RecordGetString( rec, 9 );
1639  control->property = msi_dialog_dup_property( dialog, prop, FALSE );
1640 
1641  /* subclass */
1642  info->dialog = dialog;
1643  info->hwnd = control->hwnd;
1644  info->items = NULL;
1645  info->addpos_items = 0;
1646  info->oldproc = (WNDPROC)SetWindowLongPtrW( control->hwnd, GWLP_WNDPROC,
1648  SetPropW( control->hwnd, L"MSIDATA", info );
1649 
1650  if (control->property)
1651  msi_combobox_add_items( info, control->property );
1652 
1653  msi_dialog_combobox_update( dialog, control );
1654 
1655  return ERROR_SUCCESS;
1656 }
1657 
1659 {
1660  LPWSTR buf;
1661 
1662  if (HIWORD(param) != EN_CHANGE)
1663  return ERROR_SUCCESS;
1664 
1665  TRACE("edit %s contents changed, set %s\n", debugstr_w(control->name), debugstr_w(control->property));
1666 
1667  buf = msi_get_window_text( control->hwnd );
1668  msi_dialog_set_property( dialog->package, control->property, buf );
1669  msi_free( buf );
1670 
1671  return ERROR_SUCCESS;
1672 }
1673 
1674 /* length of 2^32 + 1 */
1675 #define MAX_NUM_DIGITS 11
1676 
1678 {
1679  msi_control *control;
1680  LPCWSTR prop, text;
1681  LPWSTR val, begin, end;
1683  DWORD limit;
1684 
1685  control = msi_dialog_add_control( dialog, rec, L"Edit",
1687  control->handler = msi_dialog_edit_handler;
1688 
1689  text = MSI_RecordGetString( rec, 10 );
1690  if ( text )
1691  {
1692  begin = wcschr( text, '{' );
1693  end = wcschr( text, '}' );
1694 
1695  if ( begin && end && end > begin &&
1696  begin[0] >= '0' && begin[0] <= '9' &&
1697  end - begin < MAX_NUM_DIGITS)
1698  {
1699  lstrcpynW( num, begin + 1, end - begin );
1700  limit = wcstol( num, NULL, 10 );
1701 
1702  SendMessageW( control->hwnd, EM_SETLIMITTEXT, limit, 0 );
1703  }
1704  }
1705 
1706  prop = MSI_RecordGetString( rec, 9 );
1707  if( prop )
1708  control->property = strdupW( prop );
1709 
1710  val = msi_dup_property( dialog->package->db, control->property );
1711  SetWindowTextW( control->hwnd, val );
1712  msi_free( val );
1713  return ERROR_SUCCESS;
1714 }
1715 
1716 /******************** Masked Edit ********************************************/
1717 
1718 #define MASK_MAX_GROUPS 20
1719 
1721 {
1726 };
1727 
1729 {
1737 };
1738 
1740 {
1741  switch (type)
1742  {
1743  case '%':
1744  case '#':
1745  case '&':
1746  case '`':
1747  case '?':
1748  case '^':
1749  return TRUE;
1750  }
1751  return FALSE;
1752 }
1753 
1755 {
1756  LPWSTR val;
1757  UINT i, n, r;
1758 
1759  val = msi_alloc( (info->num_chars+1)*sizeof(WCHAR) );
1760  for( i=0, n=0; i<info->num_groups; i++ )
1761  {
1762  if (info->group[i].len == ~0u)
1763  {
1764  UINT len = SendMessageW( info->group[i].hwnd, WM_GETTEXTLENGTH, 0, 0 );
1765  val = msi_realloc( val, (len + 1) * sizeof(WCHAR) );
1766  GetWindowTextW( info->group[i].hwnd, val, len + 1 );
1767  }
1768  else
1769  {
1770  if (info->group[i].len + n > info->num_chars)
1771  {
1772  ERR("can't fit control %d text into template\n",i);
1773  break;
1774  }
1775  if (!msi_mask_editable(info->group[i].type))
1776  {
1777  for(r=0; r<info->group[i].len; r++)
1778  val[n+r] = info->group[i].type;
1779  val[n+r] = 0;
1780  }
1781  else
1782  {
1783  r = GetWindowTextW( info->group[i].hwnd, &val[n], info->group[i].len+1 );
1784  if( r != info->group[i].len )
1785  break;
1786  }
1787  n += r;
1788  }
1789  }
1790 
1791  TRACE("%d/%d controls were good\n", i, info->num_groups);
1792 
1793  if( i == info->num_groups )
1794  {
1795  TRACE("Set property %s to %s\n", debugstr_w(info->prop), debugstr_w(val));
1796  msi_dialog_set_property( info->dialog->package, info->prop, val );
1798  }
1799  msi_free( val );
1800 }
1801 
1802 /* now move to the next control if necessary */
1804 {
1805  HWND hWndNext;
1806  UINT len, i;
1807 
1808  for( i=0; i<info->num_groups; i++ )
1809  if( info->group[i].hwnd == hWnd )
1810  break;
1811 
1812  /* don't move from the last control */
1813  if( i >= (info->num_groups-1) )
1814  return;
1815 
1816  len = SendMessageW( hWnd, WM_GETTEXTLENGTH, 0, 0 );
1817  if( len < info->group[i].len )
1818  return;
1819 
1820  hWndNext = GetNextDlgTabItem( GetParent( hWnd ), hWnd, FALSE );
1821  SetFocus( hWndNext );
1822 }
1823 
1824 static LRESULT WINAPI
1826 {
1827  struct msi_maskedit_info *info;
1828  HRESULT r;
1829 
1830  TRACE("%p %04x %#Ix %#Ix\n", hWnd, msg, wParam, lParam);
1831 
1832  info = GetPropW(hWnd, L"MSIDATA");
1833 
1834  r = CallWindowProcW(info->oldproc, hWnd, msg, wParam, lParam);
1835 
1836  switch( msg )
1837  {
1838  case WM_COMMAND:
1839  if (HIWORD(wParam) == EN_CHANGE)
1840  {
1843  }
1844  break;
1845  case WM_NCDESTROY:
1846  msi_free( info->prop );
1847  msi_free( info );
1848  RemovePropW( hWnd, L"MSIDATA" );
1849  break;
1850  }
1851 
1852  return r;
1853 }
1854 
1855 /* fish the various bits of the property out and put them in the control */
1856 static void
1858 {
1859  LPCWSTR p;
1860  UINT i;
1861 
1862  p = text;
1863  for( i = 0; i < info->num_groups; i++ )
1864  {
1865  if( info->group[i].len < lstrlenW( p ) )
1866  {
1867  LPWSTR chunk = strdupW( p );
1868  chunk[ info->group[i].len ] = 0;
1869  SetWindowTextW( info->group[i].hwnd, chunk );
1870  msi_free( chunk );
1871  }
1872  else
1873  {
1874  SetWindowTextW( info->group[i].hwnd, p );
1875  break;
1876  }
1877  p += info->group[i].len;
1878  }
1879 }
1880 
1882 {
1883  struct msi_maskedit_info *info;
1884  int i = 0, n = 0, total = 0;
1885  LPCWSTR p;
1886 
1887  TRACE("masked control, template %s\n", debugstr_w(mask));
1888 
1889  if( !mask )
1890  return NULL;
1891 
1892  info = msi_alloc_zero( sizeof *info );
1893  if( !info )
1894  return info;
1895 
1896  p = wcschr(mask, '<');
1897  if( p )
1898  p++;
1899  else
1900  p = mask;
1901 
1902  for( i=0; i<MASK_MAX_GROUPS; i++ )
1903  {
1904  /* stop at the end of the string */
1905  if( p[0] == 0 || p[0] == '>' )
1906  {
1907  if (!total)
1908  {
1909  /* create a group for the empty mask */
1910  info->group[0].type = '&';
1911  info->group[0].len = ~0u;
1912  i = 1;
1913  }
1914  break;
1915  }
1916 
1917  /* count the number of the same identifier */
1918  for( n=0; p[n] == p[0]; n++ )
1919  ;
1920  info->group[i].ofs = total;
1921  info->group[i].type = p[0];
1922  if( p[n] == '=' )
1923  {
1924  n++;
1925  total++; /* an extra not part of the group */
1926  }
1927  info->group[i].len = n;
1928  total += n;
1929  p += n;
1930  }
1931 
1932  TRACE("%d characters in %d groups\n", total, i );
1933  if( i == MASK_MAX_GROUPS )
1934  ERR("too many groups in PIDTemplate %s\n", debugstr_w(mask));
1935 
1936  info->num_chars = total;
1937  info->num_groups = i;
1938 
1939  return info;
1940 }
1941 
1942 static void
1944 {
1945  DWORD width, height, style, wx, ww;
1946  RECT rect;
1947  HWND hwnd;
1948  UINT i;
1949 
1951 
1952  GetClientRect( info->hwnd, &rect );
1953 
1954  width = rect.right - rect.left;
1955  height = rect.bottom - rect.top;
1956 
1957  for( i = 0; i < info->num_groups; i++ )
1958  {
1959  if (!msi_mask_editable( info->group[i].type ))
1960  continue;
1961  if (info->num_chars)
1962  {
1963  wx = (info->group[i].ofs * width) / info->num_chars;
1964  ww = (info->group[i].len * width) / info->num_chars;
1965  }
1966  else
1967  {
1968  wx = 0;
1969  ww = width;
1970  }
1971  hwnd = CreateWindowW( L"Edit", NULL, style, wx, 0, ww, height,
1972  info->hwnd, NULL, NULL, NULL );
1973  if( !hwnd )
1974  {
1975  ERR("failed to create mask edit sub window\n");
1976  break;
1977  }
1978 
1979  SendMessageW( hwnd, EM_LIMITTEXT, info->group[i].len, 0 );
1980 
1981  msi_dialog_set_font( info->dialog, hwnd,
1982  font?font:info->dialog->default_font );
1983  info->group[i].hwnd = hwnd;
1984  }
1985 }
1986 
1987 /*
1988  * office 2003 uses "73931<````=````=````=````=`````>@@@@@"
1989  * delphi 7 uses "<????-??????-??????-????>" and "<???-???>"
1990  * filemaker pro 7 uses "<^^^^=^^^^=^^^^=^^^^=^^^^=^^^^=^^^^^>"
1991  */
1993 {
1994  LPWSTR font_mask, val = NULL, font;
1995  struct msi_maskedit_info *info = NULL;
1997  msi_control *control;
1998  LPCWSTR prop, mask;
1999 
2000  TRACE("\n");
2001 
2002  font_mask = msi_get_deformatted_field( dialog->package, rec, 10 );
2003  font = msi_dialog_get_style( font_mask, &mask );
2004  if( !mask )
2005  {
2006  WARN("mask template is empty\n");
2007  goto end;
2008  }
2009 
2011  if( !info )
2012  {
2013  ERR("template %s is invalid\n", debugstr_w(mask));
2014  goto end;
2015  }
2016 
2017  info->dialog = dialog;
2018 
2019  control = msi_dialog_add_control( dialog, rec, L"Static",
2021  if( !control )
2022  {
2023  ERR("Failed to create maskedit container\n");
2025  goto end;
2026  }
2028 
2029  info->hwnd = control->hwnd;
2030 
2031  /* subclass the static control */
2032  info->oldproc = (WNDPROC) SetWindowLongPtrW( info->hwnd, GWLP_WNDPROC,
2034  SetPropW( control->hwnd, L"MSIDATA", info );
2035 
2036  prop = MSI_RecordGetString( rec, 9 );
2037  if( prop )
2038  info->prop = strdupW( prop );
2039 
2041 
2042  if( prop )
2043  {
2044  val = msi_dup_property( dialog->package->db, prop );
2045  if( val )
2046  {
2048  msi_free( val );
2049  }
2050  }
2051 
2052 end:
2053  if( ret != ERROR_SUCCESS )
2054  msi_free( info );
2055  msi_free( font_mask );
2056  msi_free( font );
2057  return ret;
2058 }
2059 
2060 /******************** Progress Bar *****************************************/
2061 
2063 {
2064  msi_control *control;
2065  DWORD attributes, style;
2066 
2067  style = WS_VISIBLE;
2068  attributes = MSI_RecordGetInteger( rec, 8 );
2069  if( !(attributes & msidbControlAttributesProgress95) )
2070  style |= PBS_SMOOTH;
2071 
2072  control = msi_dialog_add_control( dialog, rec, PROGRESS_CLASSW, style );
2073  if( !control )
2074  return ERROR_FUNCTION_FAILED;
2075 
2076  event_subscribe( dialog, L"SetProgress", control->name, L"Progress" );
2077  return ERROR_SUCCESS;
2078 }
2079 
2080 /******************** Path Edit ********************************************/
2081 
2083 {
2087 };
2088 
2090 {
2091  WCHAR *prop, *path;
2093  if (!(prop = msi_dialog_dup_property( dialog, control->property, indirect ))) return NULL;
2095  msi_free( prop );
2096  return path;
2097 }
2098 
2100 {
2101  WCHAR *path;
2102 
2103  if (!control && !(control = msi_dialog_find_control_by_type( dialog, L"PathEdit" )))
2104  return;
2105 
2106  if (!(path = get_path_property( dialog, control ))) return;
2107  SetWindowTextW( control->hwnd, path );
2108  SendMessageW( control->hwnd, EM_SETSEL, 0, -1 );
2109  msi_free( path );
2110 }
2111 
2112 /* FIXME: test when this should fail */
2114 {
2115  if ( !path[0] )
2116  return FALSE;
2117 
2118  if ( PathIsRelativeW( path ) )
2119  return FALSE;
2120 
2121  return TRUE;
2122 }
2123 
2124 /* returns TRUE if the path is valid, FALSE otherwise */
2126 {
2127  LPWSTR buf, prop;
2128  BOOL indirect;
2129  BOOL valid;
2130 
2132  prop = msi_dialog_dup_property( dialog, control->property, indirect );
2133 
2134  buf = msi_get_window_text( control->hwnd );
2135 
2136  if ( !msi_dialog_verify_path( buf ) )
2137  {
2138  /* FIXME: display an error message box */
2139  ERR("Invalid path %s\n", debugstr_w( buf ));
2140  valid = FALSE;
2141  SetFocus( control->hwnd );
2142  }
2143  else
2144  {
2145  valid = TRUE;
2146  msi_dialog_set_property( dialog->package, prop, buf );
2147  }
2148 
2149  msi_dialog_update_pathedit( dialog, control );
2150 
2151  TRACE("edit %s contents changed, set %s\n", debugstr_w(control->name),
2152  debugstr_w(prop));
2153 
2154  msi_free( buf );
2155  msi_free( prop );
2156 
2157  return valid;
2158 }
2159 
2161 {
2162  struct msi_pathedit_info *info = GetPropW(hWnd, L"MSIDATA");
2163  LRESULT r = 0;
2164 
2165  TRACE("%p %04x %#Ix %#Ix\n", hWnd, msg, wParam, lParam);
2166 
2167  if ( msg == WM_KILLFOCUS )
2168  {
2169  /* if the path is invalid, don't handle this message */
2170  if ( !msi_dialog_onkillfocus( info->dialog, info->control ) )
2171  return 0;
2172  }
2173 
2174  r = CallWindowProcW(info->oldproc, hWnd, msg, wParam, lParam);
2175 
2176  if ( msg == WM_NCDESTROY )
2177  {
2178  msi_free( info );
2179  RemovePropW( hWnd, L"MSIDATA" );
2180  }
2181 
2182  return r;
2183 }
2184 
2186 {
2187  struct msi_pathedit_info *info;
2189  LPCWSTR prop;
2190 
2191  info = msi_alloc( sizeof *info );
2192  if (!info)
2193  return ERROR_FUNCTION_FAILED;
2194 
2195  control = msi_dialog_add_control( dialog, rec, L"Edit",
2196  WS_BORDER | WS_TABSTOP );
2198  prop = MSI_RecordGetString( rec, 9 );
2201 
2202  info->dialog = dialog;
2203  info->control = control;
2206  SetPropW( control->hwnd, L"MSIDATA", info );
2207 
2209 
2210  return ERROR_SUCCESS;
2211 }
2212 
2214 {
2215  if (HIWORD(param) != BN_CLICKED)
2216  return ERROR_SUCCESS;
2217 
2218  TRACE("clicked radio button %s, set %s\n", debugstr_w(control->name), debugstr_w(control->property));
2219 
2221 
2223 }
2224 
2225 /* radio buttons are a bit different from normal controls */
2227 {
2229  msi_dialog *dialog = group->dialog;
2231  LPCWSTR prop, text, name;
2233 
2234  name = MSI_RecordGetString( rec, 3 );
2235  text = MSI_RecordGetString( rec, 8 );
2236 
2237  control = dialog_create_window( dialog, rec, 0, L"BUTTON", name, text, style,
2238  group->parent->hwnd );
2239  if (!control)
2240  return ERROR_FUNCTION_FAILED;
2242 
2243  if (group->propval && !wcscmp( control->name, group->propval ))
2245 
2246  prop = MSI_RecordGetString( rec, 1 );
2247  if( prop )
2248  control->property = strdupW( prop );
2249 
2250  return ERROR_SUCCESS;
2251 }
2252 
2254 {
2255  EnableWindow( hWnd, lParam );
2256  return TRUE;
2257 }
2258 
2260 {
2261  WNDPROC oldproc = (WNDPROC)GetPropW( hWnd, L"MSIDATA" );
2262  LRESULT r;
2263 
2264  TRACE( "hWnd %p msg %04x wParam %#Ix lParam %#Ix\n", hWnd, msg, wParam, lParam );
2265 
2266  if (msg == WM_COMMAND) /* Forward notifications to dialog */
2268 
2270 
2271  /* make sure the radio buttons show as disabled if the parent is disabled */
2272  if (msg == WM_ENABLE)
2274 
2275  return r;
2276 }
2277 
2279 {
2280  UINT r;
2281  LPCWSTR prop;
2283  MSIQUERY *view;
2285  MSIPACKAGE *package = dialog->package;
2286  WNDPROC oldproc;
2287  DWORD attr, style = WS_GROUP;
2288 
2289  prop = MSI_RecordGetString( rec, 9 );
2290 
2291  TRACE("%p %p %s\n", dialog, rec, debugstr_w( prop ));
2292 
2293  attr = MSI_RecordGetInteger( rec, 8 );
2295  style |= WS_VISIBLE;
2297  style |= WS_DISABLED;
2299  style |= BS_GROUPBOX;
2300  else
2301  style |= BS_OWNERDRAW;
2302 
2303  /* Create parent group box to hold radio buttons */
2304  control = msi_dialog_add_control( dialog, rec, L"BUTTON", style );
2305  if( !control )
2306  return ERROR_FUNCTION_FAILED;
2307 
2308  oldproc = (WNDPROC) SetWindowLongPtrW( control->hwnd, GWLP_WNDPROC,
2310  SetPropW(control->hwnd, L"MSIDATA", oldproc);
2312 
2313  if( prop )
2314  control->property = strdupW( prop );
2315 
2316  /* query the Radio Button table for all control in this group */
2317  r = MSI_OpenQuery( package->db, &view, L"SELECT * FROM `RadioButton` WHERE `Property` = '%s'", prop );
2318  if( r != ERROR_SUCCESS )
2319  {
2320  ERR("query failed for dialog %s radio group %s\n",
2321  debugstr_w(dialog->name), debugstr_w(prop));
2322  return ERROR_INVALID_PARAMETER;
2323  }
2324 
2325  group.dialog = dialog;
2326  group.parent = control;
2327  group.propval = msi_dup_property( dialog->package->db, control->property );
2328 
2330  msiobj_release( &view->hdr );
2331  msi_free( group.propval );
2332  return r;
2333 }
2334 
2335 static void
2337 {
2338  TVITEMW tvi;
2339  DWORD index = feature->ActionRequest;
2340 
2341  TRACE("Feature %s -> %d %d %d\n", debugstr_w(feature->Title),
2342  feature->Installed, feature->Action, feature->ActionRequest);
2343 
2344  if (index == INSTALLSTATE_UNKNOWN)
2346 
2347  tvi.mask = TVIF_STATE;
2348  tvi.hItem = hItem;
2351 
2352  SendMessageW( hwnd, TVM_SETITEMW, 0, (LPARAM) &tvi );
2353 }
2354 
2355 static UINT
2357 {
2358  HMENU hMenu;
2359  INT r;
2360 
2361  /* create a menu to display */
2362  hMenu = CreatePopupMenu();
2363 
2364  /* FIXME: load strings from resources */
2365  AppendMenuA( hMenu, MF_ENABLED, INSTALLSTATE_LOCAL, "Install feature locally");
2366  AppendMenuA( hMenu, MF_ENABLED, USER_INSTALLSTATE_ALL, "Install entire feature");
2367  AppendMenuA( hMenu, MF_ENABLED, INSTALLSTATE_ADVERTISED, "Install on demand");
2368  AppendMenuA( hMenu, MF_ENABLED, INSTALLSTATE_ABSENT, "Don't install");
2370  x, y, 0, hwnd, NULL );
2371  DestroyMenu( hMenu );
2372  return r;
2373 }
2374 
2375 static void
2378 {
2379  feature->ActionRequest = state;
2382 }
2383 
2384 static void
2386  MSIPACKAGE *package, INSTALLSTATE state)
2387 {
2388  /* update all siblings */
2389  do
2390  {
2392  HTREEITEM child;
2393 
2396 
2397  /* update this sibling's children */
2399  if (child)
2401  package, state );
2402  }
2403  while ((curr = (HTREEITEM)SendMessageW( hwnd, TVM_GETNEXTITEM, (WPARAM)TVGN_NEXT, (LPARAM)curr )));
2404 }
2405 
2406 static LRESULT
2408 {
2409  struct msi_selection_tree_info *info;
2411  MSIPACKAGE *package;
2412  union {
2413  RECT rc;
2414  POINT pt[2];
2415  HTREEITEM hItem;
2416  } u;
2417  UINT r;
2418 
2419  info = GetPropW(hwnd, L"MSIDATA");
2420  package = info->dialog->package;
2421 
2423  if (!feature)
2424  {
2425  ERR("item %p feature was NULL\n", hItem);
2426  return 0;
2427  }
2428 
2429  /* get the item's rectangle to put the menu just below it */
2430  u.hItem = hItem;
2431  SendMessageW( hwnd, TVM_GETITEMRECT, 0, (LPARAM) &u.rc );
2432  MapWindowPoints( hwnd, NULL, u.pt, 2 );
2433 
2434  r = msi_seltree_popup_menu( hwnd, u.rc.left, u.rc.top );
2435 
2436  switch (r)
2437  {
2438  case USER_INSTALLSTATE_ALL:
2440  /* fall-through */
2442  case INSTALLSTATE_ABSENT:
2443  {
2444  HTREEITEM child;
2446  if (child)
2448  }
2449  /* fall-through */
2450  case INSTALLSTATE_LOCAL:
2452  break;
2453  }
2454 
2455  return 0;
2456 }
2457 
2458 static LRESULT WINAPI
2460 {
2461  struct msi_selection_tree_info *info;
2462  TVHITTESTINFO tvhti;
2463  HRESULT r;
2464 
2465  TRACE("%p %04x %#Ix %#Ix\n", hWnd, msg, wParam, lParam);
2466 
2467  info = GetPropW(hWnd, L"MSIDATA");
2468 
2469  switch( msg )
2470  {
2471  case WM_LBUTTONDOWN:
2472  tvhti.pt.x = (short)LOWORD( lParam );
2473  tvhti.pt.y = (short)HIWORD( lParam );
2474  tvhti.flags = 0;
2475  tvhti.hItem = 0;
2476  CallWindowProcW(info->oldproc, hWnd, TVM_HITTEST, 0, (LPARAM) &tvhti );
2477  if (tvhti.flags & TVHT_ONITEMSTATEICON)
2478  return msi_seltree_menu( hWnd, tvhti.hItem );
2479  break;
2480  }
2481  r = CallWindowProcW(info->oldproc, hWnd, msg, wParam, lParam);
2482 
2483  switch( msg )
2484  {
2485  case WM_NCDESTROY:
2486  msi_free( info );
2487  RemovePropW( hWnd, L"MSIDATA" );
2488  break;
2489  }
2490  return r;
2491 }
2492 
2493 static void
2495  LPCWSTR parent, HTREEITEM hParent )
2496 {
2497  struct msi_selection_tree_info *info = GetPropW( hwnd, L"MSIDATA" );
2499  TVINSERTSTRUCTW tvis;
2500  HTREEITEM hitem, hfirst = NULL;
2501 
2503  {
2504  if ( parent && feature->Feature_Parent && wcscmp( parent, feature->Feature_Parent ))
2505  continue;
2506  else if ( parent && !feature->Feature_Parent )
2507  continue;
2508  else if ( !parent && feature->Feature_Parent )
2509  continue;
2510 
2511  if ( !feature->Title )
2512  continue;
2513 
2514  if ( !feature->Display )
2515  continue;
2516 
2517  memset( &tvis, 0, sizeof tvis );
2518  tvis.hParent = hParent;
2519  tvis.hInsertAfter = TVI_LAST;
2520  tvis.u.item.mask = TVIF_TEXT | TVIF_PARAM;
2521  tvis.u.item.pszText = feature->Title;
2522  tvis.u.item.lParam = (LPARAM) feature;
2523 
2524  hitem = (HTREEITEM) SendMessageW( hwnd, TVM_INSERTITEMW, 0, (LPARAM) &tvis );
2525  if (!hitem)
2526  continue;
2527 
2528  if (!hfirst)
2529  hfirst = hitem;
2530 
2533  feature->Feature, hitem );
2534 
2535  /* the node is expanded if Display is odd */
2536  if ( feature->Display % 2 != 0 )
2538  }
2539 
2540  /* select the first item */
2542  info->selected = hfirst;
2543 }
2544 
2546 {
2547  const int bm_width = 32, bm_height = 16, bm_count = 3;
2548  const int bm_resource = 0x1001;
2549  HIMAGELIST himl;
2550  int i;
2551  HBITMAP hbmp;
2552 
2553  himl = ImageList_Create( bm_width, bm_height, FALSE, 4, 0 );
2554  if (!himl)
2555  {
2556  ERR("failed to create image list\n");
2557  return;
2558  }
2559 
2560  for (i=0; i<bm_count; i++)
2561  {
2562  hbmp = LoadBitmapW( msi_hInstance, MAKEINTRESOURCEW(i+bm_resource) );
2563  if (!hbmp)
2564  {
2565  ERR("failed to load bitmap %d\n", i);
2566  break;
2567  }
2568 
2569  /*
2570  * Add a dummy bitmap at offset zero because the treeview
2571  * can't use it as a state mask (zero means no user state).
2572  */
2573  if (!i)
2574  ImageList_Add( himl, hbmp, NULL );
2575 
2576  ImageList_Add( himl, hbmp, NULL );
2577  }
2578 
2580 }
2581 
2583  msi_control *control, WPARAM param )
2584 {
2585  struct msi_selection_tree_info *info = GetPropW( control->hwnd, L"MSIDATA" );
2587  MSIRECORD *row, *rec;
2588  MSIFOLDER *folder;
2590  LPCWSTR dir, title = NULL;
2591  UINT r = ERROR_SUCCESS;
2592 
2593  if (tv->hdr.code != TVN_SELCHANGINGW)
2594  return ERROR_SUCCESS;
2595 
2596  info->selected = tv->itemNew.hItem;
2597 
2598  if (!(tv->itemNew.mask & TVIF_TEXT))
2599  {
2601  if (feature)
2602  title = feature->Title;
2603  }
2604  else
2605  title = tv->itemNew.pszText;
2606 
2607  row = MSI_QueryGetRecord( dialog->package->db, L"SELECT * FROM `Feature` WHERE `Title` = '%s'", title );
2608  if (!row)
2609  return ERROR_FUNCTION_FAILED;
2610 
2611  rec = MSI_CreateRecord( 1 );
2612 
2613  MSI_RecordSetStringW( rec, 1, MSI_RecordGetString( row, 4 ) );
2614  msi_event_fire( dialog->package, L"SelectionDescription", rec );
2615 
2616  dir = MSI_RecordGetString( row, 7 );
2617  if (dir)
2618  {
2619  folder = msi_get_loaded_folder( dialog->package, dir );
2620  if (!folder)
2621  {
2623  goto done;
2624  }
2625  MSI_RecordSetStringW( rec, 1, folder->ResolvedTarget );
2626  }
2627  else
2628  MSI_RecordSetStringW( rec, 1, NULL );
2629 
2630  msi_event_fire( dialog->package, L"SelectionPath", rec );
2631 
2632 done:
2633  msiobj_release(&row->hdr);
2634  msiobj_release(&rec->hdr);
2635 
2636  return r;
2637 }
2638 
2640 {
2641  msi_control *control;
2642  LPCWSTR prop, control_name;
2643  MSIPACKAGE *package = dialog->package;
2644  DWORD style;
2645  struct msi_selection_tree_info *info;
2646 
2647  info = msi_alloc( sizeof *info );
2648  if (!info)
2649  return ERROR_FUNCTION_FAILED;
2650 
2651  /* create the treeview control */
2654  control = msi_dialog_add_control( dialog, rec, WC_TREEVIEWW, style );
2655  if (!control)
2656  {
2657  msi_free(info);
2658  return ERROR_FUNCTION_FAILED;
2659  }
2660 
2662  control_name = MSI_RecordGetString( rec, 2 );
2663  control->attributes = MSI_RecordGetInteger( rec, 8 );
2664  prop = MSI_RecordGetString( rec, 9 );
2665  control->property = msi_dialog_dup_property( dialog, prop, FALSE );
2666 
2667  /* subclass */
2668  info->dialog = dialog;
2669  info->hwnd = control->hwnd;
2670  info->oldproc = (WNDPROC) SetWindowLongPtrW( control->hwnd, GWLP_WNDPROC,
2672  SetPropW( control->hwnd, L"MSIDATA", info );
2673 
2674  event_subscribe( dialog, L"SelectionPath", control_name, L"Property" );
2675 
2676  /* initialize it */
2677  msi_seltree_create_imagelist( control->hwnd );
2678  msi_seltree_add_child_features( package, control->hwnd, NULL, NULL );
2679 
2680  return ERROR_SUCCESS;
2681 }
2682 
2683 /******************** Group Box ***************************************/
2684 
2686 {
2687  msi_control *control;
2688  DWORD style;
2689 
2691  control = msi_dialog_add_control( dialog, rec, WC_BUTTONW, style );
2692  if (!control)
2693  return ERROR_FUNCTION_FAILED;
2694 
2695  return ERROR_SUCCESS;
2696 }
2697 
2698 /******************** List Box ***************************************/
2699 
2701 {
2708 };
2709 
2711 {
2712  struct msi_listbox_info *info;
2713  LRESULT r;
2714  DWORD j;
2715 
2716  TRACE("%p %04x %#Ix %#Ix\n", hWnd, msg, wParam, lParam);
2717 
2718  info = GetPropW( hWnd, L"MSIDATA" );
2719  if (!info)
2720  return 0;
2721 
2722  r = CallWindowProcW( info->oldproc, hWnd, msg, wParam, lParam );
2723 
2724  switch( msg )
2725  {
2726  case WM_NCDESTROY:
2727  for (j = 0; j < info->num_items; j++)
2728  msi_free( info->items[j] );
2729  msi_free( info->items );
2730  msi_free( info );
2731  RemovePropW( hWnd, L"MSIDATA" );
2732  break;
2733  }
2734 
2735  return r;
2736 }
2737 
2739 {
2740  struct msi_listbox_info *info = param;
2741  LPCWSTR value, text;
2742  int pos;
2743 
2744  value = MSI_RecordGetString( rec, 3 );
2745  text = MSI_RecordGetString( rec, 4 );
2746 
2747  info->items[info->addpos_items] = strdupW( value );
2748 
2749  pos = SendMessageW( info->hwnd, LB_ADDSTRING, 0, (LPARAM)text );
2750  SendMessageW( info->hwnd, LB_SETITEMDATA, pos, (LPARAM)info->items[info->addpos_items] );
2751  info->addpos_items++;
2752  return ERROR_SUCCESS;
2753 }
2754 
2756 {
2757  MSIQUERY *view;
2758  DWORD count;
2759  UINT r;
2760 
2761  r = MSI_OpenQuery( info->dialog->package->db, &view,
2762  L"SELECT * FROM `ListBox` WHERE `Property` = '%s' ORDER BY `Order`", property );
2763  if ( r != ERROR_SUCCESS )
2764  return r;
2765 
2766  /* just get the number of records */
2767  count = 0;
2769  if (r != ERROR_SUCCESS)
2770  {
2771  msiobj_release( &view->hdr );
2772  return r;
2773  }
2774  info->num_items = count;
2775  info->items = msi_alloc( sizeof(*info->items) * count );
2776 
2778  msiobj_release( &view->hdr );
2779  return r;
2780 }
2781 
2783  msi_control *control, WPARAM param )
2784 {
2785  struct msi_listbox_info *info;
2786  int index;
2787  LPCWSTR value;
2788 
2789  if( HIWORD(param) != LBN_SELCHANGE )
2790  return ERROR_SUCCESS;
2791 
2792  info = GetPropW( control->hwnd, L"MSIDATA" );
2793  index = SendMessageW( control->hwnd, LB_GETCURSEL, 0, 0 );
2794  value = (LPCWSTR) SendMessageW( control->hwnd, LB_GETITEMDATA, index, 0 );
2795 
2796  msi_dialog_set_property( info->dialog->package, control->property, value );
2798 
2799  return ERROR_SUCCESS;
2800 }
2801 
2803 {
2804  struct msi_listbox_info *info;
2805  msi_control *control;
2806  DWORD attributes, style;
2807  LPCWSTR prop;
2808 
2809  info = msi_alloc( sizeof *info );
2810  if (!info)
2811  return ERROR_FUNCTION_FAILED;
2812 
2814  attributes = MSI_RecordGetInteger( rec, 8 );
2815  if (~attributes & msidbControlAttributesSorted)
2816  style |= LBS_SORT;
2817 
2818  control = msi_dialog_add_control( dialog, rec, WC_LISTBOXW, style );
2819  if (!control)
2820  {
2821  msi_free(info);
2822  return ERROR_FUNCTION_FAILED;
2823  }
2824 
2826 
2827  prop = MSI_RecordGetString( rec, 9 );
2828  control->property = msi_dialog_dup_property( dialog, prop, FALSE );
2829 
2830  /* subclass */
2831  info->dialog = dialog;
2832  info->hwnd = control->hwnd;
2833  info->items = NULL;
2834  info->addpos_items = 0;
2835  info->oldproc = (WNDPROC)SetWindowLongPtrW( control->hwnd, GWLP_WNDPROC,
2837  SetPropW( control->hwnd, L"MSIDATA", info );
2838 
2839  if ( control->property )
2840  msi_listbox_add_items( info, control->property );
2841 
2842  return ERROR_SUCCESS;
2843 }
2844 
2845 /******************** Directory Combo ***************************************/
2846 
2848 {
2849  WCHAR *path;
2850 
2851  if (!control && !(control = msi_dialog_find_control_by_type( dialog, L"DirectoryCombo" )))
2852  return;
2853 
2854  if (!(path = get_path_property( dialog, control ))) return;
2855  PathStripPathW( path );
2857 
2858  SendMessageW( control->hwnd, CB_INSERTSTRING, 0, (LPARAM)path );
2859  SendMessageW( control->hwnd, CB_SETCURSEL, 0, 0 );
2860 
2861  msi_free( path );
2862 }
2863 
2865 {
2866  msi_control *control;
2867  LPCWSTR prop;
2868  DWORD style;
2869 
2870  /* FIXME: use CBS_OWNERDRAWFIXED and add owner draw code */
2873  control = msi_dialog_add_control( dialog, rec, WC_COMBOBOXW, style );
2874  if (!control)
2875  return ERROR_FUNCTION_FAILED;
2876 
2877  control->attributes = MSI_RecordGetInteger( rec, 8 );
2878  prop = MSI_RecordGetString( rec, 9 );
2879  control->property = msi_dialog_dup_property( dialog, prop, FALSE );
2880 
2882 
2883  return ERROR_SUCCESS;
2884 }
2885 
2886 /******************** Directory List ***************************************/
2887 
2889 {
2890  WCHAR dir_spec[MAX_PATH], *path;
2891  WIN32_FIND_DATAW wfd;
2892  LVITEMW item;
2893  HANDLE file;
2894 
2895  if (!control && !(control = msi_dialog_find_control_by_type( dialog, L"DirectoryList" )))
2896  return;
2897 
2898  /* clear the list-view */
2899  SendMessageW( control->hwnd, LVM_DELETEALLITEMS, 0, 0 );
2900 
2901  if (!(path = get_path_property( dialog, control ))) return;
2902  lstrcpyW( dir_spec, path );
2903  lstrcatW( dir_spec, L"*" );
2904 
2905  file = FindFirstFileW( dir_spec, &wfd );
2906  if (file == INVALID_HANDLE_VALUE)
2907  {
2908  msi_free( path );
2909  return;
2910  }
2911 
2912  do
2913  {
2914  if ( wfd.dwFileAttributes != FILE_ATTRIBUTE_DIRECTORY )
2915  continue;
2916 
2917  if ( !wcscmp( wfd.cFileName, L"." ) || !wcscmp( wfd.cFileName, L".." ) )
2918  continue;
2919 
2920  item.mask = LVIF_TEXT;
2921  item.cchTextMax = MAX_PATH;
2922  item.iItem = 0;
2923  item.iSubItem = 0;
2924  item.pszText = wfd.cFileName;
2925 
2926  SendMessageW( control->hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item );
2927  } while ( FindNextFileW( file, &wfd ) );
2928 
2929  msi_free( path );
2930  FindClose( file );
2931 }
2932 
2934 {
2935  msi_control *control;
2936  LPWSTR prop, path, ptr;
2937  BOOL indirect;
2938 
2939  control = msi_dialog_find_control_by_type( dialog, L"DirectoryList" );
2941  prop = msi_dialog_dup_property( dialog, control->property, indirect );
2943 
2944  /* strip off the last directory */
2945  ptr = PathFindFileNameW( path );
2946  if (ptr != path) *(ptr - 1) = '\0';
2948 
2949  msi_dialog_set_property( dialog->package, prop, path );
2950 
2954 
2955  msi_free( path );
2956  msi_free( prop );
2957 
2958  return ERROR_SUCCESS;
2959 }
2960 
2962 {
2963  WCHAR newfolder[MAX_PATH], *path, *ptr;
2964  int len, count = 2;
2965 
2966  len = LoadStringW( msi_hInstance, IDS_NEWFOLDER, newfolder, ARRAY_SIZE(newfolder) );
2967  len += lstrlenW(root) + 1;
2968  if (!(path = msi_alloc( (len + 4) * sizeof(WCHAR) ))) return NULL;
2969  lstrcpyW( path, root );
2970  lstrcatW( path, newfolder );
2971 
2972  for (;;)
2973  {
2975  if (count > 99)
2976  {
2977  msi_free( path );
2978  return NULL;
2979  }
2980  swprintf( path, len + 4, L"%s%s %u", root, newfolder, count++ );
2981  }
2982 
2983  ptr = wcsrchr( path, '\\' ) + 1;
2984  *ret_len = lstrlenW(ptr);
2985  memmove( path, ptr, *ret_len * sizeof(WCHAR) );
2986  return path;
2987 }
2988 
2990 {
2991  msi_control *control;
2992  WCHAR *path;
2993  LVITEMW item;
2994  int index;
2995 
2996  control = msi_dialog_find_control_by_type( dialog, L"DirectoryList" );
2997 
2998  if (!(path = get_path_property( dialog, control ))) return ERROR_OUTOFMEMORY;
2999 
3000  item.mask = LVIF_TEXT;
3001  item.iItem = 0;
3002  item.iSubItem = 0;
3003  item.pszText = get_unique_folder_name( path, &item.cchTextMax );
3004 
3005  index = SendMessageW( control->hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item );
3006  SendMessageW( control->hwnd, LVM_ENSUREVISIBLE, index, 0 );
3007  SendMessageW( control->hwnd, LVM_EDITLABELW, index, -1 );
3008 
3009  msi_free( path );
3010  msi_free( item.pszText );
3011  return ERROR_SUCCESS;
3012 }
3013 
3015 {
3016  NMHDR *nmhdr = (NMHDR *)param;
3017  WCHAR text[MAX_PATH], *new_path, *path, *prop;
3018  BOOL indirect;
3019 
3020  switch (nmhdr->code)
3021  {
3022  case LVN_ENDLABELEDITW:
3023  {
3025  if (!info->item.pszText) return ERROR_SUCCESS;
3026  lstrcpynW( text, info->item.pszText, ARRAY_SIZE(text) );
3027  text[ARRAY_SIZE(text) - 1] = 0;
3028  break;
3029  }
3030  case LVN_ITEMACTIVATE:
3031  {
3032  LVITEMW item;
3033  int index = SendMessageW( control->hwnd, LVM_GETNEXTITEM, -1, LVNI_SELECTED );
3034  if (index < 0)
3035  {
3036  ERR("no list-view item selected\n");
3037  return ERROR_FUNCTION_FAILED;
3038  }
3039 
3040  item.iSubItem = 0;
3041  item.pszText = text;
3042  item.cchTextMax = MAX_PATH;
3044  text[ARRAY_SIZE(text) - 1] = 0;
3045  break;
3046  }
3047  default:
3048  return ERROR_SUCCESS;
3049  }
3050 
3052  prop = msi_dialog_dup_property( dialog, control->property, indirect );
3054 
3055  if (!(new_path = msi_alloc( (lstrlenW(path) + lstrlenW(text) + 2) * sizeof(WCHAR) )))
3056  {
3057  msi_free( prop );
3058  msi_free( path );
3059  return ERROR_OUTOFMEMORY;
3060  }
3061  lstrcpyW( new_path, path );
3062  lstrcatW( new_path, text );
3063  if (nmhdr->code == LVN_ENDLABELEDITW) CreateDirectoryW( new_path, NULL );
3064  lstrcatW( new_path, L"\\" );
3065 
3066  msi_dialog_set_property( dialog->package, prop, new_path );
3067 
3071 
3072  msi_free( prop );
3073  msi_free( path );
3074  msi_free( new_path );
3075 
3076  return ERROR_SUCCESS;
3077 }
3078 
3080 {
3081  msi_control *control;
3082  LPCWSTR prop;
3083  DWORD style;
3084 
3088  control = msi_dialog_add_control( dialog, rec, WC_LISTVIEWW, style );
3089  if (!control)
3090  return ERROR_FUNCTION_FAILED;
3091 
3092  control->attributes = MSI_RecordGetInteger( rec, 8 );
3094  prop = MSI_RecordGetString( rec, 9 );
3095  control->property = msi_dialog_dup_property( dialog, prop, FALSE );
3096 
3097  /* double click to activate an item in the list */
3100 
3102 
3103  return ERROR_SUCCESS;
3104 }
3105 
3106 /******************** VolumeCost List ***************************************/
3107 
3109 {
3110  int i;
3111 
3112  for (i = 0; i < lstrlenW( str ); i++)
3113  if (!iswdigit(str[i]))
3114  return FALSE;
3115 
3116  return TRUE;
3117 }
3118 
3119 static const WCHAR column_keys[][80] =
3120 {
3121  L"VolumeCostVolume",
3122  L"VolumeCostSize",
3123  L"VolumeCostAvailable",
3124  L"VolumeCostRequired",
3125  L"VolumeCostDifference",
3126 };
3127 
3129 {
3130  LPCWSTR text = MSI_RecordGetString( rec, 10 );
3131  LPCWSTR begin = text, end;
3132  WCHAR *num;
3133  LVCOLUMNW lvc;
3134  DWORD count = 0;
3135 
3136  if (!text) return;
3137 
3138  while ((begin = wcschr( begin, '{' )) && count < 5)
3139  {
3140  if (!(end = wcschr( begin, '}' )))
3141  return;
3142 
3143  num = msi_alloc( (end-begin+1)*sizeof(WCHAR) );
3144  if (!num)
3145  return;
3146 
3147  lstrcpynW( num, begin + 1, end - begin );
3148  begin += end - begin + 1;
3149 
3150  /* empty braces or '0' hides the column */
3151  if ( !num[0] || !wcscmp( num, L"0" ) )
3152  {
3153  count++;
3154  msi_free( num );
3155  continue;
3156  }
3157 
3158  /* the width must be a positive number
3159  * if a width is invalid, all remaining columns are hidden
3160  */
3161  if ( !wcsncmp( num, L"-", 1 ) || !str_is_number( num ) ) {
3162  msi_free( num );
3163  return;
3164  }
3165 
3166  ZeroMemory( &lvc, sizeof(lvc) );
3168  lvc.cx = wcstol( num, NULL, 10 );
3170 
3171  SendMessageW( control->hwnd, LVM_INSERTCOLUMNW, count++, (LPARAM)&lvc );
3172  msi_free( lvc.pszText );
3173  msi_free( num );
3174  }
3175 }
3176 
3178 {
3180  INT each_cost;
3181  LONGLONG total_cost = 0;
3182 
3183  LIST_FOR_EACH_ENTRY( feature, &dialog->package->features, MSIFEATURE, entry )
3184  {
3185  if (ERROR_SUCCESS == (MSI_GetFeatureCost(dialog->package, feature,
3187  {
3188  /* each_cost is in 512-byte units */
3189  total_cost += ((LONGLONG)each_cost) * 512;
3190  }
3191  if (ERROR_SUCCESS == (MSI_GetFeatureCost(dialog->package, feature,
3193  {
3194  /* each_cost is in 512-byte units */
3195  total_cost -= ((LONGLONG)each_cost) * 512;
3196  }
3197  }
3198  return total_cost;
3199 }
3200 
3202 {
3204  LONGLONG difference, cost;
3205  WCHAR size_text[MAX_PATH];
3206  WCHAR cost_text[MAX_PATH];
3207  LPWSTR drives, ptr;
3208  LVITEMW lvitem;
3209  DWORD size, flags;
3210  int i = 0;
3211 
3212  cost = msi_vcl_get_cost(dialog);
3213  StrFormatByteSizeW(cost, cost_text, MAX_PATH);
3214 
3216  if ( !size ) return;
3217 
3218  drives = msi_alloc( (size + 1) * sizeof(WCHAR) );
3219  if ( !drives ) return;
3220 
3221  GetLogicalDriveStringsW( size, drives );
3222 
3223  ptr = drives;
3224  while (*ptr)
3225  {
3226  if (GetVolumeInformationW(ptr, NULL, 0, NULL, 0, &flags, NULL, 0) &&
3228  {
3229  ptr += lstrlenW(ptr) + 1;
3230  continue;
3231  }
3232 
3233  lvitem.mask = LVIF_TEXT;
3234  lvitem.iItem = i;
3235  lvitem.iSubItem = 0;
3236  lvitem.pszText = ptr;
3237  lvitem.cchTextMax = lstrlenW(ptr) + 1;
3238  SendMessageW( control->hwnd, LVM_INSERTITEMW, 0, (LPARAM)&lvitem );
3239 
3241  difference = free.QuadPart - cost;
3242 
3243  StrFormatByteSizeW(total.QuadPart, size_text, MAX_PATH);
3244  lvitem.iSubItem = 1;
3245  lvitem.pszText = size_text;
3246  lvitem.cchTextMax = lstrlenW(size_text) + 1;
3247  SendMessageW( control->hwnd, LVM_SETITEMW, 0, (LPARAM)&lvitem );
3248 
3249  StrFormatByteSizeW(free.QuadPart, size_text, MAX_PATH);
3250  lvitem.iSubItem = 2;
3251  lvitem.pszText = size_text;
3252  lvitem.cchTextMax = lstrlenW(size_text) + 1;
3253  SendMessageW( control->hwnd, LVM_SETITEMW, 0, (LPARAM)&lvitem );
3254 
3255  lvitem.iSubItem = 3;
3256  lvitem.pszText = cost_text;
3257  lvitem.cchTextMax = lstrlenW(cost_text) + 1;
3258  SendMessageW( control->hwnd, LVM_SETITEMW, 0, (LPARAM)&lvitem );
3259 
3260  StrFormatByteSizeW(difference, size_text, MAX_PATH);
3261  lvitem.iSubItem = 4;
3262  lvitem.pszText = size_text;
3263  lvitem.cchTextMax = lstrlenW(size_text) + 1;
3264  SendMessageW( control->hwnd, LVM_SETITEMW, 0, (LPARAM)&lvitem );
3265 
3266  ptr += lstrlenW(ptr) + 1;
3267  i++;
3268  }
3269 
3270  msi_free( drives );
3271 }
3272 
3274 {
3275  msi_control *control;
3276  DWORD style;
3277 
3281  control = msi_dialog_add_control( dialog, rec, WC_LISTVIEWW, style );
3282  if (!control)
3283  return ERROR_FUNCTION_FAILED;
3284 
3285  msi_dialog_vcl_add_columns( dialog, control, rec );
3286  msi_dialog_vcl_add_drives( dialog, control );
3287 
3288  return ERROR_SUCCESS;
3289 }
3290 
3291 /******************** VolumeSelect Combo ***************************************/
3292 
3294  msi_control *control, WPARAM param )
3295 {
3296  WCHAR text[MAX_PATH];
3297  LPWSTR prop;
3298  BOOL indirect;
3299  int index;
3300 
3301  if (HIWORD(param) != CBN_SELCHANGE)
3302  return ERROR_SUCCESS;
3303 
3304  index = SendMessageW( control->hwnd, CB_GETCURSEL, 0, 0 );
3305  if ( index == CB_ERR )
3306  {
3307  ERR("No ComboBox item selected!\n");
3308  return ERROR_FUNCTION_FAILED;
3309  }
3310 
3311  SendMessageW( control->hwnd, CB_GETLBTEXT, index, (LPARAM)text );
3312 
3314  prop = msi_dialog_dup_property( dialog, control->property, indirect );
3315 
3316  msi_dialog_set_property( dialog->package, prop, text );
3317 
3318  msi_free( prop );
3319  return ERROR_SUCCESS;
3320 }
3321 
3323 {
3324  LPWSTR drives, ptr;
3325  DWORD size;
3326 
3328  if ( !size ) return;
3329 
3330  drives = msi_alloc( (size + 1) * sizeof(WCHAR) );
3331  if ( !drives ) return;
3332 
3333  GetLogicalDriveStringsW( size, drives );
3334 
3335  ptr = drives;
3336  while (*ptr)
3337  {
3338  SendMessageW( control->hwnd, CB_ADDSTRING, 0, (LPARAM)ptr );
3339  ptr += lstrlenW(ptr) + 1;
3340  }
3341 
3342  msi_free( drives );
3343 }
3344 
3346 {
3347  msi_control *control;
3348  LPCWSTR prop;
3349  DWORD style;
3350 
3351  /* FIXME: CBS_OWNERDRAWFIXED */
3355  control = msi_dialog_add_control( dialog, rec, WC_COMBOBOXW, style );
3356  if (!control)
3357  return ERROR_FUNCTION_FAILED;
3358 
3359  control->attributes = MSI_RecordGetInteger( rec, 8 );
3361  prop = MSI_RecordGetString( rec, 9 );
3362  control->property = msi_dialog_dup_property( dialog, prop, FALSE );
3363 
3364  msi_dialog_vsc_add_drives( dialog, control );
3365 
3366  return ERROR_SUCCESS;
3367 }
3368 
3370 {
3371  int len, len_href = ARRAY_SIZE( L"href" ) - 1;
3372  const WCHAR *p, *q;
3373  WCHAR quote = 0;
3374  LITEM item;
3375 
3376  item.mask = LIF_ITEMINDEX | LIF_URL;
3377  item.iLink = 0;
3378  item.szUrl[0] = 0;
3379 
3380  SendMessageW( control->hwnd, LM_GETITEM, 0, (LPARAM)&item );
3381 
3382  p = item.szUrl;
3383  while (*p && *p != '<') p++;
3384  if (!*p++) return ERROR_SUCCESS;
3385  if (towupper( *p++ ) != 'A' || !iswspace( *p++ )) return ERROR_SUCCESS;
3386  while (*p && iswspace( *p )) p++;
3387 
3388  len = lstrlenW( p );
3389  if (len > len_href && !wcsnicmp( p, L"href", len_href ))
3390  {
3391  p += len_href;
3392  while (*p && iswspace( *p )) p++;
3393  if (!*p || *p++ != '=') return ERROR_SUCCESS;
3394  while (*p && iswspace( *p )) p++;
3395 
3396  if (*p == '\"' || *p == '\'') quote = *p++;
3397  q = p;
3398  if (quote)
3399  {
3400  while (*q && *q != quote) q++;
3401  if (*q != quote) return ERROR_SUCCESS;
3402  }
3403  else
3404  {
3405  while (*q && *q != '>' && !iswspace( *q )) q++;
3406  if (!*q) return ERROR_SUCCESS;
3407  }
3408  item.szUrl[q - item.szUrl] = 0;
3409  ShellExecuteW( NULL, L"open", p, NULL, NULL, SW_SHOWNORMAL );
3410  }
3411  return ERROR_SUCCESS;
3412 }
3413 
3415 {
3416  msi_control *control;
3418  const WCHAR *text = MSI_RecordGetString( rec, 10 );
3419  int len = lstrlenW( text );
3420  LITEM item;
3421 
3422  control = msi_dialog_add_control( dialog, rec, WC_LINK, style );
3423  if (!control)
3424  return ERROR_FUNCTION_FAILED;
3425 
3426  control->attributes = MSI_RecordGetInteger( rec, 8 );
3428 
3429  item.mask = LIF_ITEMINDEX | LIF_STATE | LIF_URL;
3430  item.iLink = 0;
3431  item.state = LIS_ENABLED;
3432  item.stateMask = LIS_ENABLED;
3433  if (len < L_MAX_URL_LENGTH) lstrcpyW( item.szUrl, text );
3434  else item.szUrl[0] = 0;
3435 
3436  SendMessageW( control->hwnd, LM_SETITEM, 0, (LPARAM)&item );
3437 
3438  return ERROR_SUCCESS;
3439 }
3440 
3441 /******************** ListView *****************************************/
3442 
3444 {
3447 };
3448 
3450 {
3451  NMHDR *nmhdr = (NMHDR *)param;
3452 
3453  FIXME("code %#x (%d)\n", nmhdr->code, nmhdr->code);
3454 
3455  return ERROR_SUCCESS;
3456 }
3457 
3459 {
3460  struct listview_param *lv_param = (struct listview_param *)param;
3461  LPCWSTR text, binary;
3462  LVITEMW item;
3463  HICON hIcon;
3464 
3465  text = MSI_RecordGetString( rec, 4 );
3466  binary = MSI_RecordGetString( rec, 5 );
3467  hIcon = msi_load_icon( lv_param->dialog->package->db, binary, 0 );
3468 
3469  TRACE("Adding: text %s, binary %s, icon %p\n", debugstr_w(text), debugstr_w(binary), hIcon);
3470 
3471  memset( &item, 0, sizeof(item) );
3472  item.mask = LVIF_TEXT | LVIF_IMAGE;
3473  deformat_string( lv_param->dialog->package, text, &item.pszText );
3474  item.iImage = ImageList_AddIcon( lv_param->control->hImageList, hIcon );
3475  item.iItem = item.iImage;
3476  SendMessageW( lv_param->control->hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item );
3477 
3478  DestroyIcon( hIcon );
3479 
3480  return ERROR_SUCCESS;
3481 }
3482 
3484 {
3485  MSIQUERY *view;
3486  struct listview_param lv_param = { dialog, control };
3487 
3488  if (MSI_OpenQuery( dialog->package->db, &view, L"SELECT * FROM `ListView` WHERE `Property` = '%s' ORDER BY `Order`",
3490  {
3492  msiobj_release( &view->hdr );
3493  }
3494 
3495  return ERROR_SUCCESS;
3496 }
3497 
3499 {
3501  LPCWSTR prop;
3502  DWORD style, attributes;
3503  LVCOLUMNW col;
3504  RECT rc;
3505 
3508  attributes = MSI_RecordGetInteger( rec, 8 );
3509  if ( ~attributes & msidbControlAttributesSorted )
3512  if (!control)
3513  return ERROR_FUNCTION_FAILED;
3514 
3515  prop = MSI_RecordGetString( rec, 9 );
3517 
3518  control->hImageList = ImageList_Create( 16, 16, ILC_COLOR32, 0, 1);
3520 
3521  col.mask = LVCF_FMT | LVCF_WIDTH;
3522  col.fmt = LVCFMT_LEFT;
3523  col.cx = 16;
3525 
3526  GetClientRect( control->hwnd, &rc );
3527  col.cx = rc.right - 16;
3529 
3530  if (control->property)
3532 
3534 
3535  return ERROR_SUCCESS;
3536 }
3537 
3538 static const struct control_handler msi_dialog_handler[] =
3539 {
3540  { L"Text", msi_dialog_text_control },
3541  { L"PushButton", msi_dialog_button_control },
3542  { L"Line", msi_dialog_line_control },
3543  { L"Bitmap", msi_dialog_bitmap_control },
3544  { L"CheckBox", msi_dialog_checkbox_control },
3545  { L"ScrollableText", msi_dialog_scrolltext_control },
3546  { L"ComboBox", msi_dialog_combo_control },
3547  { L"Edit", msi_dialog_edit_control },
3548  { L"MaskedEdit", msi_dialog_maskedit_control },
3549  { L"PathEdit", msi_dialog_pathedit_control },
3550  { L"ProgressBar", msi_dialog_progress_bar },
3551  { L"RadioButtonGroup", msi_dialog_radiogroup_control },
3552  { L"Icon", msi_dialog_icon_control },
3553  { L"SelectionTree", msi_dialog_selection_tree },
3554  { L"GroupBox", msi_dialog_group_box },
3555  { L"ListBox", msi_dialog_list_box },
3556  { L"DirectoryCombo", msi_dialog_directory_combo },
3557  { L"DirectoryList", msi_dialog_directory_list },
3558  { L"VolumeCostList", msi_dialog_volumecost_list },
3559  { L"VolumeSelectCombo", msi_dialog_volumeselect_combo },
3560  { L"HyperLink", msi_dialog_hyperlink },
3561  { L"ListView", msi_dialog_listview }
3562 };
3563 
3565 {
3566  msi_dialog *dialog = param;
3568  UINT i;
3569 
3570  /* find and call the function that can create this type of control */
3571  control_type = MSI_RecordGetString( rec, 3 );
3572  for( i = 0; i < ARRAY_SIZE( msi_dialog_handler ); i++ )
3574  break;
3575  if( i != ARRAY_SIZE( msi_dialog_handler ))
3576  msi_dialog_handler[i].func( dialog, rec );
3577  else
3578  ERR("no handler for element type %s\n", debugstr_w(control_type));
3579 
3580  return ERROR_SUCCESS;
3581 }
3582 
3584 {
3585  UINT r;
3586  MSIQUERY *view;
3587  MSIPACKAGE *package = dialog->package;
3588 
3589  TRACE("%p %s\n", dialog, debugstr_w(dialog->name) );
3590 
3591  /* query the Control table for all the elements of the control */
3592  r = MSI_OpenQuery( package->db, &view, L"SELECT * FROM `Control` WHERE `Dialog_` = '%s'", dialog->name );
3593  if( r != ERROR_SUCCESS )
3594  {
3595  ERR("query failed for dialog %s\n", debugstr_w(dialog->name));
3596  return ERROR_INVALID_PARAMETER;
3597  }
3598 
3600  msiobj_release( &view->hdr );
3601  return r;
3602 }
3603 
3605 {
3606  /* FIXME: should restore the original values of any properties we changed */
3608 }
3609 
3610 /* figure out the height of 10 point MS Sans Serif */
3612 {
3613  LOGFONTW lf;
3614  TEXTMETRICW tm;
3615  BOOL r;
3616  LONG height = 0;
3617  HFONT hFont, hOldFont;
3618  HDC hdc;
3619 
3620  hdc = GetDC( hwnd );
3621  if (hdc)
3622  {
3623  memset( &lf, 0, sizeof lf );
3624  lf.lfHeight = MulDiv(12, GetDeviceCaps(hdc, LOGPIXELSY), 72);
3625  lstrcpyW( lf.lfFaceName, L"MS Sans Serif" );
3626  hFont = CreateFontIndirectW(&lf);
3627  if (hFont)
3628  {
3629  hOldFont = SelectObject( hdc, hFont );
3630  r = GetTextMetricsW( hdc, &tm );
3631  if (r)
3632  height = tm.tmHeight;
3633  SelectObject( hdc, hOldFont );
3634  DeleteObject( hFont );
3635  }
3636  ReleaseDC( hwnd, hdc );
3637  }
3638  return height;
3639 }
3640 
3641 /* fetch the associated record from the Dialog table */
3643 {
3644  MSIPACKAGE *package = dialog->package;
3645  MSIRECORD *rec = NULL;
3646 
3647  TRACE("%p %s\n", dialog, debugstr_w(dialog->name) );
3648 
3649  rec = MSI_QueryGetRecord( package->db, L"SELECT * FROM `Dialog` WHERE `Dialog` = '%s'", dialog->name );
3650  if( !rec )
3651  WARN("query failed for dialog %s\n", debugstr_w(dialog->name));
3652 
3653  return rec;
3654 }
3655 
3657 {
3658  UINT xres, yres;
3659  POINT center;
3660  SIZE sz;
3661  LONG style;
3662 
3663  center.x = MSI_RecordGetInteger( rec, 2 );
3664  center.y = MSI_RecordGetInteger( rec, 3 );
3665 
3666  sz.cx = MSI_RecordGetInteger( rec, 4 );
3667  sz.cy = MSI_RecordGetInteger( rec, 5 );
3668 
3669  sz.cx = msi_dialog_scale_unit( dialog, sz.cx );
3670  sz.cy = msi_dialog_scale_unit( dialog, sz.cy );
3671 
3672  xres = msi_get_property_int( dialog->package->db, L"ScreenX", 0 );
3673  yres = msi_get_property_int( dialog->package->db, L"ScreenY", 0 );
3674 
3675  center.x = MulDiv( center.x, xres, 100 );
3676  center.y = MulDiv( center.y, yres, 100 );
3677 
3678  /* turn the client pos into the window rectangle */
3679  if (dialog->package->center_x && dialog->package->center_y)
3680  {
3681  pos->left = dialog->package->center_x - sz.cx / 2.0;
3682  pos->right = pos->left + sz.cx;
3683  pos->top = dialog->package->center_y - sz.cy / 2.0;
3684  pos->bottom = pos->top + sz.cy;
3685  }
3686  else
3687  {
3688  pos->left = center.x - sz.cx/2;
3689  pos->right = pos->left + sz.cx;
3690  pos->top = center.y - sz.cy/2;
3691  pos->bottom = pos->top + sz.cy;
3692 
3693  /* save the center */
3694  dialog->package->center_x = center.x;
3695  dialog->package->center_y = center.y;
3696  }
3697 
3698  dialog->size.cx = sz.cx;
3699  dialog->size.cy = sz.cy;
3700 
3701  TRACE("%s\n", wine_dbgstr_rect(pos));
3702 
3705 }
3706 
3708 {
3709  struct list tab_chain;
3710  msi_control *control;
3711  HWND prev = HWND_TOP;
3712 
3713  list_init( &tab_chain );
3714  if (!(control = msi_dialog_find_control( dialog, first ))) return;
3715 
3716  dialog->hWndFocus = control->hwnd;
3717  while (control)
3718  {
3719  list_remove( &control->entry );
3720  list_add_tail( &tab_chain, &control->entry );
3721  if (!control->tabnext) break;
3722  control = msi_dialog_find_control( dialog, control->tabnext );
3723  }
3724 
3725  LIST_FOR_EACH_ENTRY( control, &tab_chain, msi_control, entry )
3726  {
3727  SetWindowPos( control->hwnd, prev, 0, 0, 0, 0,
3730  prev = control->hwnd;
3731  }
3732 
3733  /* put them back on the main list */
3734  list_move_head( &dialog->controls, &tab_chain );
3735 }
3736 
3738 {
3739  msi_dialog *dialog = cs->lpCreateParams;
3740  MSIRECORD *rec = NULL;
3741  LPWSTR title = NULL;
3742  RECT pos;
3743 
3744  TRACE("%p %p\n", dialog, dialog->package);
3745 
3746  dialog->hwnd = hwnd;
3748 
3749  rec = msi_get_dialog_record( dialog );
3750  if( !rec )
3751  {
3752  TRACE("No record found for dialog %s\n", debugstr_w(dialog->name));
3753  return -1;
3754  }
3755 
3757 
3759 
3760  dialog->attributes = MSI_RecordGetInteger( rec, 6 );
3761 
3762  dialog->default_font = msi_dup_property( dialog->package->db, L"DefaultUIFont" );