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

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