winecoreaudio: Implement WIDM_GETPOS.
[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
22 /*
23 http://msdn.microsoft.com/library/default.asp?url=/library/en-us/msi/setup/controlevent_overview.asp
24 */
25
26 #include <stdarg.h>
27 #include <stdio.h>
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winerror.h"
32 #include "winreg.h"
33 #include "msi.h"
34 #include "msipriv.h"
35
36 #include "wine/debug.h"
37 #include "wine/unicode.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(msi);
40
41 typedef UINT (*EVENTHANDLER)(MSIPACKAGE*,LPCWSTR,msi_dialog *);
42
43 struct _events {
44     LPCSTR event;
45     EVENTHANDLER handler;
46 };
47
48 struct subscriber {
49     struct list entry;
50     msi_dialog *dialog;
51     LPWSTR event;
52     LPWSTR control;
53     LPWSTR attribute;
54 };
55
56 static UINT ControlEvent_HandleControlEvent(MSIPACKAGE *, LPCWSTR, LPCWSTR, msi_dialog*);
57
58 /*
59  * Create a dialog box and run it if it's modal
60  */
61 static UINT event_do_dialog( MSIPACKAGE *package, LPCWSTR name, msi_dialog *parent, BOOL destroy_modeless )
62 {
63     msi_dialog *dialog;
64     UINT r;
65
66     /* create a new dialog */
67     dialog = msi_dialog_create( package, name, parent,
68                                 ControlEvent_HandleControlEvent );
69     if( dialog )
70     {
71         /* kill the current modeless dialog */
72         if( destroy_modeless && package->dialog )
73         {
74             msi_dialog_destroy( package->dialog );
75             package->dialog = NULL;
76         }
77
78         /* modeless dialogs return an error message */
79         r = msi_dialog_run_message_loop( dialog );
80         if( r == ERROR_SUCCESS )
81             msi_dialog_destroy( dialog );
82         else
83             package->dialog = dialog;
84     }
85     else
86         r = ERROR_FUNCTION_FAILED;
87
88     return r;
89 }
90
91
92 /*
93  * End a modal dialog box
94  */
95 static UINT ControlEvent_EndDialog(MSIPACKAGE* package, LPCWSTR argument, 
96                                    msi_dialog* dialog)
97 {
98     static const WCHAR szExit[] = {
99     'E','x','i','t',0};
100     static const WCHAR szRetry[] = {
101     'R','e','t','r','y',0};
102     static const WCHAR szIgnore[] = {
103     'I','g','n','o','r','e',0};
104     static const WCHAR szReturn[] = {
105     'R','e','t','u','r','n',0};
106
107     if (lstrcmpW(argument,szExit)==0)
108         package->CurrentInstallState = ERROR_INSTALL_USEREXIT;
109     else if (lstrcmpW(argument, szRetry) == 0)
110         package->CurrentInstallState = ERROR_INSTALL_SUSPEND;
111     else if (lstrcmpW(argument, szIgnore) == 0)
112         package->CurrentInstallState = -1;
113     else if (lstrcmpW(argument, szReturn) == 0)
114     {
115         msi_dialog *parent = msi_dialog_get_parent(dialog);
116         msi_free(package->next_dialog);
117         package->next_dialog = (parent) ? strdupW(msi_dialog_get_name(parent)) : NULL;
118         package->CurrentInstallState = ERROR_SUCCESS;
119     }
120     else
121     {
122         ERR("Unknown argument string %s\n",debugstr_w(argument));
123         package->CurrentInstallState = ERROR_FUNCTION_FAILED;
124     }
125
126     ControlEvent_CleanupDialogSubscriptions(package, msi_dialog_get_name( dialog ));
127     msi_dialog_end_dialog( dialog );
128     return ERROR_SUCCESS;
129 }
130
131 /*
132  * transition from one modal dialog to another modal dialog
133  */
134 static UINT ControlEvent_NewDialog(MSIPACKAGE* package, LPCWSTR argument, 
135                                    msi_dialog *dialog)
136 {
137     /* store the name of the next dialog, and signal this one to end */
138     package->next_dialog = strdupW(argument);
139     ControlEvent_CleanupSubscriptions(package);
140     msi_dialog_end_dialog( dialog );
141     return ERROR_SUCCESS;
142 }
143
144 /*
145  * Create a new child dialog of an existing modal dialog
146  */
147 static UINT ControlEvent_SpawnDialog(MSIPACKAGE* package, LPCWSTR argument, 
148                               msi_dialog *dialog)
149 {
150     /* don't destroy a modeless dialogs that might be our parent */
151     event_do_dialog( package, argument, dialog, FALSE );
152     if( package->CurrentInstallState != ERROR_SUCCESS )
153         msi_dialog_end_dialog( dialog );
154     return ERROR_SUCCESS;
155 }
156
157 /*
158  * Creates a dialog that remains up for a period of time
159  * based on a condition
160  */
161 static UINT ControlEvent_SpawnWaitDialog(MSIPACKAGE* package, LPCWSTR argument, 
162                                   msi_dialog* dialog)
163 {
164     FIXME("Doing Nothing\n");
165     return ERROR_SUCCESS;
166 }
167
168 static UINT ControlEvent_DoAction(MSIPACKAGE* package, LPCWSTR argument, 
169                                   msi_dialog* dialog)
170 {
171     ACTION_PerformAction(package,argument,-1,TRUE);
172     return ERROR_SUCCESS;
173 }
174
175 static UINT ControlEvent_AddLocal(MSIPACKAGE* package, LPCWSTR argument, 
176                                   msi_dialog* dialog)
177 {
178     static const WCHAR szAll[] = {'A','L','L',0};
179     MSIFEATURE *feature = NULL;
180
181     if (lstrcmpW(szAll,argument))
182     {
183         MSI_SetFeatureStateW(package,argument,INSTALLSTATE_LOCAL);
184     }
185     else
186     {
187         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
188             msi_feature_set_state( feature, INSTALLSTATE_LOCAL );
189
190         ACTION_UpdateComponentStates(package,argument);
191     }
192     return ERROR_SUCCESS;
193 }
194
195 static UINT ControlEvent_Remove(MSIPACKAGE* package, LPCWSTR argument, 
196                                 msi_dialog* dialog)
197 {
198     static const WCHAR szAll[] = {'A','L','L',0};
199     MSIFEATURE *feature = NULL;
200
201     if (lstrcmpW(szAll,argument))
202     {
203         MSI_SetFeatureStateW(package,argument,INSTALLSTATE_ABSENT);
204     }
205     else
206     {
207         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
208             msi_feature_set_state( feature, INSTALLSTATE_ABSENT );
209
210         ACTION_UpdateComponentStates(package,argument);
211     }
212     return ERROR_SUCCESS;
213 }
214
215 static UINT ControlEvent_AddSource(MSIPACKAGE* package, LPCWSTR argument, 
216                                    msi_dialog* dialog)
217 {
218     static const WCHAR szAll[] = {'A','L','L',0};
219     MSIFEATURE *feature = NULL;
220
221     if (lstrcmpW(szAll,argument))
222     {
223         MSI_SetFeatureStateW(package,argument,INSTALLSTATE_SOURCE);
224     }
225     else
226     {
227         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
228             msi_feature_set_state( feature, INSTALLSTATE_SOURCE );
229         ACTION_UpdateComponentStates(package,argument);
230     }
231     return ERROR_SUCCESS;
232 }
233
234 static UINT ControlEvent_SetTargetPath(MSIPACKAGE* package, LPCWSTR argument, 
235                                    msi_dialog* dialog)
236 {
237     LPWSTR path = msi_dup_property( package, argument );
238     MSIRECORD *rec = MSI_CreateRecord( 1 );
239     UINT r;
240
241     static const WCHAR szSelectionPath[] = {'S','e','l','e','c','t','i','o','n','P','a','t','h',0};
242
243     MSI_RecordSetStringW( rec, 1, path );
244     ControlEvent_FireSubscribedEvent( package, szSelectionPath, rec );
245
246     /* failure to set the path halts the executing of control events */
247     r = MSI_SetTargetPathW(package, argument, path);
248     msi_free(path);
249     msi_free(&rec->hdr);
250     return r;
251 }
252
253 static UINT ControlEvent_Reset(MSIPACKAGE* package, LPCWSTR argument, 
254                                    msi_dialog* dialog)
255 {
256     msi_dialog_reset(dialog);
257     return ERROR_SUCCESS;
258 }
259
260 /*
261  * Subscribed events
262  */
263 static void free_subscriber( struct subscriber *sub )
264 {
265     msi_free(sub->event);
266     msi_free(sub->control);
267     msi_free(sub->attribute);
268     msi_free(sub);
269 }
270
271 VOID ControlEvent_SubscribeToEvent( MSIPACKAGE *package, msi_dialog *dialog,
272                                     LPCWSTR event, LPCWSTR control, LPCWSTR attribute )
273 {
274     struct subscriber *sub;
275
276     sub = msi_alloc(sizeof (*sub));
277     if( !sub )
278         return;
279     sub->dialog = dialog;
280     sub->event = strdupW(event);
281     sub->control = strdupW(control);
282     sub->attribute = strdupW(attribute);
283     list_add_tail( &package->subscriptions, &sub->entry );
284 }
285
286 VOID ControlEvent_UnSubscribeToEvent( MSIPACKAGE *package, LPCWSTR event,
287                                       LPCWSTR control, LPCWSTR attribute )
288 {
289     struct list *i, *t;
290     struct subscriber *sub;
291
292     LIST_FOR_EACH_SAFE( i, t, &package->subscriptions )
293     {
294         sub = LIST_ENTRY( i, struct subscriber, entry );
295
296         if( lstrcmpiW(sub->control,control) )
297             continue;
298         if( lstrcmpiW(sub->attribute,attribute) )
299             continue;
300         if( lstrcmpiW(sub->event,event) )
301             continue;
302         list_remove( &sub->entry );
303         free_subscriber( sub );
304     }
305 }
306
307 VOID ControlEvent_FireSubscribedEvent( MSIPACKAGE *package, LPCWSTR event, 
308                                        MSIRECORD *rec )
309 {
310     struct subscriber *sub;
311
312     TRACE("Firing Event %s\n",debugstr_w(event));
313
314     LIST_FOR_EACH_ENTRY( sub, &package->subscriptions, struct subscriber, entry )
315     {
316         if (lstrcmpiW(sub->event, event))
317             continue;
318         msi_dialog_handle_event( sub->dialog, sub->control,
319                                  sub->attribute, rec );
320     }
321 }
322
323 VOID ControlEvent_CleanupDialogSubscriptions(MSIPACKAGE *package, LPWSTR dialog)
324 {
325     struct list *i, *t;
326     struct subscriber *sub;
327
328     LIST_FOR_EACH_SAFE( i, t, &package->subscriptions )
329     {
330         sub = LIST_ENTRY( i, struct subscriber, entry );
331
332         if ( lstrcmpW( msi_dialog_get_name( sub->dialog ), dialog ))
333             continue;
334
335         list_remove( &sub->entry );
336         free_subscriber( sub );
337     }
338 }
339
340 VOID ControlEvent_CleanupSubscriptions(MSIPACKAGE *package)
341 {
342     struct list *i, *t;
343     struct subscriber *sub;
344
345     LIST_FOR_EACH_SAFE( i, t, &package->subscriptions )
346     {
347         sub = LIST_ENTRY( i, struct subscriber, entry );
348
349         list_remove( &sub->entry );
350         free_subscriber( sub );
351     }
352 }
353
354 /*
355  * ACTION_DialogBox()
356  *
357  * Return ERROR_SUCCESS if dialog is process and ERROR_FUNCTION_FAILED
358  * if the given parameter is not a dialog box
359  */
360 UINT ACTION_DialogBox( MSIPACKAGE* package, LPCWSTR szDialogName )
361 {
362     UINT r = ERROR_SUCCESS;
363
364     if( package->next_dialog )
365         ERR("Already a next dialog... ignoring it\n");
366     package->next_dialog = NULL;
367
368     /*
369      * Dialogs are chained by filling in the next_dialog member
370      *  of the package structure, then terminating the current dialog.
371      *  The code below sees the next_dialog member set, and runs the
372      *  next dialog.
373      * We fall out of the loop below if we come across a modeless
374      *  dialog, as it returns ERROR_IO_PENDING when we try to run
375      *  its message loop.
376      */
377     r = event_do_dialog( package, szDialogName, NULL, TRUE );
378     while( r == ERROR_SUCCESS && package->next_dialog )
379     {
380         LPWSTR name = package->next_dialog;
381
382         package->next_dialog = NULL;
383         r = event_do_dialog( package, name, NULL, TRUE );
384         msi_free( name );
385     }
386
387     if( r == ERROR_IO_PENDING )
388         r = ERROR_SUCCESS;
389
390     return r;
391 }
392
393 static UINT ControlEvent_SetInstallLevel(MSIPACKAGE* package, LPCWSTR argument,
394                                           msi_dialog* dialog)
395 {
396     int iInstallLevel = atolW(argument);
397
398     TRACE("Setting install level: %i\n", iInstallLevel);
399
400     return MSI_SetInstallLevel( package, iInstallLevel );
401 }
402
403 static UINT ControlEvent_DirectoryListUp(MSIPACKAGE *package, LPCWSTR argument,
404                                          msi_dialog *dialog)
405 {
406     return msi_dialog_directorylist_up( dialog );
407 }
408
409 static UINT ControlEvent_ReinstallMode(MSIPACKAGE *package, LPCWSTR argument,
410                                        msi_dialog *dialog)
411 {
412     static const WCHAR szReinstallMode[] = {'R','E','I','N','S','T','A','L','L','M','O','D','E',0};
413     return MSI_SetPropertyW( package, szReinstallMode, argument );
414 }
415
416 static const struct _events Events[] = {
417     { "EndDialog",ControlEvent_EndDialog },
418     { "NewDialog",ControlEvent_NewDialog },
419     { "SpawnDialog",ControlEvent_SpawnDialog },
420     { "SpawnWaitDialog",ControlEvent_SpawnWaitDialog },
421     { "DoAction",ControlEvent_DoAction },
422     { "AddLocal",ControlEvent_AddLocal },
423     { "Remove",ControlEvent_Remove },
424     { "AddSource",ControlEvent_AddSource },
425     { "SetTargetPath",ControlEvent_SetTargetPath },
426     { "Reset",ControlEvent_Reset },
427     { "SetInstallLevel",ControlEvent_SetInstallLevel },
428     { "DirectoryListUp",ControlEvent_DirectoryListUp },
429     { "SelectionBrowse",ControlEvent_SpawnDialog },
430     { "ReinstallMode",ControlEvent_ReinstallMode },
431     { NULL,NULL },
432 };
433
434 UINT ControlEvent_HandleControlEvent(MSIPACKAGE *package, LPCWSTR event,
435                                      LPCWSTR argument, msi_dialog* dialog)
436 {
437     int i = 0;
438     UINT rc = ERROR_SUCCESS;
439
440     TRACE("Handling Control Event %s\n",debugstr_w(event));
441     if (!event)
442         return rc;
443
444     while( Events[i].event != NULL)
445     {
446         LPWSTR wevent = strdupAtoW(Events[i].event);
447         if (lstrcmpW(wevent,event)==0)
448         {
449             msi_free(wevent);
450             rc = Events[i].handler(package,argument,dialog);
451             return rc;
452         }
453         msi_free(wevent);
454         i++;
455     }
456     FIXME("unhandled control event %s arg(%s)\n",
457           debugstr_w(event), debugstr_w(argument));
458     return rc;
459 }