setup_native/source/win32/customactions/reg4msdoc/registrar.cxx

   1 // Registrar.cpp: Implementierung der Klasse Registrar.
   2 //
   3 //////////////////////////////////////////////////////////////////////
   4
   5 #include "registrar.hxx"
   6
   7 #ifndef _REGISTRYVALUEIMPL_HXX_
   8 #include "RegistryValueImpl.hxx"
   9 #endif
  10 #include "windowsregistry.hxx"
  11 #include "registryexception.hxx"
  12
  13 #include <assert.h>
  14 #ifdef _MSC_VER
  15 #pragma warning(disable: 4350 4482)
  16 #include "strsafe.h"
  17 #endif
  18
  19 //----------------------------------------------------------
  20 #ifdef DEBUG
  21 inline void OutputDebugStringFormat( LPCTSTR pFormat, ... )
  22 {
  23     TCHAR    buffer[1024];
  24     va_list  args;
  25
  26     va_start( args, pFormat );
  27     StringCchVPrintf( buffer, sizeof(buffer), pFormat, args );
  28     OutputDebugString( buffer );
  29 }
  30 #else
  31 static inline void OutputDebugStringFormat( LPCTSTR, ... )
  32 {
  33 }
  34 #endif
  35 //----------------------------------------------------------
  36
  37 const int MSWORD                     = 0x1;
  38 const int MSEXCEL                    = 0x2;
  39 const int MSPOWERPOINT               = 0x4;
  40 const int DEFAULT_HTML_EDITOR_FOR_IE = 0x8;
  41 const int HTML_EDITOR                            = 0x10;
  42 const int DEFAULT_SHELL_HTML_EDITOR  = 0x20;
  43
  44 namespace /* private */
  45 {
  46     const std::wstring HTM_OPENWITHLIST = L".htm\\OpenWithList";
  47     const std::wstring APPLICATIONS = L"Applications";
  48     const std::wstring SHELL_EDIT_COMMAND = L"shell\\edit\\command";
  49     const std::wstring HTML_EDIT = L"HTML Edit";
  50     const std::wstring HTML_EDIT_DISPLAY_NAME = L"Edit Display Name";
  51     const std::wstring SHELL_EDIT_COMMAND_BACKUP = L"Shell Edit Cmd";
  52     const std::wstring DEFAULT_HTML_EDITOR = L"Default HTML Editor";
  53     const std::wstring MS_IE_DEF_HTML_EDITOR = L"Software\\Microsoft\\Internet Explorer\\Default HTML Editor";
  54     const std::wstring MS_IE_DEF_HTML_EDITOR_SHL_EDIT_CMD = L"Software\\Microsoft\\Internet Explorer\\Default HTML Editor\\shell\\edit\\command";
  55 }
  56
  57 Registrar::Registrar(const RegistrationContextInformation& RegContext) :
  58     m_ContextInformation(RegContext),
  59     FORWARD_KEY_PREFIX(L"OpenOffice.org"),//FORWARD_KEY_PREFIX(L"soffice6"),
  60     DEFAULT_VALUE_NAME(L""),
  61     BACKUP_VALUE_NAME(L"Backup"),
  62     PRIVATE_BACKUP_KEY_NAME(L"OpenOffice.org.reg4msdocmsi"),//PRIVATE_BACKUP_KEY_NAME(L"soffice6.bak"),
  63     REGISTRATION_STATE(L"Reg4MsDocState")
  64 {
  65     m_RootKey = WindowsRegistry().GetClassesRootKey();
  66 }
  67
  68 Registrar::~Registrar()
  69 {
  70 }
  71
  72 void Registrar::RegisterForMsWord() const
  73 {
  74     assert(m_RootKey.get());
  75
  76     RegisterForMsOfficeApplication(
  77         m_ContextInformation.GetWordDocumentFileExtension(),
  78         m_ContextInformation.GetWordDocumentDisplayName(),
  79         m_ContextInformation.GetWordDocumentDefaultIconEntry(),
  80         m_ContextInformation.GetWordDocumentDefaultShellCommand(),
  81         m_ContextInformation.ShellNewCommandDisplayName(),
  82         RegistrationContextInformation::Writer);
  83
  84     RegisterForMsOfficeApplication(
  85         m_ContextInformation.GetMOOXWordDocumentFileExtension(),
  86         m_ContextInformation.GetMOOXWordDocumentDisplayName(),
  87         m_ContextInformation.GetWordDocumentDefaultIconEntry(),
  88         m_ContextInformation.GetWordDocumentDefaultShellCommand(),
  89         m_ContextInformation.ShellNewCommandDisplayName(),
  90         RegistrationContextInformation::Writer);
  91
  92     RegisterForMsOfficeApplication(
  93         m_ContextInformation.GetWordTemplateFileExtension(),
  94         m_ContextInformation.GetWordTemplateDisplayName(),
  95         m_ContextInformation.GetWordTemplateDefaultIconEntry(),
  96         m_ContextInformation.GetWordTemplateDefaultShellCommand(),
  97         m_ContextInformation.ShellNewCommandDisplayName(),
  98         RegistrationContextInformation::Writer);
  99
 100     RegisterForMsOfficeApplication(
 101         m_ContextInformation.GetRtfDocumentFileExtension(),
 102         m_ContextInformation.GetRtfDocumentDisplayName(),
 103         m_ContextInformation.GetRtfDocumentDefaultIconEntry(),
 104         m_ContextInformation.GetRtfDocumentDefaultShellCommand(),
 105         m_ContextInformation.ShellNewCommandDisplayName(),
 106         RegistrationContextInformation::Writer);
 107
 108     SaveRegisteredFor(MSWORD);
 109 }
 110
 111 void Registrar::UnregisterForMsWord() const
 112 {
 113     assert(m_RootKey.get());
 114
 115     try
 116     {
 117         UnregisterForMsOfficeApplication(
 118             m_ContextInformation.GetWordDocumentFileExtension());
 119     }
 120     catch(RegistryKeyNotFoundException&)
 121     {}
 122
 123         try
 124         {
 125                 UnregisterForMsOfficeApplication(
 126                         m_ContextInformation.GetMOOXWordDocumentFileExtension());
 127         }
 128         catch(RegistryKeyNotFoundException&)
 129         {}
 130
 131     try
 132     {
 133         UnregisterForMsOfficeApplication(
 134             m_ContextInformation.GetWordTemplateFileExtension());
 135     }
 136     catch(RegistryKeyNotFoundException&)
 137     {}
 138
 139     try
 140     {
 141         UnregisterForMsOfficeApplication(
 142             m_ContextInformation.GetRtfDocumentFileExtension());
 143     }
 144     catch(RegistryKeyNotFoundException&)
 145     {}
 146
 147     SaveNotRegisteredFor(MSWORD);
 148 }
 149
 150 bool Registrar::QueryPreselectForMsApplication(const std::wstring& file_extension) const
 151 {
 152     bool preselect = false;
 153
 154     // We use HKCR else we would not see that a registration for
 155     // MS Office applications already exist if we are about to
 156     // register in HKCU\Software\Classes
 157     RegistryKey root_key = WindowsRegistry().GetClassesRootKey();
 158
 159     if (!root_key->HasSubKey(file_extension))
 160     {
 161         preselect = true;
 162         OutputDebugStringFormat( TEXT("QueryPreselect: No SubKey found for (%s), preselected!\n"), file_extension.c_str() );
 163     }
 164     else
 165     {
 166         RegistryKey RegKey = root_key->OpenSubKey(file_extension, false);
 167
 168         if (RegKey->HasValue(DEFAULT_VALUE_NAME))
 169         {
 170             RegistryValue RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
 171
 172             if (REG_SZ == RegVal->GetType() &&
 173                 IsOpenOfficeRegisteredForMsApplication(RegVal->GetDataAsUniString()))
 174             {
 175                 preselect = true;
 176                 OutputDebugStringFormat( TEXT("QueryPreselect: (%s) registered to Office, preselected!\n"), file_extension.c_str() );
 177             }
 178             else if ( (REG_SZ == RegVal->GetType()) && ! root_key->HasSubKey( RegVal->GetDataAsUniString() ) )
 179             {
 180                 preselect = true;
 181                 OutputDebugStringFormat( TEXT("QueryPreselect: (%s) registered but destination is empty, preselected!\n"), file_extension.c_str() );
 182             }
 183         }
 184         else
 185         {
 186             preselect = true;
 187             OutputDebugStringFormat( TEXT("QueryPreselect: No default found for SubKey (%s), preselected!\n"), file_extension.c_str() );
 188         }
 189     }
 190     return preselect;
 191 }
 192
 193 bool Registrar::QueryPreselectMsWordRegistration() const
 194 {
 195     return QueryPreselectForMsApplication(
 196         m_ContextInformation.GetWordDocumentFileExtension());
 197 }
 198
 199 void Registrar::RegisterForMsExcel() const
 200 {
 201     assert(m_RootKey.get());
 202
 203     RegisterForMsOfficeApplication(
 204         m_ContextInformation.GetExcelSheetFileExtension(),
 205         m_ContextInformation.GetExcelSheetDisplayName(),
 206         m_ContextInformation.GetExcelSheetDefaultIconEntry(),
 207         m_ContextInformation.GetExcelSheetDefaultShellCommand(),
 208         m_ContextInformation.ShellNewCommandDisplayName(),
 209         RegistrationContextInformation::Calc);
 210
 211     RegisterForMsOfficeApplication(
 212         m_ContextInformation.GetMOOXExcelSheetFileExtension(),
 213         m_ContextInformation.GetMOOXExcelSheetDisplayName(),
 214         m_ContextInformation.GetExcelSheetDefaultIconEntry(),
 215         m_ContextInformation.GetExcelSheetDefaultShellCommand(),
 216         m_ContextInformation.ShellNewCommandDisplayName(),
 217         RegistrationContextInformation::Calc);
 218
 219     RegisterForMsOfficeApplication(
 220         m_ContextInformation.GetExcelTemplateFileExtension(),
 221         m_ContextInformation.GetExcelTemplateDisplayName(),
 222         m_ContextInformation.GetExcelTemplateDefaultIconEntry(),
 223         m_ContextInformation.GetExcelTemplateDefaultShellCommand(),
 224         m_ContextInformation.ShellNewCommandDisplayName(),
 225         RegistrationContextInformation::Calc);
 226
 227     SaveRegisteredFor(MSEXCEL);
 228 }
 229
 230 void Registrar::UnregisterForMsExcel() const
 231 {
 232     assert(m_RootKey.get());
 233
 234     try
 235     {
 236         UnregisterForMsOfficeApplication(
 237             m_ContextInformation.GetExcelSheetFileExtension());
 238     }
 239     catch(RegistryKeyNotFoundException&)
 240     {}
 241
 242         try
 243         {
 244                 UnregisterForMsOfficeApplication(
 245                         m_ContextInformation.GetMOOXExcelSheetFileExtension());
 246         }
 247         catch(RegistryKeyNotFoundException&)
 248         {}
 249
 250     try
 251     {
 252         UnregisterForMsOfficeApplication(
 253             m_ContextInformation.GetExcelTemplateFileExtension());
 254     }
 255     catch(RegistryKeyNotFoundException&)
 256     {}
 257
 258     SaveNotRegisteredFor(MSEXCEL);
 259 }
 260
 261 bool Registrar::QueryPreselectMsExcelRegistration() const
 262 {
 263     return QueryPreselectForMsApplication(
 264         m_ContextInformation.GetExcelSheetFileExtension());
 265 }
 266
 267 void Registrar::RegisterForMsPowerPoint() const
 268 {
 269     assert(m_RootKey.get());
 270
 271     RegisterForMsOfficeApplication(
 272         m_ContextInformation.GetPowerPointDocumentFileExtension(),
 273         m_ContextInformation.GetPowerPointDocumentDisplayName(),
 274         m_ContextInformation.GetPowerPointDocumentDefaultIconEntry(),
 275         m_ContextInformation.GetPowerPointDocumentDefaultShellCommand(),
 276         m_ContextInformation.ShellNewCommandDisplayName(),
 277         RegistrationContextInformation::Impress);
 278
 279     RegisterForMsOfficeApplication(
 280         m_ContextInformation.GetMOOXPowerPointDocumentFileExtension(),
 281         m_ContextInformation.GetMOOXPowerPointDocumentDisplayName(),
 282         m_ContextInformation.GetPowerPointDocumentDefaultIconEntry(),
 283         m_ContextInformation.GetPowerPointDocumentDefaultShellCommand(),
 284         m_ContextInformation.ShellNewCommandDisplayName(),
 285         RegistrationContextInformation::Impress);
 286
 287     RegisterForMsOfficeApplication(
 288         m_ContextInformation.GetPowerPointShowFileExtension(),
 289         m_ContextInformation.GetPowerPointShowDisplayName(),
 290         m_ContextInformation.GetPowerPointShowDefaultIconEntry(),
 291         m_ContextInformation.GetPowerPointShowDefaultShellCommand(),
 292         m_ContextInformation.ShellNewCommandDisplayName(),
 293         RegistrationContextInformation::Impress);
 294
 295     RegisterForMsOfficeApplication(
 296         m_ContextInformation.GetPowerPointTemplateFileExtension(),
 297         m_ContextInformation.GetPowerPointTemplateDisplayName(),
 298         m_ContextInformation.GetPowerPointTemplateDefaultIconEntry(),
 299         m_ContextInformation.GetPowerPointTemplateDefaultShellCommand(),
 300         m_ContextInformation.ShellNewCommandDisplayName(),
 301         RegistrationContextInformation::Impress);
 302
 303     SaveRegisteredFor(MSPOWERPOINT);
 304 }
 305
 306 void Registrar::UnregisterForMsPowerPoint() const
 307 {
 308     assert(m_RootKey.get());
 309
 310     try
 311     {
 312         UnregisterForMsOfficeApplication(
 313             m_ContextInformation.GetPowerPointDocumentFileExtension());
 314     }
 315     catch(RegistryKeyNotFoundException&)
 316     {}
 317
 318         try
 319         {
 320                 UnregisterForMsOfficeApplication(
 321                         m_ContextInformation.GetMOOXPowerPointDocumentFileExtension());
 322         }
 323         catch(RegistryKeyNotFoundException&)
 324         {}
 325
 326     try
 327     {
 328         UnregisterForMsOfficeApplication(
 329             m_ContextInformation.GetPowerPointShowFileExtension());
 330     }
 331     catch(RegistryKeyNotFoundException&)
 332     {}
 333
 334     try
 335     {
 336         UnregisterForMsOfficeApplication(
 337             m_ContextInformation.GetPowerPointTemplateFileExtension());
 338     }
 339     catch(RegistryKeyNotFoundException&)
 340     {}
 341
 342     SaveNotRegisteredFor(MSPOWERPOINT);
 343 }
 344
 345 //-----------------------------------------
 346 /*
 347 */
 348 bool Registrar::QueryPreselectMsPowerPointRegistration() const
 349 {
 350     return QueryPreselectForMsApplication( m_ContextInformation.GetPowerPointDocumentFileExtension()) &&
 351            QueryPreselectForMsApplication( m_ContextInformation.GetPowerPointShowFileExtension());
 352 }
 353
 354 //-----------------------------------------
 355 /** The documentation says we have to
 356       make the following entries to register
 357       a html editor for the Internet Explorer
 358       HKCR\.htm\OpenWithList\App Friendly Name\shell\edit\command
 359       But the reality shows that this works only
 360       with Internet Explorer 5.x
 361       Internet Explorer 6.0 wants the follwoing
 362       entries:
 363       HKCR\.htm\OpenWithList\App.exe
 364       HKCR\Applications\App.ex\shell\edit\command
 365 */
 366 void Registrar::RegisterAsHtmlEditorForInternetExplorer() const
 367 {
 368     assert(m_RootKey.get());
 369
 370     std::wstring OOFriendlyAppName = m_ContextInformation.GetOpenOfficeFriendlyAppName();
 371
 372     std::wstring RegKeyName = HTM_OPENWITHLIST + std::wstring(L"\\") + OOFriendlyAppName;
 373     RegistryKey RegKey = m_RootKey->CreateSubKey(RegKeyName);
 374
 375     RegKey = RegKey->CreateSubKey(SHELL_EDIT_COMMAND);
 376
 377     RegistryValue RegVal(
 378         new RegistryValueImpl(
 379             DEFAULT_VALUE_NAME,
 380             m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::Open,
 381                                                           RegistrationContextInformation::Writer)));
 382
 383     RegKey->SetValue(RegVal);
 384
 385     RegKeyName = APPLICATIONS + std::wstring(L"\\") + OOFriendlyAppName;
 386     RegKey = m_RootKey->CreateSubKey(RegKeyName);
 387
 388     RegVal->SetName(L"FriendlyAppName");
 389     RegVal->SetValue(OOFriendlyAppName);
 390     RegKey->SetValue(RegVal);
 391
 392     RegKey = RegKey->CreateSubKey(SHELL_EDIT_COMMAND);
 393     RegVal->SetName(DEFAULT_VALUE_NAME);
 394     RegVal->SetValue(
 395         m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::Open,
 396                                                       RegistrationContextInformation::Writer));
 397     RegKey->SetValue(RegVal);
 398
 399     SaveRegisteredFor(HTML_EDITOR);
 400 }
 401
 402 void Registrar::UnregisterAsHtmlEditorForInternetExplorer() const
 403 {
 404     assert(m_RootKey.get());
 405
 406     try
 407     {
 408         std::wstring OOFriendlyAppName = m_ContextInformation.GetOpenOfficeFriendlyAppName();
 409
 410         RegistryKey aRegKey = m_RootKey->OpenSubKey( APPLICATIONS );
 411         if ( aRegKey->HasSubKey( OOFriendlyAppName ) )
 412             aRegKey->DeleteSubKeyTree( OOFriendlyAppName );
 413
 414         aRegKey = m_RootKey->OpenSubKey( HTM_OPENWITHLIST );
 415         if ( aRegKey->HasSubKey( OOFriendlyAppName ) )
 416             aRegKey->DeleteSubKeyTree( OOFriendlyAppName );
 417     }
 418     catch(RegistryKeyNotFoundException&)
 419     {}
 420
 421     SaveNotRegisteredFor(HTML_EDITOR);
 422 }
 423
 424 void Registrar::RegisterAsDefaultHtmlEditorForInternetExplorer() const
 425 {
 426     assert(m_RootKey.get());
 427
 428     RegistryKey RegistrationRootKey = GetRootKeyForDefHtmlEditorForIERegistration();
 429
 430     RegistryKey RegKey = RegistrationRootKey->CreateSubKey(MS_IE_DEF_HTML_EDITOR_SHL_EDIT_CMD);
 431
 432     RegistryValue RegVal = RegistryValue(new RegistryValueImpl(DEFAULT_VALUE_NAME, L""));
 433
 434     if (RegKey->HasValue(DEFAULT_VALUE_NAME))
 435     {
 436         RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
 437
 438         std::wstring CmdLine = RegVal->GetDataAsUniString();
 439
 440         if (std::wstring::npos == CmdLine.find(m_ContextInformation.GetOpenOfficeExecutableName()))
 441         {
 442             RegistryKey BackupRegKey = m_RootKey->CreateSubKey(PRIVATE_BACKUP_KEY_NAME + L"\\" + DEFAULT_HTML_EDITOR);
 443
 444             if (RegKey->HasValue(DEFAULT_VALUE_NAME))
 445                 BackupRegKey->CopyValue(RegKey, DEFAULT_VALUE_NAME);
 446
 447             RegKey = RegistrationRootKey->OpenSubKey(MS_IE_DEF_HTML_EDITOR);
 448             if (RegKey->HasValue(L"Description"))
 449                 BackupRegKey->CopyValue(RegKey, L"Description");
 450         }
 451     }
 452
 453     RegVal->SetValue(
 454         m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::Open,
 455                                                       RegistrationContextInformation::Writer));
 456     RegKey = RegistrationRootKey->OpenSubKey(MS_IE_DEF_HTML_EDITOR_SHL_EDIT_CMD);
 457     RegKey->SetValue(RegVal);
 458
 459     RegVal->SetName(L"Description");
 460     RegVal->SetValue(m_ContextInformation.GetOpenOfficeFriendlyAppName());
 461     RegKey = RegistrationRootKey->OpenSubKey(MS_IE_DEF_HTML_EDITOR);
 462     RegKey->SetValue(RegVal);
 463
 464     SaveRegisteredFor(DEFAULT_HTML_EDITOR_FOR_IE);
 465 }
 466
 467 void Registrar::UnregisterAsDefaultHtmlEditorForInternetExplorer() const
 468 {
 469     assert(m_RootKey.get());
 470
 471     RegistryKey RegistrationRootKey = GetRootKeyForDefHtmlEditorForIERegistration();
 472
 473     RegistryKey RegKey = RegistrationRootKey->OpenSubKey(MS_IE_DEF_HTML_EDITOR_SHL_EDIT_CMD);
 474
 475     if (RegKey->HasValue(DEFAULT_VALUE_NAME))
 476     {
 477         RegistryValue RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
 478
 479         std::wstring CmdLine = RegVal->GetDataAsUniString();
 480
 481         if (std::wstring::npos != CmdLine.find(m_ContextInformation.GetOpenOfficeExecutableName()))
 482         {
 483             RegistryKey BackupRegKey = m_RootKey->OpenSubKey(PRIVATE_BACKUP_KEY_NAME);
 484
 485             if (BackupRegKey->HasSubKey(DEFAULT_HTML_EDITOR))
 486             {
 487                 BackupRegKey = BackupRegKey->OpenSubKey(DEFAULT_HTML_EDITOR);
 488
 489                 if (BackupRegKey->HasValue(DEFAULT_VALUE_NAME))
 490                     RegKey->CopyValue(BackupRegKey, DEFAULT_VALUE_NAME);
 491                 else
 492                     RegKey->DeleteValue(DEFAULT_VALUE_NAME);
 493
 494                 RegKey = RegistrationRootKey->OpenSubKey(MS_IE_DEF_HTML_EDITOR);
 495
 496                 if (BackupRegKey->HasValue(L"Description"))
 497                     RegKey->CopyValue(BackupRegKey, L"Description");
 498                 else
 499                     RegKey->DeleteValue(L"Description");
 500             }
 501             else
 502             {
 503                 RegKey->DeleteValue(DEFAULT_VALUE_NAME);
 504                 RegKey = RegistrationRootKey->OpenSubKey(MS_IE_DEF_HTML_EDITOR);
 505                 RegKey->DeleteValue(L"Description");
 506             }
 507         }
 508     }
 509
 510     SaveNotRegisteredFor(DEFAULT_HTML_EDITOR_FOR_IE);
 511 }
 512
 513 void Registrar::RegisterAsDefaultShellHtmlEditor() const
 514 {
 515     assert(m_RootKey.get());
 516
 517     RegistryKey RegKey = m_RootKey->CreateSubKey(L".htm");
 518
 519     RegistryValue RegVal = RegistryValue(
 520         new RegistryValueImpl(DEFAULT_VALUE_NAME, L""));
 521
 522     if (RegKey->HasValue(DEFAULT_VALUE_NAME))
 523         RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
 524
 525     std::wstring HtmFwdKey = RegVal->GetDataAsUniString();
 526     if (0 == HtmFwdKey.length() || !m_RootKey->HasSubKey(HtmFwdKey))
 527         HtmFwdKey = L".htm";
 528
 529     RegKey = m_RootKey->CreateSubKey(HtmFwdKey + L"\\" + SHELL_EDIT_COMMAND);
 530
 531     if (RegKey->HasValue(DEFAULT_VALUE_NAME))
 532     {
 533         RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
 534
 535         std::wstring CmdLine = RegVal->GetDataAsUniString();
 536
 537         // backup old values if we are not in place
 538         if (std::wstring::npos == CmdLine.find(m_ContextInformation.GetOpenOfficeExecutableName()))
 539         {
 540             RegistryKey BackupRegKey = m_RootKey->CreateSubKey(PRIVATE_BACKUP_KEY_NAME + L"\\" + HTML_EDIT);
 541             BackupRegKey->CopyValue(RegKey, DEFAULT_VALUE_NAME, SHELL_EDIT_COMMAND_BACKUP);
 542         }
 543     }
 544
 545     RegVal->SetValue(
 546         m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::Open,
 547                                                       RegistrationContextInformation::Writer));
 548
 549     RegKey->SetValue(RegVal);
 550
 551     SaveRegisteredFor(DEFAULT_SHELL_HTML_EDITOR);
 552 }
 553
 554 void Registrar::UnregisterAsDefaultShellHtmlEditor() const
 555 {
 556     assert(m_RootKey.get());
 557
 558     try
 559     {
 560         RegistryKey RegKey = m_RootKey->OpenSubKey(L".htm");
 561
 562         RegistryValue RegVal = RegistryValue(
 563             new RegistryValueImpl(DEFAULT_VALUE_NAME, L""));
 564
 565         if (RegKey->HasValue(DEFAULT_VALUE_NAME))
 566             RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
 567
 568         std::wstring HtmFwdKey = RegVal->GetDataAsUniString();
 569
 570         if (0 == HtmFwdKey.length() || !m_RootKey->HasSubKey(HtmFwdKey))
 571             HtmFwdKey = L".htm";
 572
 573         RegKey = m_RootKey->OpenSubKey(HtmFwdKey + L"\\" + SHELL_EDIT_COMMAND);
 574
 575         RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
 576
 577         std::wstring CmdLine = RegVal->GetDataAsUniString();
 578
 579         if (std::wstring::npos != CmdLine.find(m_ContextInformation.GetOpenOfficeExecutableName()))
 580         {
 581             RegistryKey BackupRegKey = m_RootKey->CreateSubKey(PRIVATE_BACKUP_KEY_NAME + L"\\" + HTML_EDIT);
 582
 583             if (BackupRegKey->HasValue(SHELL_EDIT_COMMAND_BACKUP))
 584                 RegKey->CopyValue(BackupRegKey, SHELL_EDIT_COMMAND_BACKUP, DEFAULT_VALUE_NAME);
 585             else
 586                 RegKey->DeleteValue(DEFAULT_VALUE_NAME);
 587         }
 588     }
 589     catch(RegistryKeyNotFoundException&)
 590     {
 591     }
 592
 593     SaveNotRegisteredFor(DEFAULT_SHELL_HTML_EDITOR);
 594 }
 595
 596 void Registrar::SaveRegisteredFor(int State) const
 597 {
 598     assert(m_RootKey.get());
 599
 600     int NewState = GetRegisterState();
 601     NewState |= State;
 602     SetRegisterState(NewState);
 603 }
 604
 605 void Registrar::SaveNotRegisteredFor(int State) const
 606 {
 607     assert(m_RootKey.get());
 608
 609     int NewState = GetRegisterState();
 610     NewState &= ~State;
 611     SetRegisterState(NewState);
 612 }
 613
 614 int Registrar::GetRegisterState() const
 615 {
 616     int State = 0;
 617
 618     RegistryKey RegKey = m_RootKey->CreateSubKey(PRIVATE_BACKUP_KEY_NAME);
 619
 620     if (RegKey->HasValue(REGISTRATION_STATE))
 621     {
 622         RegistryValue RegVal = RegKey->GetValue(REGISTRATION_STATE);
 623         if (REG_DWORD == RegVal->GetType())
 624             State = RegVal->GetDataAsInt();
 625     }
 626
 627     return State;
 628 }
 629
 630 void Registrar::SetRegisterState(int NewState) const
 631 {
 632     RegistryKey RegKey = m_RootKey->CreateSubKey(PRIVATE_BACKUP_KEY_NAME);
 633     RegistryValue RegVal = RegistryValue(new RegistryValueImpl(REGISTRATION_STATE, NewState));
 634     RegKey->SetValue(RegVal);
 635 }
 636
 637 bool Registrar::IsRegisteredFor(int State) const
 638 {
 639     assert(m_RootKey.get());
 640
 641     RegistryKey RegKey = m_RootKey->CreateSubKey(PRIVATE_BACKUP_KEY_NAME);
 642
 643     int SavedState = 0;
 644
 645     if (RegKey->HasValue(REGISTRATION_STATE))
 646     {
 647         RegistryValue RegVal = RegKey->GetValue(REGISTRATION_STATE);
 648         if (REG_DWORD == RegVal->GetType())
 649             SavedState = RegVal->GetDataAsInt();
 650     }
 651
 652     return ((SavedState & State) == State);
 653 }
 654
 655 //--------------------------------------
 656 /** Restore the last registration state (necessary for
 657     Setup repair) */
 658 void Registrar::RepairRegistrationState() const
 659 {
 660     assert(m_RootKey.get());
 661
 662     if (IsRegisteredFor(MSWORD))
 663         RegisterForMsWord();
 664
 665     if (IsRegisteredFor(MSEXCEL))
 666         RegisterForMsExcel();
 667
 668     if (IsRegisteredFor(MSPOWERPOINT))
 669         RegisterForMsPowerPoint();
 670
 671     if (IsRegisteredFor(DEFAULT_HTML_EDITOR_FOR_IE))
 672         RegisterAsDefaultHtmlEditorForInternetExplorer();
 673
 674     if (IsRegisteredFor(HTML_EDITOR))
 675         RegisterAsHtmlEditorForInternetExplorer();
 676
 677     if (IsRegisteredFor(DEFAULT_SHELL_HTML_EDITOR))
 678         RegisterAsDefaultShellHtmlEditor();
 679 }
 680
 681 /** Unregisters all and delete all Registry keys we have written */
 682 void Registrar::UnregisterAllAndCleanUpRegistry() const
 683 {
 684     assert(m_RootKey.get());
 685
 686     if (IsRegisteredFor(MSWORD))
 687         UnregisterForMsWord();
 688
 689     if (IsRegisteredFor(MSEXCEL))
 690         UnregisterForMsExcel();
 691
 692     if (IsRegisteredFor(MSPOWERPOINT))
 693         UnregisterForMsPowerPoint();
 694
 695     if (IsRegisteredFor(DEFAULT_HTML_EDITOR_FOR_IE))
 696         UnregisterAsDefaultHtmlEditorForInternetExplorer();
 697
 698     if (IsRegisteredFor(HTML_EDITOR))
 699         UnregisterAsHtmlEditorForInternetExplorer();
 700
 701     if (IsRegisteredFor(DEFAULT_SHELL_HTML_EDITOR))
 702         UnregisterAsDefaultShellHtmlEditor();
 703
 704     if (m_RootKey->HasSubKey(PRIVATE_BACKUP_KEY_NAME))
 705         m_RootKey->DeleteSubKeyTree(PRIVATE_BACKUP_KEY_NAME);
 706 }
 707
 708 void Registrar::RegisterForMsOfficeApplication(
 709     const std::wstring& FileExtension,
 710     const std::wstring& DocumentDisplayName,
 711     const std::wstring& DefaultIconEntry,
 712     const std::wstring& DefaultShellCommand,
 713     const std::wstring& ShellNewCommandDisplayName,
 714     const RegistrationContextInformation::OFFICE_APPLICATION eOfficeApp) const
 715 {
 716     assert(m_RootKey.get());
 717
 718     std::wstring ForwardKeyName = FORWARD_KEY_PREFIX + FileExtension;
 719
 720     RegistryKey ForwardKey = m_RootKey->CreateSubKey(ForwardKeyName);
 721     RegistryValue RegVal(new RegistryValueImpl(std::wstring(DEFAULT_VALUE_NAME), DocumentDisplayName));
 722     ForwardKey->SetValue(RegVal);
 723
 724     RegistryKey RegKey = ForwardKey->CreateSubKey(L"DefaultIcon");
 725     RegVal->SetValue(DefaultIconEntry);
 726     RegKey->SetValue(RegVal);
 727
 728     RegistryKey RegKeyShell = ForwardKey->CreateSubKey(L"shell");
 729     RegVal->SetValue(DefaultShellCommand);
 730     RegKeyShell->SetValue(RegVal);
 731
 732     RegKey = RegKeyShell->CreateSubKey(L"new");
 733     RegVal->SetValue(ShellNewCommandDisplayName);
 734     RegKey->SetValue(RegVal);
 735
 736     RegKey = RegKey->CreateSubKey(L"command");
 737     RegVal->SetValue(m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::New, eOfficeApp));
 738     RegKey->SetValue(RegVal);
 739
 740     RegKey = RegKeyShell->CreateSubKey(L"open\\command");
 741     RegVal->SetValue(m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::Open, eOfficeApp));
 742     RegKey->SetValue(RegVal);
 743
 744     RegKey = RegKeyShell->CreateSubKey(L"print\\command");
 745     RegVal->SetValue(m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::Print, eOfficeApp));
 746     RegKey->SetValue(RegVal);
 747
 748     RegKey = RegKeyShell->CreateSubKey(L"printto\\command");
 749     RegVal->SetValue(m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::Printto, eOfficeApp));
 750     RegKey->SetValue(RegVal);
 751
 752     // set the new forward key under the appropriate extension
 753     RegKey = m_RootKey->CreateSubKey(FileExtension);
 754
 755     if (RegKey->HasValue(DEFAULT_VALUE_NAME))
 756     {
 757         RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
 758
 759         if (REG_SZ == RegVal->GetType())
 760         {
 761             std::wstring str = RegVal->GetDataAsUniString();
 762             if (!IsOpenOfficeRegisteredForMsApplication(str))
 763                 ForwardKey->CopyValue(RegKey, DEFAULT_VALUE_NAME, BACKUP_VALUE_NAME);
 764         }
 765     }
 766
 767     RegVal->SetValue(ForwardKeyName);
 768     RegKey->SetValue(RegVal);
 769 }
 770
 771 void Registrar::UnregisterForMsOfficeApplication(const std::wstring& FileExtension) const
 772 {
 773     std::wstring FwdRegKeyName = FORWARD_KEY_PREFIX + FileExtension;
 774
 775     if (m_RootKey->HasSubKey(FileExtension))
 776     {
 777         RegistryKey RegKey = m_RootKey->OpenSubKey(FileExtension);
 778
 779         if (RegKey->HasValue(DEFAULT_VALUE_NAME))
 780         {
 781             RegistryValue RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
 782             if (REG_SZ == RegVal->GetType() &&
 783                 IsOpenOfficeRegisteredForMsApplication(RegVal->GetDataAsUniString()))
 784             {
 785                 RegistryKey FwdRegKey = m_RootKey->CreateSubKey(FwdRegKeyName);
 786
 787                 if (FwdRegKey->HasValue(BACKUP_VALUE_NAME))
 788                     RegKey->CopyValue(FwdRegKey, BACKUP_VALUE_NAME, DEFAULT_VALUE_NAME);
 789                 else
 790                     RegKey->DeleteValue(DEFAULT_VALUE_NAME);
 791             }
 792         }
 793     }
 794
 795     if (m_RootKey->HasSubKey(FwdRegKeyName))
 796         m_RootKey->DeleteSubKeyTree(FwdRegKeyName);
 797 }
 798
 799 RegistryKey Registrar::GetRootKeyForDefHtmlEditorForIERegistration() const
 800 {
 801     return WindowsRegistry().GetLocalMachineKey();
 802 }
 803
 804 bool Registrar::IsOpenOfficeRegisteredForMsApplication(const std::wstring& DocumentExtensionDefValue) const
 805 {
 806     return (std::wstring::npos != DocumentExtensionDefValue.find(FORWARD_KEY_PREFIX));
 807 }