Assorted typo, spelling, wording and case fixes.
[wine] / dlls / msi / events.c
1 /*
2  * Implementation of the Microsoft Installer (msi.dll)
3  *
4  * Copyright 2005 Aric Stewart for CodeWeavers
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <stdarg.h>
22 #include <stdio.h>
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winerror.h"
27 #include "winreg.h"
28 #include "msi.h"
29 #include "msipriv.h"
30
31 #include "wine/debug.h"
32 #include "wine/unicode.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(msi);
35
36 typedef UINT (*EVENTHANDLER)(MSIPACKAGE*,LPCWSTR,msi_dialog *);
37
38 struct control_events
39 {
40     const WCHAR *event;
41     EVENTHANDLER handler;
42 };
43
44 struct subscriber {
45     struct list entry;
46     msi_dialog *dialog;
47     LPWSTR event;
48     LPWSTR control;
49     LPWSTR attribute;
50 };
51
52 static UINT ControlEvent_HandleControlEvent(MSIPACKAGE *, LPCWSTR, LPCWSTR, msi_dialog*);
53
54 /*
55  * Create a dialog box and run it if it's modal
56  */
57 static UINT event_do_dialog( MSIPACKAGE *package, LPCWSTR name, msi_dialog *parent, BOOL destroy_modeless )
58 {
59     msi_dialog *dialog;
60     UINT r;
61
62     /* create a new dialog */
63     dialog = msi_dialog_create( package, name, parent,
64                                 ControlEvent_HandleControlEvent );
65     if( dialog )
66     {
67         /* kill the current modeless dialog */
68         if( destroy_modeless && package->dialog )
69         {
70             msi_dialog_destroy( package->dialog );
71             package->dialog = NULL;
72         }
73
74         /* modeless dialogs return an error message */
75         r = msi_dialog_run_message_loop( dialog );
76         if( r == ERROR_SUCCESS )
77             msi_dialog_destroy( dialog );
78         else
79             package->dialog = dialog;
80     }
81     else
82         r = ERROR_FUNCTION_FAILED;
83
84     return r;
85 }
86
87
88 /*
89  * End a modal dialog box
90  */
91 static UINT ControlEvent_EndDialog(MSIPACKAGE* package, LPCWSTR argument, 
92                                    msi_dialog* dialog)
93 {
94     static const WCHAR szExit[] = {'E','x','i','t',0};
95     static const WCHAR szRetry[] = {'R','e','t','r','y',0};
96     static const WCHAR szIgnore[] = {'I','g','n','o','r','e',0};
97     static const WCHAR szReturn[] = {'R','e','t','u','r','n',0};
98
99     if (!strcmpW( argument, szExit ))
100         package->CurrentInstallState = ERROR_INSTALL_USEREXIT;
101     else if (!strcmpW( argument, szRetry ))
102         package->CurrentInstallState = ERROR_INSTALL_SUSPEND;
103     else if (!strcmpW( argument, szIgnore ))
104         package->CurrentInstallState = ERROR_SUCCESS;
105     else if (!strcmpW( argument, szReturn ))
106     {
107         msi_dialog *parent = msi_dialog_get_parent(dialog);
108         msi_free(package->next_dialog);
109         package->next_dialog = (parent) ? strdupW(msi_dialog_get_name(parent)) : NULL;
110         package->CurrentInstallState = ERROR_SUCCESS;
111     }
112     else
113     {
114         ERR("Unknown argument string %s\n",debugstr_w(argument));
115         package->CurrentInstallState = ERROR_FUNCTION_FAILED;
116     }
117
118     ControlEvent_CleanupDialogSubscriptions(package, msi_dialog_get_name( dialog ));
119     msi_dialog_end_dialog( dialog );
120     return ERROR_SUCCESS;
121 }
122
123 /*
124  * transition from one modal dialog to another modal dialog
125  */
126 static UINT ControlEvent_NewDialog(MSIPACKAGE* package, LPCWSTR argument, 
127                                    msi_dialog *dialog)
128 {
129     /* store the name of the next dialog, and signal this one to end */
130     package->next_dialog = strdupW(argument);
131     ControlEvent_CleanupSubscriptions(package);
132     msi_dialog_end_dialog( dialog );
133     return ERROR_SUCCESS;
134 }
135
136 /*
137  * Create a new child dialog of an existing modal dialog
138  */
139 static UINT ControlEvent_SpawnDialog(MSIPACKAGE* package, LPCWSTR argument, 
140                               msi_dialog *dialog)
141 {
142     /* don't destroy a modeless dialogs that might be our parent */
143     event_do_dialog( package, argument, dialog, FALSE );
144     if( package->CurrentInstallState != ERROR_SUCCESS )
145         msi_dialog_end_dialog( dialog );
146     return ERROR_SUCCESS;
147 }
148
149 /*
150  * Creates a dialog that remains up for a period of time
151  * based on a condition
152  */
153 static UINT ControlEvent_SpawnWaitDialog(MSIPACKAGE* package, LPCWSTR argument, 
154                                   msi_dialog* dialog)
155 {
156     FIXME("Doing Nothing\n");
157     return ERROR_SUCCESS;
158 }
159
160 static UINT ControlEvent_DoAction(MSIPACKAGE* package, LPCWSTR argument, 
161                                   msi_dialog* dialog)
162 {
163     ACTION_PerformAction(package, argument, SCRIPT_NONE);
164     return ERROR_SUCCESS;
165 }
166
167 static UINT ControlEvent_AddLocal( MSIPACKAGE *package, LPCWSTR argument, msi_dialog *dialog )
168 {
169     MSIFEATURE *feature;
170
171     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
172     {
173         if (!strcmpW( argument, feature->Feature ) || !strcmpW( argument, szAll ))
174         {
175             if (feature->ActionRequest != INSTALLSTATE_LOCAL)
176                 msi_set_property( package->db, szPreselected, szOne );
177             MSI_SetFeatureStateW( package, feature->Feature, INSTALLSTATE_LOCAL );
178         }
179     }
180     return ERROR_SUCCESS;
181 }
182
183 static UINT ControlEvent_Remove( MSIPACKAGE *package, LPCWSTR argument, msi_dialog *dialog )
184 {
185     MSIFEATURE *feature;
186
187     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
188     {
189         if (!strcmpW( argument, feature->Feature ) || !strcmpW( argument, szAll ))
190         {
191             if (feature->ActionRequest != INSTALLSTATE_ABSENT)
192                 msi_set_property( package->db, szPreselected, szOne );
193             MSI_SetFeatureStateW( package, feature->Feature, INSTALLSTATE_ABSENT );
194         }
195     }
196     return ERROR_SUCCESS;
197 }
198
199 static UINT ControlEvent_AddSource( MSIPACKAGE *package, LPCWSTR argument, msi_dialog *dialog )
200 {
201     MSIFEATURE *feature;
202
203     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
204     {
205         if (!strcmpW( argument, feature->Feature ) || !strcmpW( argument, szAll ))
206         {
207             if (feature->ActionRequest != INSTALLSTATE_SOURCE)
208                 msi_set_property( package->db, szPreselected, szOne );
209             MSI_SetFeatureStateW( package, feature->Feature, INSTALLSTATE_SOURCE );
210         }
211     }
212     return ERROR_SUCCESS;
213 }
214
215 static UINT ControlEvent_SetTargetPath(MSIPACKAGE* package, LPCWSTR argument, 
216                                    msi_dialog* dialog)
217 {
218     static const WCHAR szSelectionPath[] = {'S','e','l','e','c','t','i','o','n','P','a','t','h',0};
219     LPWSTR path = msi_dup_property( package->db, argument );
220     MSIRECORD *rec = MSI_CreateRecord( 1 );
221     UINT r = ERROR_SUCCESS;
222
223     MSI_RecordSetStringW( rec, 1, path );
224     ControlEvent_FireSubscribedEvent( package, szSelectionPath, rec );
225     if (path)
226     {
227         /* failure to set the path halts the executing of control events */
228         r = MSI_SetTargetPathW(package, argument, path);
229         msi_free(path);
230     }
231     msi_free(&rec->hdr);
232     return r;
233 }
234
235 static UINT ControlEvent_Reset(MSIPACKAGE* package, LPCWSTR argument, 
236                                    msi_dialog* dialog)
237 {
238     msi_dialog_reset(dialog);
239     return ERROR_SUCCESS;
240 }
241
242 /*
243  * Subscribed events
244  */
245 static void free_subscriber( struct subscriber *sub )
246 {
247     msi_free(sub->event);
248     msi_free(sub->control);
249     msi_free(sub->attribute);
250     msi_free(sub);
251 }
252
253 VOID ControlEvent_SubscribeToEvent( MSIPACKAGE *package, msi_dialog *dialog,
254                                     LPCWSTR event, LPCWSTR control, LPCWSTR attribute )
255 {
256     struct subscriber *sub;
257
258     TRACE("event %s control %s attribute %s\n", debugstr_w(event), debugstr_w(control), debugstr_w(attribute));
259
260     LIST_FOR_EACH_ENTRY( sub, &package->subscriptions, struct subscriber, entry )
261     {
262         if (!strcmpiW( sub->event, event ) &&
263             !strcmpiW( sub->control, control ) &&
264             !strcmpiW( sub->attribute, attribute ))
265         {
266             TRACE("already subscribed\n");
267             return;
268         };
269     }
270     if (!(sub = msi_alloc( sizeof(*sub) ))) return;
271     sub->dialog = dialog;
272     sub->event = strdupW(event);
273     sub->control = strdupW(control);
274     sub->attribute = strdupW(attribute);
275     list_add_tail( &package->subscriptions, &sub->entry );
276 }
277
278 VOID ControlEvent_FireSubscribedEvent( MSIPACKAGE *package, LPCWSTR event, MSIRECORD *rec )
279 {
280     struct subscriber *sub;
281
282     TRACE("Firing event %s\n", debugstr_w(event));
283
284     LIST_FOR_EACH_ENTRY( sub, &package->subscriptions, struct subscriber, entry )
285     {
286         if (strcmpiW( sub->event, event )) continue;
287         msi_dialog_handle_event( sub->dialog, sub->control, sub->attribute, rec );
288     }
289 }
290
291 VOID ControlEvent_CleanupDialogSubscriptions(MSIPACKAGE *package, LPWSTR dialog)
292 {
293     struct list *i, *t;
294     struct subscriber *sub;
295
296     LIST_FOR_EACH_SAFE( i, t, &package->subscriptions )
297     {
298         sub = LIST_ENTRY( i, struct subscriber, entry );
299
300         if (strcmpW( msi_dialog_get_name( sub->dialog ), dialog ))
301             continue;
302
303         list_remove( &sub->entry );
304         free_subscriber( sub );
305     }
306 }
307
308 VOID ControlEvent_CleanupSubscriptions(MSIPACKAGE *package)
309 {
310     struct list *i, *t;
311     struct subscriber *sub;
312
313     LIST_FOR_EACH_SAFE( i, t, &package->subscriptions )
314     {
315         sub = LIST_ENTRY( i, struct subscriber, entry );
316
317         list_remove( &sub->entry );
318         free_subscriber( sub );
319     }
320 }
321
322 /*
323  * ACTION_DialogBox()
324  *
325  * Return ERROR_SUCCESS if dialog is process and ERROR_FUNCTION_FAILED
326  * if the given parameter is not a dialog box
327  */
328 UINT ACTION_DialogBox( MSIPACKAGE* package, LPCWSTR szDialogName )
329 {
330     UINT r = ERROR_SUCCESS;
331
332     if( package->next_dialog )
333         ERR("Already a next dialog... ignoring it\n");
334     package->next_dialog = NULL;
335
336     /*
337      * Dialogs are chained by filling in the next_dialog member
338      *  of the package structure, then terminating the current dialog.
339      *  The code below sees the next_dialog member set, and runs the
340      *  next dialog.
341      * We fall out of the loop below if we come across a modeless
342      *  dialog, as it returns ERROR_IO_PENDING when we try to run
343      *  its message loop.
344      */
345     r = event_do_dialog( package, szDialogName, NULL, TRUE );
346     while( r == ERROR_SUCCESS && package->next_dialog )
347     {
348         LPWSTR name = package->next_dialog;
349
350         package->next_dialog = NULL;
351         r = event_do_dialog( package, name, NULL, TRUE );
352         msi_free( name );
353     }
354
355     if( r == ERROR_IO_PENDING )
356         r = ERROR_SUCCESS;
357
358     return r;
359 }
360
361 static UINT ControlEvent_SetInstallLevel(MSIPACKAGE* package, LPCWSTR argument,
362                                           msi_dialog* dialog)
363 {
364     int iInstallLevel = atolW(argument);
365
366     TRACE("Setting install level: %i\n", iInstallLevel);
367
368     return MSI_SetInstallLevel( package, iInstallLevel );
369 }
370
371 static UINT ControlEvent_DirectoryListUp(MSIPACKAGE *package, LPCWSTR argument,
372                                          msi_dialog *dialog)
373 {
374     return msi_dialog_directorylist_up( dialog );
375 }
376
377 static UINT ControlEvent_ReinstallMode(MSIPACKAGE *package, LPCWSTR argument,
378                                        msi_dialog *dialog)
379 {
380     return msi_set_property( package->db, szReinstallMode, argument );
381 }
382
383 static UINT ControlEvent_Reinstall( MSIPACKAGE *package, LPCWSTR argument,
384                                     msi_dialog *dialog )
385 {
386     return msi_set_property( package->db, szReinstall, argument );
387 }
388
389 static UINT ControlEvent_ValidateProductID(MSIPACKAGE *package, LPCWSTR argument,
390                                            msi_dialog *dialog)
391 {
392     return msi_validate_product_id( package );
393 }
394
395 static const WCHAR end_dialogW[] = {'E','n','d','D','i','a','l','o','g',0};
396 static const WCHAR new_dialogW[] = {'N','e','w','D','i','a','l','o','g',0};
397 static const WCHAR spawn_dialogW[] = {'S','p','a','w','n','D','i','a','l','o','g',0};
398 static const WCHAR spawn_wait_dialogW[] = {'S','p','a','w','n','W','a','i','t','D','i','a','l','o','g',0};
399 static const WCHAR do_actionW[] = {'D','o','A','c','t','i','o','n',0};
400 static const WCHAR add_localW[] = {'A','d','d','L','o','c','a','l',0};
401 static const WCHAR removeW[] = {'R','e','m','o','v','e',0};
402 static const WCHAR add_sourceW[] = {'A','d','d','S','o','u','r','c','e',0};
403 static const WCHAR set_target_pathW[] = {'S','e','t','T','a','r','g','e','t','P','a','t','h',0};
404 static const WCHAR resetW[] = {'R','e','s','e','t',0};
405 static const WCHAR set_install_levelW[] = {'S','e','t','I','n','s','t','a','l','l','L','e','v','e','l',0};
406 static const WCHAR directory_list_upW[] = {'D','i','r','e','c','t','o','r','y','L','i','s','t','U','p',0};
407 static const WCHAR selection_browseW[] = {'S','e','l','e','c','t','i','o','n','B','r','o','w','s','e',0};
408 static const WCHAR reinstall_modeW[] = {'R','e','i','n','s','t','a','l','l','M','o','d','e',0};
409 static const WCHAR reinstallW[] = {'R','e','i','n','s','t','a','l','l',0};
410 static const WCHAR validate_product_idW[] = {'V','a','l','i','d','a','t','e','P','r','o','d','u','c','t','I','D',0};
411
412 static const struct control_events control_events[] =
413 {
414     { end_dialogW, ControlEvent_EndDialog },
415     { new_dialogW, ControlEvent_NewDialog },
416     { spawn_dialogW, ControlEvent_SpawnDialog },
417     { spawn_wait_dialogW, ControlEvent_SpawnWaitDialog },
418     { do_actionW, ControlEvent_DoAction },
419     { add_localW, ControlEvent_AddLocal },
420     { removeW, ControlEvent_Remove },
421     { add_sourceW, ControlEvent_AddSource },
422     { set_target_pathW, ControlEvent_SetTargetPath },
423     { resetW, ControlEvent_Reset },
424     { set_install_levelW, ControlEvent_SetInstallLevel },
425     { directory_list_upW, ControlEvent_DirectoryListUp },
426     { selection_browseW, ControlEvent_SpawnDialog },
427     { reinstall_modeW, ControlEvent_ReinstallMode },
428     { reinstallW, ControlEvent_Reinstall },
429     { validate_product_idW, ControlEvent_ValidateProductID },
430     { NULL, NULL }
431 };
432
433 UINT ControlEvent_HandleControlEvent( MSIPACKAGE *package, LPCWSTR event,
434                                       LPCWSTR argument, msi_dialog *dialog )
435 {
436     unsigned int i;
437
438     TRACE("handling control event %s\n", debugstr_w(event));
439
440     if (!event) return ERROR_SUCCESS;
441
442     for (i = 0; control_events[i].event; i++)
443     {
444         if (!strcmpW( control_events[i].event, event ))
445             return control_events[i].handler( package, argument, dialog );
446     }
447     FIXME("unhandled control event %s arg(%s)\n", debugstr_w(event), debugstr_w(argument));
448     return ERROR_SUCCESS;
449 }