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