git.oblomov.eu Git - wine/blob - 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 #include "action.h"
  36
  37 #include "wine/debug.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     LPWSTR event;
  51     LPWSTR control;
  52     LPWSTR attribute;
  53 };
  54
  55 UINT ControlEvent_HandleControlEvent(MSIPACKAGE *, LPCWSTR, LPCWSTR, msi_dialog*);
  56
  57 /*
  58  * Create a dialog box and run it if it's modal
  59  */
  60 static UINT event_do_dialog( MSIPACKAGE *package, LPCWSTR name, BOOL destroy_modeless )
  61 {
  62     msi_dialog *dialog;
  63     UINT r;
  64
  65     /* create a new dialog */
  66     dialog = msi_dialog_create( package, name,
  67                                 ControlEvent_HandleControlEvent );
  68     if( dialog )
  69     {
  70         /* kill the current modeless dialog */
  71         if( destroy_modeless && package->dialog )
  72         {
  73             msi_dialog_destroy( package->dialog );
  74             package->dialog = NULL;
  75         }
  76
  77         /* modeless dialogs return an error message */
  78         r = msi_dialog_run_message_loop( dialog );
  79         if( r == ERROR_SUCCESS )
  80             msi_dialog_destroy( dialog );
  81         else
  82             package->dialog = dialog;
  83     }
  84     else
  85         r = ERROR_FUNCTION_FAILED;
  86
  87     return r;
  88 }
  89
  90
  91 /*
  92  * End a modal dialog box
  93  */
  94 static UINT ControlEvent_EndDialog(MSIPACKAGE* package, LPCWSTR argument,
  95                                    msi_dialog* dialog)
  96 {
  97     static const WCHAR szExit[] = {
  98     'E','x','i','t',0};
  99     static const WCHAR szRetry[] = {
 100     'R','e','t','r','y',0};
 101     static const WCHAR szIgnore[] = {
 102     'I','g','n','o','r','e',0};
 103     static const WCHAR szReturn[] = {
 104     'R','e','t','u','r','n',0};
 105
 106     if (lstrcmpW(argument,szExit)==0)
 107         package->CurrentInstallState = ERROR_INSTALL_USEREXIT;
 108     else if (lstrcmpW(argument, szRetry) == 0)
 109         package->CurrentInstallState = ERROR_INSTALL_SUSPEND;
 110     else if (lstrcmpW(argument, szIgnore) == 0)
 111         package->CurrentInstallState = -1;
 112     else if (lstrcmpW(argument, szReturn) == 0)
 113         package->CurrentInstallState = ERROR_SUCCESS;
 114     else
 115     {
 116         ERR("Unknown argument string %s\n",debugstr_w(argument));
 117         package->CurrentInstallState = ERROR_FUNCTION_FAILED;
 118     }
 119
 120     ControlEvent_CleanupSubscriptions(package);
 121     msi_dialog_end_dialog( dialog );
 122     return ERROR_SUCCESS;
 123 }
 124
 125 /*
 126  * transition from one modal dialog to another modal dialog
 127  */
 128 static UINT ControlEvent_NewDialog(MSIPACKAGE* package, LPCWSTR argument,
 129                                    msi_dialog *dialog)
 130 {
 131     /* store the name of the next dialog, and signal this one to end */
 132     package->next_dialog = strdupW(argument);
 133     ControlEvent_CleanupSubscriptions(package);
 134     msi_dialog_end_dialog( dialog );
 135     return ERROR_SUCCESS;
 136 }
 137
 138 /*
 139  * Create a new child dialog of an existing modal dialog
 140  */
 141 static UINT ControlEvent_SpawnDialog(MSIPACKAGE* package, LPCWSTR argument,
 142                               msi_dialog *dialog)
 143 {
 144     /* don't destroy a modeless dialogs that might be our parent */
 145     event_do_dialog( package, argument, FALSE );
 146     if( package->CurrentInstallState != ERROR_SUCCESS )
 147         msi_dialog_end_dialog( dialog );
 148     return ERROR_SUCCESS;
 149 }
 150
 151 /*
 152  * Creates a dialog that remains up for a period of time
 153  * based on a condition
 154  */
 155 static UINT ControlEvent_SpawnWaitDialog(MSIPACKAGE* package, LPCWSTR argument,
 156                                   msi_dialog* dialog)
 157 {
 158     FIXME("Doing Nothing\n");
 159     return ERROR_SUCCESS;
 160 }
 161
 162 static UINT ControlEvent_DoAction(MSIPACKAGE* package, LPCWSTR argument,
 163                                   msi_dialog* dialog)
 164 {
 165     ACTION_PerformAction(package,argument,TRUE);
 166     return ERROR_SUCCESS;
 167 }
 168
 169 static UINT ControlEvent_AddLocal(MSIPACKAGE* package, LPCWSTR argument,
 170                                   msi_dialog* dialog)
 171 {
 172     static const WCHAR szAll[] = {'A','L','L',0};
 173     MSIFEATURE *feature = NULL;
 174
 175     if (lstrcmpW(szAll,argument))
 176     {
 177         MSI_SetFeatureStateW(package,argument,INSTALLSTATE_LOCAL);
 178     }
 179     else
 180     {
 181         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
 182         {
 183             feature->ActionRequest = INSTALLSTATE_LOCAL;
 184             feature->Action = INSTALLSTATE_LOCAL;
 185         }
 186         ACTION_UpdateComponentStates(package,argument);
 187     }
 188     return ERROR_SUCCESS;
 189 }
 190
 191 static UINT ControlEvent_Remove(MSIPACKAGE* package, LPCWSTR argument,
 192                                 msi_dialog* dialog)
 193 {
 194     static const WCHAR szAll[] = {'A','L','L',0};
 195     MSIFEATURE *feature = NULL;
 196
 197     if (lstrcmpW(szAll,argument))
 198     {
 199         MSI_SetFeatureStateW(package,argument,INSTALLSTATE_ABSENT);
 200     }
 201     else
 202     {
 203         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
 204         {
 205             feature->ActionRequest = INSTALLSTATE_ABSENT;
 206             feature->Action= INSTALLSTATE_ABSENT;
 207         }
 208         ACTION_UpdateComponentStates(package,argument);
 209     }
 210     return ERROR_SUCCESS;
 211 }
 212
 213 static UINT ControlEvent_AddSource(MSIPACKAGE* package, LPCWSTR argument,
 214                                    msi_dialog* dialog)
 215 {
 216     static const WCHAR szAll[] = {'A','L','L',0};
 217     MSIFEATURE *feature = NULL;
 218
 219     if (lstrcmpW(szAll,argument))
 220     {
 221         MSI_SetFeatureStateW(package,argument,INSTALLSTATE_SOURCE);
 222     }
 223     else
 224     {
 225         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
 226         {
 227             feature->ActionRequest = INSTALLSTATE_SOURCE;
 228             feature->Action = INSTALLSTATE_SOURCE;
 229         }
 230         ACTION_UpdateComponentStates(package,argument);
 231     }
 232     return ERROR_SUCCESS;
 233 }
 234
 235 static UINT ControlEvent_SetTargetPath(MSIPACKAGE* package, LPCWSTR argument,
 236                                    msi_dialog* dialog)
 237 {
 238     LPWSTR path = load_dynamic_property(package,argument, NULL);
 239     UINT r;
 240     /* failure to set the path halts the executing of control events */
 241     r = MSI_SetTargetPathW(package, argument, path);
 242     HeapFree(GetProcessHeap(),0,path);
 243     return r;
 244 }
 245
 246 /*
 247  * Subscribed events
 248  */
 249 static void free_subscriber( struct subscriber *sub )
 250 {
 251     HeapFree(GetProcessHeap(),0,sub->event);
 252     HeapFree(GetProcessHeap(),0,sub->control);
 253     HeapFree(GetProcessHeap(),0,sub->attribute);
 254     HeapFree(GetProcessHeap(),0,sub);
 255 }
 256
 257 VOID ControlEvent_SubscribeToEvent( MSIPACKAGE *package, LPCWSTR event,
 258                                     LPCWSTR control, LPCWSTR attribute )
 259 {
 260     struct subscriber *sub;
 261
 262     sub = HeapAlloc(GetProcessHeap(),0,sizeof (*sub));
 263     if( !sub )
 264         return;
 265     sub->event = strdupW(event);
 266     sub->control = strdupW(control);
 267     sub->attribute = strdupW(attribute);
 268     list_add_tail( &package->subscriptions, &sub->entry );
 269 }
 270
 271 VOID ControlEvent_UnSubscribeToEvent( MSIPACKAGE *package, LPCWSTR event,
 272                                       LPCWSTR control, LPCWSTR attribute )
 273 {
 274     struct list *i, *t;
 275     struct subscriber *sub;
 276
 277     LIST_FOR_EACH_SAFE( i, t, &package->subscriptions )
 278     {
 279         sub = LIST_ENTRY( i, struct subscriber, entry );
 280
 281         if( lstrcmpiW(sub->control,control) )
 282             continue;
 283         if( lstrcmpiW(sub->attribute,attribute) )
 284             continue;
 285         if( lstrcmpiW(sub->event,event) )
 286             continue;
 287         list_remove( &sub->entry );
 288         free_subscriber( sub );
 289     }
 290 }
 291
 292 VOID ControlEvent_FireSubscribedEvent( MSIPACKAGE *package, LPCWSTR event,
 293                                        MSIRECORD *rec )
 294 {
 295     struct subscriber *sub;
 296
 297     TRACE("Firing Event %s\n",debugstr_w(event));
 298
 299     if (!package->dialog)
 300         return;
 301
 302     LIST_FOR_EACH_ENTRY( sub, &package->subscriptions, struct subscriber, entry )
 303     {
 304         if (lstrcmpiW(sub->event, event))
 305             continue;
 306         msi_dialog_handle_event( package->dialog, sub->control,
 307                                  sub->attribute, rec );
 308     }
 309 }
 310
 311 VOID ControlEvent_CleanupSubscriptions(MSIPACKAGE *package)
 312 {
 313     struct list *i, *t;
 314     struct subscriber *sub;
 315
 316     LIST_FOR_EACH_SAFE( i, t, &package->subscriptions )
 317     {
 318         sub = LIST_ENTRY( i, struct subscriber, entry );
 319
 320         list_remove( &sub->entry );
 321         free_subscriber( sub );
 322     }
 323 }
 324
 325 /*
 326  * ACTION_DialogBox()
 327  *
 328  * Return ERROR_SUCCESS if dialog is process and ERROR_FUNCTION_FAILED
 329  * if the given parameter is not a dialog box
 330  */
 331 UINT ACTION_DialogBox( MSIPACKAGE* package, LPCWSTR szDialogName )
 332 {
 333     UINT r = ERROR_SUCCESS;
 334
 335     if( package->next_dialog )
 336         ERR("Already a next dialog... ignoring it\n");
 337     package->next_dialog = NULL;
 338
 339     /*
 340      * Dialogs are chained by filling in the next_dialog member
 341      *  of the package structure, then terminating the current dialog.
 342      *  The code below sees the next_dialog member set, and runs the
 343      *  next dialog.
 344      * We fall out of the loop below if we come across a modeless
 345      *  dialog, as it returns ERROR_IO_PENDING when we try to run
 346      *  its message loop.
 347      */
 348     r = event_do_dialog( package, szDialogName, TRUE );
 349     while( r == ERROR_SUCCESS && package->next_dialog )
 350     {
 351         LPWSTR name = package->next_dialog;
 352
 353         package->next_dialog = NULL;
 354         r = event_do_dialog( package, name, TRUE );
 355         HeapFree( GetProcessHeap(), 0, name );
 356     }
 357
 358     if( r == ERROR_IO_PENDING )
 359         r = ERROR_SUCCESS;
 360
 361     return r;
 362 }
 363
 364 struct _events Events[] = {
 365     { "EndDialog",ControlEvent_EndDialog },
 366     { "NewDialog",ControlEvent_NewDialog },
 367     { "SpawnDialog",ControlEvent_SpawnDialog },
 368     { "SpawnWaitDialog",ControlEvent_SpawnWaitDialog },
 369     { "DoAction",ControlEvent_DoAction },
 370     { "AddLocal",ControlEvent_AddLocal },
 371     { "Remove",ControlEvent_Remove },
 372     { "AddSource",ControlEvent_AddSource },
 373     { "SetTargetPath",ControlEvent_SetTargetPath },
 374     { NULL,NULL },
 375 };
 376
 377 UINT ControlEvent_HandleControlEvent(MSIPACKAGE *package, LPCWSTR event,
 378                                      LPCWSTR argument, msi_dialog* dialog)
 379 {
 380     int i = 0;
 381     UINT rc = ERROR_SUCCESS;
 382
 383     TRACE("Handling Control Event %s\n",debugstr_w(event));
 384     if (!event)
 385         return rc;
 386
 387     while( Events[i].event != NULL)
 388     {
 389         LPWSTR wevent = strdupAtoW(Events[i].event);
 390         if (lstrcmpW(wevent,event)==0)
 391         {
 392             HeapFree(GetProcessHeap(),0,wevent);
 393             rc = Events[i].handler(package,argument,dialog);
 394             return rc;
 395         }
 396         HeapFree(GetProcessHeap(),0,wevent);
 397         i++;
 398     }
 399     FIXME("unhandled control event %s arg(%s)\n",
 400           debugstr_w(event), debugstr_w(argument));
 401     return rc;
 402 }