setup_native/source/win32/customactions/reg4allmsdoc/reg4allmsi.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #ifdef _MSC_VER
  30 #pragma warning(push, 1) /* disable warnings within system headers */
  31 #endif
  32 #define WIN32_LEAN_AND_MEAN
  33 #include <windows.h>
  34 #include <msiquery.h>
  35 #ifdef _MSC_VER
  36 #pragma warning(pop)
  37 #endif
  38
  39 #include <malloc.h>
  40 #include <string>
  41 #include <strsafe.h>
  42
  43 //----------------------------------------------------------
  44 static const CHAR* g_Extensions[] =
  45 {
  46     ".doc",     // Microsoft Word Text [0]
  47     ".dot",     // Microsoft Word Template
  48     ".rtf",     // rtf text
  49     ".docx",    // Office Word 2007 XML document
  50     ".docm",    // Office Word 2007 XML macro-enabled document
  51     ".dotx",    // Office Word 2007 XML template
  52     ".dotm",    // Office Word 2007 XML macro-enabled template
  53     ".xlw",     // Microsoft Excel
  54     ".xls",     // Microsoft Excel
  55     ".xlt",     // Microsoft Excel Template
  56     ".xlsx",    // Office Excel 2007 XML workbook
  57     ".xlsm",    // Office Excel 2007 XML macro-enabled workbook
  58     ".xltx",    // Office Excel 2007 XML template
  59     ".xltm",    // Office Excel 2007 XML macro-enabled template
  60     ".xlsb",    // Office Excel 2007 binary workbook (BIFF12)
  61     ".ppt",     // Microsoft Powerpoint
  62     ".pps",     // Microsoft Powerpoint
  63     ".pot",     // Microsoft Powerpoint Template
  64     ".pptx",    // Office PowerPoint 2007 XML presentation
  65     ".pptm",    // Office PowerPoint 2007 macro-enabled XML presentation
  66     ".potx",    // Office PowerPoint 2007 XML template
  67     ".potm",    // Office PowerPoint 2007 macro-enabled XML template
  68     ".ppsx",    // Office PowerPoint 2007 XML show
  69     ".vsd",     // Visio 2000/XP/2003 document
  70     ".vst",     // Visio 2000/XP/2003 template
  71     0
  72 };
  73
  74 static const int WORD_START = 0;
  75 static const int EXCEL_START = 7;
  76 static const int POWERPOINT_START = 15;
  77 static const int VISIO_START = 23;
  78 static const int VISIO_END = 25;
  79
  80 //    ".xlam",    // Office Excel 2007 XML macro-enabled add-in
  81 //    ".ppam",    // Office PowerPoint 2007 macro-enabled XML add-in
  82 //    ".ppsm",    // Office PowerPoint 2007 macro-enabled XML show
  83
  84 //----------------------------------------------------------
  85 #ifdef DEBUG
  86 inline void OutputDebugStringFormat( LPCSTR pFormat, ... )
  87 {
  88     CHAR    buffer[1024];
  89     va_list args;
  90
  91     va_start( args, pFormat );
  92     StringCchVPrintfA( buffer, sizeof(buffer), pFormat, args );
  93     OutputDebugStringA( buffer );
  94 }
  95 #else
  96 static inline void OutputDebugStringFormat( LPCSTR, ... )
  97 {
  98 }
  99 #endif
 100
 101 //----------------------------------------------------------
 102 static BOOL CheckExtensionInRegistry( LPCSTR lpSubKey )
 103 {
 104     BOOL    bRet = false;
 105     HKEY    hKey = NULL;
 106     LONG    lResult = RegOpenKeyExA( HKEY_CLASSES_ROOT, lpSubKey, 0, KEY_QUERY_VALUE, &hKey );
 107
 108     if ( ERROR_SUCCESS == lResult )
 109     {
 110         CHAR    szBuffer[1024];
 111         DWORD   nSize = sizeof( szBuffer );
 112
 113         lResult = RegQueryValueExA( hKey, "", NULL, NULL, (LPBYTE)szBuffer, &nSize );
 114         if ( ERROR_SUCCESS == lResult )
 115         {
 116             szBuffer[nSize] = '\0';
 117             OutputDebugStringFormat( "Found value [%s] for key [%s].\n", szBuffer, lpSubKey );
 118
 119             if ( strncmp( szBuffer, "WordPad.Document.1", 18 ) == 0 )
 120             {   // We will replace registration for word pad
 121                 bRet = true;
 122             }
 123             else if ( strncmp( szBuffer, "LibreOffice.", 12 ) == 0 )
 124             {   // We will replace registration for our own types, too
 125                 bRet = true;
 126             }
 127             else if ( strncmp( szBuffer, "lostub.", 7 ) == 0 )
 128             {   // We will replace registration for ooostub, too
 129                 bRet = true;
 130             }
 131             else
 132             {
 133                 OutputDebugStringFormat( "  Checking OpenWithList of [%s].\n", lpSubKey );
 134                 HKEY hSubKey;
 135                 lResult = RegOpenKeyExA( hKey, "OpenWithList", 0, KEY_ENUMERATE_SUB_KEYS, &hSubKey );
 136                 if ( ERROR_SUCCESS == lResult )
 137                 {
 138                     DWORD nIndex = 0;
 139                     while ( ERROR_SUCCESS == lResult )
 140                     {
 141                         nSize = sizeof( szBuffer );
 142                         lResult = RegEnumKeyExA( hSubKey, nIndex++, szBuffer, &nSize, NULL, NULL, NULL, NULL );
 143                         if ( ERROR_SUCCESS == lResult )
 144                         {
 145                             OutputDebugStringFormat( "    Found value [%s] in OpenWithList of [%s].\n", szBuffer, lpSubKey );
 146                             if ( strncmp( szBuffer, "WordPad.exe", 11 ) == 0 )
 147                             {   // We will replace registration for word pad
 148                                 bRet = true;
 149                             }
 150                             else if ( nSize > 0 )
 151                                 bRet = false;
 152                         }
 153                     }
 154                 }
 155                 else
 156                 {
 157                     OutputDebugStringFormat( "  No OpenWithList found!\n" );
 158                 }
 159             }
 160         }
 161         else    // no default value found -> return TRUE to register for that key
 162             bRet = true;
 163
 164         RegCloseKey( hKey );
 165     }
 166     else // no key found -> return TRUE to register for that key
 167         bRet = true;
 168
 169     return bRet;
 170 }
 171
 172 //----------------------------------------------------------
 173 static LONG DeleteSubKeyTree( HKEY RootKey, LPCSTR lpKey )
 174 {
 175     HKEY hKey;
 176     LONG rc = RegOpenKeyExA( RootKey, lpKey, 0, KEY_READ | DELETE, &hKey );
 177
 178     if (ERROR_SUCCESS == rc)
 179     {
 180         LPCSTR    lpSubKey;
 181         DWORD     nMaxSubKeyLen;
 182
 183         rc = RegQueryInfoKeyA( hKey, 0, 0, 0, 0, &nMaxSubKeyLen, 0, 0, 0, 0, 0, 0 );
 184         nMaxSubKeyLen++; // space for trailing '\0'
 185         lpSubKey = reinterpret_cast<CHAR*>( _alloca( nMaxSubKeyLen*sizeof(CHAR) ) );
 186
 187         while (ERROR_SUCCESS == rc)
 188         {
 189             DWORD nLen = nMaxSubKeyLen;
 190             rc = RegEnumKeyExA( hKey, 0, (LPSTR)lpSubKey, &nLen, 0, 0, 0, 0);    // always index zero
 191
 192             if ( ERROR_NO_MORE_ITEMS == rc )
 193             {
 194                 rc = RegDeleteKeyA( RootKey, lpKey );
 195                 if ( rc == ERROR_SUCCESS )
 196                     OutputDebugStringFormat( "deleted key [%s] from registry.\n", lpKey );
 197                 else
 198                     OutputDebugStringFormat( "RegDeleteKeyA %s returned %ld.\n", lpKey, rc );
 199                 break;
 200             }
 201             else if ( rc == ERROR_SUCCESS )
 202             {
 203                 rc = DeleteSubKeyTree( hKey, lpSubKey );
 204                 if ( ERROR_SUCCESS != rc )
 205                     OutputDebugStringFormat( "RegDeleteKeyA %s returned %ld.\n", lpSubKey, rc );
 206             }
 207
 208         }
 209         RegCloseKey(hKey);
 210     }
 211     else
 212     {
 213         OutputDebugStringFormat( "RegOpenKeyExA %s returned %ld.\n", lpKey, rc );
 214     }
 215
 216     return rc;
 217 }
 218
 219 // Unused
 220 #if 0
 221
 222 //----------------------------------------------------------
 223 static BOOL RemoveExtensionInRegistry( LPCSTR lpSubKey )
 224 {
 225     CHAR    szBuffer[4096];
 226     DWORD   nSize = sizeof( szBuffer );
 227     HKEY    hKey = NULL;
 228     HKEY    hSubKey = NULL;
 229     LONG    lResult = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "SOFTWARE\\Classes", 0, KEY_QUERY_VALUE, &hKey );
 230
 231     if ( ERROR_SUCCESS == lResult )
 232     {
 233         lResult = RegOpenKeyExA( hKey, lpSubKey, 0, KEY_QUERY_VALUE, &hSubKey );
 234
 235         if ( ERROR_SUCCESS == lResult )
 236         {
 237             DWORD nSubKeys = 1;
 238             szBuffer[0] = '\0';
 239
 240             // we get the value of the default key fist and while we are on querying,
 241             // we ask for the subkey count, too
 242             lResult = RegQueryValueExA( hSubKey, "", NULL, NULL, (LPBYTE)szBuffer, &nSize );
 243             if ( ERROR_SUCCESS == lResult )
 244                 RegQueryInfoKeyA( hSubKey, 0, 0, 0, &nSubKeys, 0, 0, 0, 0, 0, 0, 0 );
 245             RegCloseKey( hSubKey );
 246
 247             // we will remove all key with an default value starting with ooostub but
 248             // we have to be careful about MSO keys
 249             if ( strncmp( szBuffer, "opendocument.", 13 ) == 0 )
 250             {
 251                 if ( nSubKeys == 0 )
 252                 {
 253                     DeleteSubKeyTree( hKey, lpSubKey );
 254                 }
 255                 else
 256                 {
 257                     lResult = RegOpenKeyExA( hKey, lpSubKey, 0, KEY_SET_VALUE, &hSubKey );
 258                     if ( ERROR_SUCCESS == lResult )
 259                         RegDeleteValueA( hSubKey, "" );
 260                     else
 261                         OutputDebugStringFormat( "Could not open key %s for deleting: RegOpenKeyEx returned %ld.\n", lpSubKey, lResult );
 262                 }
 263             }
 264         }
 265
 266         RegCloseKey( hKey );
 267     }
 268
 269     return ( ERROR_SUCCESS == lResult );
 270 }
 271
 272 #endif
 273
 274 //----------------------------------------------------------
 275 bool GetMsiProp( MSIHANDLE handle, LPCSTR name, /*out*/std::string& value )
 276 {
 277     DWORD sz = 0;
 278     LPSTR dummy = "";
 279     if (MsiGetPropertyA(handle, name, dummy, &sz) == ERROR_MORE_DATA)
 280     {
 281         sz++;
 282         DWORD nbytes = sz * sizeof(TCHAR);
 283         LPSTR buff = reinterpret_cast<LPSTR>(_alloca(nbytes));
 284         ZeroMemory(buff, nbytes);
 285         MsiGetPropertyA(handle, name, buff, &sz);
 286         value = buff;
 287         return true;
 288     }
 289     return false;
 290 }
 291
 292 //----------------------------------------------------------
 293 bool IsSetMsiProp( MSIHANDLE handle, LPCSTR name )
 294 {
 295     std::string val;
 296     GetMsiProp( handle, name, val );
 297     return (val == "1");
 298 }
 299
 300 //----------------------------------------------------------
 301 static void registerForExtension( MSIHANDLE handle, const int nIndex, bool bRegister )
 302 {
 303     CHAR sPropName[256];
 304     StringCchCopyA( sPropName, 256, "REGISTER_" );
 305     StringCchCatA( sPropName, 256, (g_Extensions[nIndex])+1 );
 306     CharUpperBuffA( sPropName+9, 4 );
 307
 308     if ( bRegister ) {
 309         MsiSetPropertyA( handle, sPropName, "1" );
 310         OutputDebugStringFormat( "Set MSI property %s.\n", sPropName );
 311     } else {
 312         MsiSetPropertyA( handle, sPropName, "0" );
 313         OutputDebugStringFormat( "Unset MSI property %s.\n", sPropName );
 314     }
 315 }
 316
 317 //----------------------------------------------------------
 318 static void saveOldRegistration( LPCSTR lpSubKey )
 319 {
 320     BOOL    bRet = false;
 321     HKEY    hKey = NULL;
 322     LONG    lResult = RegOpenKeyExA( HKEY_CLASSES_ROOT, lpSubKey, 0,
 323                                      KEY_QUERY_VALUE|KEY_SET_VALUE, &hKey );
 324
 325     if ( ERROR_SUCCESS == lResult )
 326     {
 327         CHAR    szBuffer[1024];
 328         DWORD   nSize = sizeof( szBuffer );
 329
 330         lResult = RegQueryValueExA( hKey, "", NULL, NULL, (LPBYTE)szBuffer, &nSize );
 331         if ( ERROR_SUCCESS == lResult )
 332         {
 333             szBuffer[nSize] = '\0';
 334
 335             // No need to save assocations for our own types
 336             if ( strncmp( szBuffer, "LibreOffice.", 12 ) != 0 )
 337             {
 338                 // Save the old association
 339                 RegSetValueExA( hKey, "LOBackupAssociation", 0,
 340                                 REG_SZ, (LPBYTE)szBuffer, nSize );
 341                 // Also save what the old association means, just so we can try to verify
 342                 // if/when restoring it that the old application still exists
 343                 HKEY hKey2 = NULL;
 344                 lResult = RegOpenKeyExA( HKEY_CLASSES_ROOT, szBuffer, 0,
 345                                          KEY_QUERY_VALUE, &hKey2 );
 346                 if ( ERROR_SUCCESS == lResult )
 347                 {
 348                     nSize = sizeof( szBuffer );
 349                     lResult = RegQueryValueExA( hKey2, "", NULL, NULL, (LPBYTE)szBuffer, &nSize );
 350                     if ( ERROR_SUCCESS == lResult )
 351                     {
 352                         RegSetValueExA( hKey, "LOBackupAssociationDeref", 0,
 353                                         REG_SZ, (LPBYTE)szBuffer, nSize );
 354                     }
 355                     RegCloseKey( hKey2 );
 356                 }
 357             }
 358         }
 359         RegCloseKey( hKey );
 360     }
 361 }
 362
 363 //----------------------------------------------------------
 364 static void registerForExtensions( MSIHANDLE handle, BOOL bRegisterAll )
 365 { // Check all file extensions
 366     int nIndex = 0;
 367     while ( g_Extensions[nIndex] != 0 )
 368     {
 369         saveOldRegistration( g_Extensions[nIndex] );
 370
 371         BOOL bRegister = bRegisterAll || CheckExtensionInRegistry( g_Extensions[nIndex] );
 372         if ( bRegister )
 373             registerForExtension( handle, nIndex, true );
 374         ++nIndex;
 375     }
 376 }
 377
 378 //----------------------------------------------------------
 379 static bool checkSomeExtensionInRegistry( const int nStart, const int nEnd )
 380 { // Check all file extensions
 381     int nIndex = nStart;
 382     bool bFound = false;
 383
 384     while ( !bFound && ( g_Extensions[nIndex] != 0 ) && ( nIndex < nEnd ) )
 385     {
 386         bFound = ! CheckExtensionInRegistry( g_Extensions[nIndex] );
 387
 388         if ( bFound )
 389             OutputDebugStringFormat( "Found registration for [%s].\n", g_Extensions[nIndex] );
 390
 391         ++nIndex;
 392     }
 393     return bFound;
 394 }
 395
 396 //----------------------------------------------------------
 397 static void registerSomeExtensions( MSIHANDLE handle, const int nStart, const int nEnd, bool bRegister )
 398 { // Check all file extensions
 399     int nIndex = nStart;
 400
 401     while ( ( g_Extensions[nIndex] != 0 ) && ( nIndex < nEnd ) )
 402     {
 403         registerForExtension( handle, nIndex++, bRegister );
 404     }
 405 }
 406
 407 //----------------------------------------------------------
 408 //----------------------------------------------------------
 409 //----------------------------------------------------------
 410 extern "C" UINT __stdcall LookForRegisteredExtensions( MSIHANDLE handle )
 411 {
 412     OutputDebugStringFormat( "LookForRegisteredExtensions: " );
 413
 414     INSTALLSTATE current_state;
 415     INSTALLSTATE future_state;
 416
 417     bool bWriterEnabled = false;
 418     bool bCalcEnabled = false;
 419     bool bImpressEnabled = false;
 420     bool bDrawEnabled = false;
 421     bool bRegisterNone = IsSetMsiProp( handle, "REGISTER_NO_MSO_TYPES" );
 422
 423     if ( ( ERROR_SUCCESS == MsiGetFeatureState( handle, L"gm_p_Wrt", &current_state, &future_state ) ) &&
 424          ( (future_state == INSTALLSTATE_LOCAL) || ((current_state == INSTALLSTATE_LOCAL) && (future_state == INSTALLSTATE_UNKNOWN) ) ) )
 425         bWriterEnabled = true;
 426
 427     OutputDebugStringFormat( "LookForRegisteredExtensions: Install state Writer is [%d], will be [%d]", current_state, future_state );
 428     if ( bWriterEnabled )
 429         OutputDebugStringFormat( "LookForRegisteredExtensions: Writer is enabled" );
 430     else
 431         OutputDebugStringFormat( "LookForRegisteredExtensions: Writer is NOT enabled" );
 432
 433     if ( ( ERROR_SUCCESS == MsiGetFeatureState( handle, L"gm_p_Calc", &current_state, &future_state ) ) &&
 434          ( (future_state == INSTALLSTATE_LOCAL) || ((current_state == INSTALLSTATE_LOCAL) && (future_state == INSTALLSTATE_UNKNOWN) ) ) )
 435         bCalcEnabled = true;
 436
 437     OutputDebugStringFormat( "LookForRegisteredExtensions: Install state Calc is [%d], will be [%d]", current_state, future_state );
 438     if ( bCalcEnabled )
 439         OutputDebugStringFormat( "LookForRegisteredExtensions: Calc is enabled" );
 440     else
 441         OutputDebugStringFormat( "LookForRegisteredExtensions: Calc is NOT enabled" );
 442
 443     if ( ( ERROR_SUCCESS == MsiGetFeatureState( handle, L"gm_p_Impress", &current_state, &future_state ) ) &&
 444          ( (future_state == INSTALLSTATE_LOCAL) || ((current_state == INSTALLSTATE_LOCAL) && (future_state == INSTALLSTATE_UNKNOWN) ) ) )
 445         bImpressEnabled = true;
 446
 447     OutputDebugStringFormat( "LookForRegisteredExtensions: Install state Impress is [%d], will be [%d]", current_state, future_state );
 448     if ( bImpressEnabled )
 449         OutputDebugStringFormat( "LookForRegisteredExtensions: Impress is enabled" );
 450     else
 451         OutputDebugStringFormat( "LookForRegisteredExtensions: Impress is NOT enabled" );
 452
 453     if ( ( ERROR_SUCCESS == MsiGetFeatureState( handle, L"gm_p_Draw", &current_state, &future_state ) ) &&
 454          ( (future_state == INSTALLSTATE_LOCAL) || ((current_state == INSTALLSTATE_LOCAL) && (future_state == INSTALLSTATE_UNKNOWN) ) ) )
 455         bDrawEnabled = true;
 456
 457     OutputDebugStringFormat( "LookForRegisteredExtensions: Install state Draw is [%d], will be [%d]", current_state, future_state );
 458     if ( bImpressEnabled )
 459         OutputDebugStringFormat( "LookForRegisteredExtensions: Draw is enabled" );
 460     else
 461         OutputDebugStringFormat( "LookForRegisteredExtensions: Draw is NOT enabled" );
 462
 463     MsiSetPropertyA( handle, "SELECT_WORD", "" );
 464     MsiSetPropertyA( handle, "SELECT_EXCEL", "" );
 465     MsiSetPropertyA( handle, "SELECT_POWERPOINT", "" );
 466     MsiSetPropertyA( handle, "SELECT_VISIO", "" );
 467
 468     if ( ! bRegisterNone )
 469     {
 470         if ( IsSetMsiProp( handle, "REGISTER_ALL_MSO_TYPES" ) )
 471         {
 472             if ( bWriterEnabled )
 473                 MsiSetPropertyA( handle, "SELECT_WORD", "1" );
 474             if ( bCalcEnabled )
 475                 MsiSetPropertyA( handle, "SELECT_EXCEL", "1" );
 476             if ( bImpressEnabled )
 477                 MsiSetPropertyA( handle, "SELECT_POWERPOINT", "1" );
 478             if ( bDrawEnabled )
 479                 MsiSetPropertyA( handle, "SELECT_VISIO", "1" );
 480         }
 481         else
 482         {
 483             if ( bWriterEnabled && ! checkSomeExtensionInRegistry( WORD_START, EXCEL_START ) )
 484             {
 485                 MsiSetPropertyA( handle, "SELECT_WORD", "1" );
 486                 OutputDebugStringFormat( "LookForRegisteredExtensions: Register for Microsoft Word" );
 487             }
 488             if ( bCalcEnabled && ! checkSomeExtensionInRegistry( EXCEL_START, POWERPOINT_START ) )
 489             {
 490                 MsiSetPropertyA( handle, "SELECT_EXCEL", "1" );
 491                 OutputDebugStringFormat( "LookForRegisteredExtensions: Register for Microsoft Excel" );
 492             }
 493             if ( bImpressEnabled && ! checkSomeExtensionInRegistry( POWERPOINT_START, VISIO_START ) )
 494             {
 495                 MsiSetPropertyA( handle, "SELECT_POWERPOINT", "1" );
 496                 OutputDebugStringFormat( "LookForRegisteredExtensions: Register for Microsoft PowerPoint" );
 497             }
 498             if ( bImpressEnabled && ! checkSomeExtensionInRegistry( VISIO_START, VISIO_END ) )
 499             {
 500                 MsiSetPropertyA( handle, "SELECT_VISIO", "1" );
 501                 OutputDebugStringFormat( "LookForRegisteredExtensions: Register for Microsoft Visio" );
 502             }
 503         }
 504     }
 505
 506     MsiSetPropertyA( handle, "FILETYPEDIALOGUSED", "1" );
 507
 508     return ERROR_SUCCESS;
 509 }
 510
 511 //----------------------------------------------------------
 512 extern "C" UINT __stdcall RegisterSomeExtensions( MSIHANDLE handle )
 513 {
 514     OutputDebugStringFormat( "RegisterSomeExtensions: " );
 515
 516     if ( IsSetMsiProp( handle, "SELECT_WORD" ) )
 517     {
 518         registerSomeExtensions( handle, WORD_START, EXCEL_START, true );
 519         MsiSetFeatureState( handle, L"gm_p_Wrt_MSO_Reg", INSTALLSTATE_LOCAL );
 520         OutputDebugStringFormat( "RegisterSomeExtensions: Register for Microsoft Word" );
 521     }
 522     else
 523     {
 524         registerSomeExtensions( handle, WORD_START, EXCEL_START, false );
 525         MsiSetFeatureState( handle, L"gm_p_Wrt_MSO_Reg", INSTALLSTATE_ABSENT );
 526     }
 527
 528     if ( IsSetMsiProp( handle, "SELECT_EXCEL" ) )
 529     {
 530         registerSomeExtensions( handle, EXCEL_START, POWERPOINT_START, true );
 531         MsiSetFeatureState( handle, L"gm_p_Calc_MSO_Reg", INSTALLSTATE_LOCAL );
 532         OutputDebugStringFormat( "RegisterSomeExtensions: Register for Microsoft Excel" );
 533     }
 534     else
 535     {
 536         registerSomeExtensions( handle, EXCEL_START, POWERPOINT_START, false );
 537         MsiSetFeatureState( handle, L"gm_p_Calc_MSO_Reg", INSTALLSTATE_ABSENT );
 538     }
 539
 540     if ( IsSetMsiProp( handle, "SELECT_POWERPOINT" ) )
 541     {
 542         registerSomeExtensions( handle, POWERPOINT_START, VISIO_START, true );
 543         MsiSetFeatureState( handle, L"gm_p_Impress_MSO_Reg", INSTALLSTATE_LOCAL );
 544         OutputDebugStringFormat( "RegisterSomeExtensions: Register for Microsoft PowerPoint" );
 545     }
 546     else
 547     {
 548         registerSomeExtensions( handle, POWERPOINT_START, VISIO_START, false );
 549         MsiSetFeatureState( handle, L"gm_p_Impress_MSO_Reg", INSTALLSTATE_ABSENT );
 550     }
 551
 552     if ( IsSetMsiProp( handle, "SELECT_VISIO" ) )
 553     {
 554         registerSomeExtensions( handle, VISIO_START, VISIO_END, true );
 555         MsiSetFeatureState( handle, L"gm_p_Draw_MSO_Reg", INSTALLSTATE_LOCAL );
 556         OutputDebugStringFormat( "RegisterSomeExtensions: Register for Microsoft Visio" );
 557     }
 558     else
 559     {
 560         registerSomeExtensions( handle, VISIO_START, VISIO_END, false );
 561         MsiSetFeatureState( handle, L"gm_p_Draw_MSO_Reg", INSTALLSTATE_ABSENT );
 562     }
 563     return ERROR_SUCCESS;
 564 }
 565
 566 //----------------------------------------------------------
 567 //
 568 // This is the (slightly misleadinly named) entry point for the
 569 // custom action called Regallmsdocdll.
 570 //
 571 extern "C" UINT __stdcall FindRegisteredExtensions( MSIHANDLE handle )
 572 {
 573     if ( IsSetMsiProp( handle, "FILETYPEDIALOGUSED" ) )
 574     {
 575         OutputDebugStringFormat( "FindRegisteredExtensions: FILETYPEDIALOGUSED!" );
 576         return ERROR_SUCCESS;
 577     }
 578
 579     OutputDebugStringFormat( "FindRegisteredExtensions:" );
 580
 581     bool bRegisterAll = IsSetMsiProp( handle, "REGISTER_ALL_MSO_TYPES" );
 582
 583     if ( IsSetMsiProp( handle, "REGISTER_NO_MSO_TYPES" ) )
 584     {
 585         OutputDebugStringFormat( "FindRegisteredExtensions: Register none!" );
 586         return ERROR_SUCCESS;
 587     }
 588     else if ( bRegisterAll )
 589         OutputDebugStringFormat( "FindRegisteredExtensions: Force all on" );
 590     else
 591         OutputDebugStringFormat( "FindRegisteredExtensions: " );
 592
 593     // setting the msi properties SELECT_* will force registering for all corresponding
 594     // file types
 595     if ( IsSetMsiProp( handle, "SELECT_WORD" ) )
 596         registerSomeExtensions( handle, WORD_START, EXCEL_START, true );
 597     if ( IsSetMsiProp( handle, "SELECT_EXCEL" ) )
 598         registerSomeExtensions( handle, EXCEL_START, POWERPOINT_START, true );
 599     if ( IsSetMsiProp( handle, "SELECT_POWERPOINT" ) )
 600         registerSomeExtensions( handle, POWERPOINT_START, VISIO_START, true );
 601     if ( IsSetMsiProp( handle, "SELECT_VISIO" ) )
 602         registerSomeExtensions( handle, VISIO_START, VISIO_END, true );
 603
 604     registerForExtensions( handle, bRegisterAll );
 605
 606     return ERROR_SUCCESS;
 607 }
 608
 609 #if 0
 610
 611 //----------------------------------------------------------
 612 //
 613 // This entry is not called for any custom action.
 614 //
 615 extern "C" UINT __stdcall DeleteRegisteredExtensions( MSIHANDLE /*handle*/ )
 616 {
 617     OutputDebugStringFormat( "DeleteRegisteredExtensions\n" );
 618
 619     // remove all file extensions
 620     int nIndex = 0;
 621     while ( g_Extensions[nIndex] != 0 )
 622     {
 623         RemoveExtensionInRegistry( g_Extensions[nIndex] );
 624         ++nIndex;
 625     }
 626
 627     return ERROR_SUCCESS;
 628 }
 629
 630 #endif
 631
 632 //----------------------------------------------------------
 633 static void restoreOldRegistration( LPCSTR lpSubKey )
 634 {
 635     BOOL    bRet = false;
 636     HKEY    hKey = NULL;
 637     LONG    lResult = RegOpenKeyExA( HKEY_CLASSES_ROOT, lpSubKey, 0,
 638                                      KEY_QUERY_VALUE|KEY_SET_VALUE, &hKey );
 639
 640     if ( ERROR_SUCCESS == lResult )
 641     {
 642         CHAR    szBuffer[1024];
 643         DWORD   nSize = sizeof( szBuffer );
 644
 645         lResult = RegQueryValueExA( hKey, "LOBackupAssociation", NULL, NULL,
 646                                     (LPBYTE)szBuffer, &nSize );
 647         if ( ERROR_SUCCESS == lResult )
 648         {
 649             HKEY hKey2 = NULL;
 650             lResult = RegOpenKeyExA( HKEY_CLASSES_ROOT, szBuffer, 0,
 651                                      KEY_QUERY_VALUE, &hKey2 );
 652             if ( ERROR_SUCCESS == lResult )
 653             {
 654                 CHAR   szBuffer2[1024];
 655                 DWORD  nSize2 = sizeof( szBuffer2 );
 656
 657                 lResult = RegQueryValueExA( hKey2, "", NULL, NULL, (LPBYTE)szBuffer2, &nSize2 );
 658                 if ( ERROR_SUCCESS == lResult )
 659                 {
 660                     CHAR   szBuffer3[1024];
 661                     DWORD  nSize3 = sizeof( szBuffer3 );
 662
 663                     // Try to verify that the old association is OK to restore
 664                     lResult = RegQueryValueExA( hKey, "LOBackupAssociationDeref", NULL, NULL,
 665                                                 (LPBYTE)szBuffer3, &nSize3 );
 666                     if ( ERROR_SUCCESS == lResult )
 667                     {
 668                         if ( nSize2 == nSize3 && strcmp (szBuffer2, szBuffer3) == 0)
 669                         {
 670                             // Yep. So restore it
 671                             RegSetValueExA( hKey, "", 0, REG_SZ, (LPBYTE)szBuffer, nSize );
 672                         }
 673                     }
 674                 }
 675                 RegCloseKey( hKey2 );
 676             }
 677             RegDeleteValueA( hKey, "LOBackupAssociation" );
 678         }
 679         RegDeleteValueA( hKey, "LOBackupAssociationDeref" );
 680         RegCloseKey( hKey );
 681     }
 682 }
 683
 684 //----------------------------------------------------------
 685 //
 686 // This function is not in OO.o. We call this from the
 687 // Restoreregallmsdocdll custom action.
 688 //
 689 extern "C" UINT __stdcall RestoreRegAllMSDoc( MSIHANDLE /*handle*/ )
 690 {
 691     OutputDebugStringFormat( "RestoreRegAllMSDoc\n" );
 692
 693     int nIndex = 0;
 694     while ( g_Extensions[nIndex] != 0 )
 695     {
 696         restoreOldRegistration( g_Extensions[nIndex] );
 697         ++nIndex;
 698     }
 699
 700
 701     return ERROR_SUCCESS;
 702 }
 703
 704 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */