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., 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 #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 = msi_dup_property( package, argument );
 239     UINT r;
 240     /* failure to set the path halts the executing of control events */
 241     r = MSI_SetTargetPathW(package, argument, path);
 242     msi_free(path);
 243     return r;
 244 }
 245
 246 static UINT ControlEvent_Reset(MSIPACKAGE* package, LPCWSTR argument,
 247                                    msi_dialog* dialog)
 248 {
 249     msi_dialog_reset(dialog);
 250     return ERROR_SUCCESS;
 251 }
 252
 253 /*
 254  * Subscribed events
 255  */
 256 static void free_subscriber( struct subscriber *sub )
 257 {
 258     msi_free(sub->event);
 259     msi_free(sub->control);
 260     msi_free(sub->attribute);
 261     msi_free(sub);
 262 }
 263
 264 VOID ControlEvent_SubscribeToEvent( MSIPACKAGE *package, LPCWSTR event,
 265                                     LPCWSTR control, LPCWSTR attribute )
 266 {
 267     struct subscriber *sub;
 268
 269     sub = msi_alloc(sizeof (*sub));
 270     if( !sub )
 271         return;
 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_UnSubscribeToEvent( MSIPACKAGE *package, LPCWSTR event,
 279                                       LPCWSTR control, LPCWSTR attribute )
 280 {
 281     struct list *i, *t;
 282     struct subscriber *sub;
 283
 284     LIST_FOR_EACH_SAFE( i, t, &package->subscriptions )
 285     {
 286         sub = LIST_ENTRY( i, struct subscriber, entry );
 287
 288         if( lstrcmpiW(sub->control,control) )
 289             continue;
 290         if( lstrcmpiW(sub->attribute,attribute) )
 291             continue;
 292         if( lstrcmpiW(sub->event,event) )
 293             continue;
 294         list_remove( &sub->entry );
 295         free_subscriber( sub );
 296     }
 297 }
 298
 299 VOID ControlEvent_FireSubscribedEvent( MSIPACKAGE *package, LPCWSTR event,
 300                                        MSIRECORD *rec )
 301 {
 302     struct subscriber *sub;
 303
 304     TRACE("Firing Event %s\n",debugstr_w(event));
 305
 306     if (!package->dialog)
 307         return;
 308
 309     LIST_FOR_EACH_ENTRY( sub, &package->subscriptions, struct subscriber, entry )
 310     {
 311         if (lstrcmpiW(sub->event, event))
 312             continue;
 313         msi_dialog_handle_event( package->dialog, sub->control,
 314                                  sub->attribute, rec );
 315     }
 316 }
 317
 318 VOID ControlEvent_CleanupSubscriptions(MSIPACKAGE *package)
 319 {
 320     struct list *i, *t;
 321     struct subscriber *sub;
 322
 323     LIST_FOR_EACH_SAFE( i, t, &package->subscriptions )
 324     {
 325         sub = LIST_ENTRY( i, struct subscriber, entry );
 326
 327         list_remove( &sub->entry );
 328         free_subscriber( sub );
 329     }
 330 }
 331
 332 /*
 333  * ACTION_DialogBox()
 334  *
 335  * Return ERROR_SUCCESS if dialog is process and ERROR_FUNCTION_FAILED
 336  * if the given parameter is not a dialog box
 337  */
 338 UINT ACTION_DialogBox( MSIPACKAGE* package, LPCWSTR szDialogName )
 339 {
 340     UINT r = ERROR_SUCCESS;
 341
 342     if( package->next_dialog )
 343         ERR("Already a next dialog... ignoring it\n");
 344     package->next_dialog = NULL;
 345
 346     /*
 347      * Dialogs are chained by filling in the next_dialog member
 348      *  of the package structure, then terminating the current dialog.
 349      *  The code below sees the next_dialog member set, and runs the
 350      *  next dialog.
 351      * We fall out of the loop below if we come across a modeless
 352      *  dialog, as it returns ERROR_IO_PENDING when we try to run
 353      *  its message loop.
 354      */
 355     r = event_do_dialog( package, szDialogName, TRUE );
 356     while( r == ERROR_SUCCESS && package->next_dialog )
 357     {
 358         LPWSTR name = package->next_dialog;
 359
 360         package->next_dialog = NULL;
 361         r = event_do_dialog( package, name, TRUE );
 362         msi_free( name );
 363     }
 364
 365     if( r == ERROR_IO_PENDING )
 366         r = ERROR_SUCCESS;
 367
 368     return r;
 369 }
 370
 371 static const struct _events Events[] = {
 372     { "EndDialog",ControlEvent_EndDialog },
 373     { "NewDialog",ControlEvent_NewDialog },
 374     { "SpawnDialog",ControlEvent_SpawnDialog },
 375     { "SpawnWaitDialog",ControlEvent_SpawnWaitDialog },
 376     { "DoAction",ControlEvent_DoAction },
 377     { "AddLocal",ControlEvent_AddLocal },
 378     { "Remove",ControlEvent_Remove },
 379     { "AddSource",ControlEvent_AddSource },
 380     { "SetTargetPath",ControlEvent_SetTargetPath },
 381     { "Reset",ControlEvent_Reset },
 382     { NULL,NULL },
 383 };
 384
 385 UINT ControlEvent_HandleControlEvent(MSIPACKAGE *package, LPCWSTR event,
 386                                      LPCWSTR argument, msi_dialog* dialog)
 387 {
 388     int i = 0;
 389     UINT rc = ERROR_SUCCESS;
 390
 391     TRACE("Handling Control Event %s\n",debugstr_w(event));
 392     if (!event)
 393         return rc;
 394
 395     while( Events[i].event != NULL)
 396     {
 397         LPWSTR wevent = strdupAtoW(Events[i].event);
 398         if (lstrcmpW(wevent,event)==0)
 399         {
 400             msi_free(wevent);
 401             rc = Events[i].handler(package,argument,dialog);
 402             return rc;
 403         }
 404         msi_free(wevent);
 405         i++;
 406     }
 407     FIXME("unhandled control event %s arg(%s)\n",
 408           debugstr_w(event), debugstr_w(argument));
 409     return rc;
 410 }