1*800f9471SAndrew Rist /**************************************************************
2*800f9471SAndrew Rist *
3*800f9471SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4*800f9471SAndrew Rist * or more contributor license agreements. See the NOTICE file
5*800f9471SAndrew Rist * distributed with this work for additional information
6*800f9471SAndrew Rist * regarding copyright ownership. The ASF licenses this file
7*800f9471SAndrew Rist * to you under the Apache License, Version 2.0 (the
8*800f9471SAndrew Rist * "License"); you may not use this file except in compliance
9*800f9471SAndrew Rist * with the License. You may obtain a copy of the License at
10*800f9471SAndrew Rist *
11*800f9471SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12*800f9471SAndrew Rist *
13*800f9471SAndrew Rist * Unless required by applicable law or agreed to in writing,
14*800f9471SAndrew Rist * software distributed under the License is distributed on an
15*800f9471SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*800f9471SAndrew Rist * KIND, either express or implied. See the License for the
17*800f9471SAndrew Rist * specific language governing permissions and limitations
18*800f9471SAndrew Rist * under the License.
19*800f9471SAndrew Rist *
20*800f9471SAndrew Rist *************************************************************/
21*800f9471SAndrew Rist
22cdf0e10cSrcweir
23cdf0e10cSrcweir #include "stdafx.h"
24cdf0e10cSrcweir
25cdf0e10cSrcweir #include "XMergeFilter.h"
26cdf0e10cSrcweir #include "XMergeFactory.h"
27cdf0e10cSrcweir
28cdf0e10cSrcweir
29cdf0e10cSrcweir CXMergeSyncModule _Module;
30cdf0e10cSrcweir
31cdf0e10cSrcweir
32cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////
33cdf0e10cSrcweir // DLL Functions
34cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////
DllMain(HANDLE hInst,ULONG ulReason,LPVOID lpReserved)35cdf0e10cSrcweir BOOL WINAPI DllMain(HANDLE hInst, ULONG ulReason, LPVOID lpReserved)
36cdf0e10cSrcweir {
37cdf0e10cSrcweir switch (ulReason)
38cdf0e10cSrcweir {
39cdf0e10cSrcweir case DLL_PROCESS_ATTACH:
40cdf0e10cSrcweir _Module.m_hInst = reinterpret_cast<HINSTANCE>(hInst);
41cdf0e10cSrcweir break;
42cdf0e10cSrcweir
43cdf0e10cSrcweir case DLL_PROCESS_DETACH:
44cdf0e10cSrcweir _Module.m_hInst = NULL;
45cdf0e10cSrcweir break;
46cdf0e10cSrcweir
47cdf0e10cSrcweir case DLL_THREAD_ATTACH:
48cdf0e10cSrcweir break;
49cdf0e10cSrcweir
50cdf0e10cSrcweir case DLL_THREAD_DETACH:
51cdf0e10cSrcweir break;
52cdf0e10cSrcweir }
53cdf0e10cSrcweir
54cdf0e10cSrcweir return TRUE;
55cdf0e10cSrcweir }
56cdf0e10cSrcweir
57cdf0e10cSrcweir
DllGetClassObject(REFCLSID rclsid,REFIID riid,LPVOID * ppv)58cdf0e10cSrcweir STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
59cdf0e10cSrcweir {
60cdf0e10cSrcweir // Create the factory object
61cdf0e10cSrcweir CXMergeFactory *pFactory = new CXMergeFactory();
62cdf0e10cSrcweir if (pFactory == NULL)
63cdf0e10cSrcweir {
64cdf0e10cSrcweir *ppv = NULL;
65cdf0e10cSrcweir return E_OUTOFMEMORY;
66cdf0e10cSrcweir }
67cdf0e10cSrcweir
68cdf0e10cSrcweir HRESULT hr = pFactory->QueryInterface(riid, ppv);
69cdf0e10cSrcweir pFactory->Release();
70cdf0e10cSrcweir
71cdf0e10cSrcweir return hr;
72cdf0e10cSrcweir }
73cdf0e10cSrcweir
74cdf0e10cSrcweir
DllCanUnloadNow()75cdf0e10cSrcweir STDAPI DllCanUnloadNow()
76cdf0e10cSrcweir {
77cdf0e10cSrcweir if (_Module.GetLockCount() == 0)
78cdf0e10cSrcweir return S_OK;
79cdf0e10cSrcweir
80cdf0e10cSrcweir return S_FALSE;
81cdf0e10cSrcweir }
82cdf0e10cSrcweir
83cdf0e10cSrcweir
84cdf0e10cSrcweir // Utility function to close open keys during registration
_signalRegError(long lRet,HKEY hKey,HKEY hDataKey)85cdf0e10cSrcweir static _signalRegError(long lRet, HKEY hKey, HKEY hDataKey)
86cdf0e10cSrcweir {
87cdf0e10cSrcweir if (hKey)
88cdf0e10cSrcweir ::RegCloseKey(hKey);
89cdf0e10cSrcweir
90cdf0e10cSrcweir
91cdf0e10cSrcweir if (hDataKey)
92cdf0e10cSrcweir ::RegCloseKey(hDataKey);
93cdf0e10cSrcweir
94cdf0e10cSrcweir return HRESULT_FROM_WIN32(lRet);
95cdf0e10cSrcweir }
96cdf0e10cSrcweir
97cdf0e10cSrcweir
DllRegisterServer()98cdf0e10cSrcweir STDAPI DllRegisterServer()
99cdf0e10cSrcweir {
100cdf0e10cSrcweir HKEY hKey = NULL;
101cdf0e10cSrcweir HKEY hDataKey = NULL;
102cdf0e10cSrcweir
103cdf0e10cSrcweir long lRet = 0;
104cdf0e10cSrcweir TCHAR sTemp[_MAX_PATH + 1] = "\0";
105cdf0e10cSrcweir
106cdf0e10cSrcweir
107cdf0e10cSrcweir /*
108cdf0e10cSrcweir * Following calls create the HKEY_CLASSES_ROOT\CLSID entry for the Writer export filter.
109cdf0e10cSrcweir *
110cdf0e10cSrcweir * Note that import are export are relative to the WinCE device, so files are
111cdf0e10cSrcweir * exported to the desktop format.
112cdf0e10cSrcweir */
113cdf0e10cSrcweir
114cdf0e10cSrcweir // Get a handle to the CLSID key
115cdf0e10cSrcweir lRet = ::RegOpenKeyEx(HKEY_CLASSES_ROOT, _T("CLSID"), 0, KEY_ALL_ACCESS, &hKey);
116cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
117cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
118cdf0e10cSrcweir
119cdf0e10cSrcweir // Create the CLSID key for the XMergeFilter
120cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, CXMergeFilter::m_pszPSWExportCLSID, 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hKey, NULL);
121cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
122cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
123cdf0e10cSrcweir
124cdf0e10cSrcweir lRet = ::RegSetValueEx(hKey, _T(""), 0, REG_SZ, (LPBYTE)CXMergeFilter::m_pszPSWExportShortDesc,
125cdf0e10cSrcweir (::_tcslen(CXMergeFilter::m_pszPSWExportShortDesc) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
126cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
127cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
128cdf0e10cSrcweir
129cdf0e10cSrcweir
130cdf0e10cSrcweir // Create the DefaultIcon key. For the moment, use one of the Async supplied ones
131cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T("DefaultIcon"), 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
132cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
133cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
134cdf0e10cSrcweir
135cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, NULL, 0, REG_SZ, (LPBYTE)_T("C:\\Program Files\\Microsoft ActiveSync\\pwdcnv.dll,0"),
136cdf0e10cSrcweir (::_tcslen(_T("C:\\Program Files\\Microsoft ActiveSync\\pwdcnv.dll,0"))
137cdf0e10cSrcweir * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
138cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
139cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
140cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
141cdf0e10cSrcweir
142cdf0e10cSrcweir // Create the InprocServer32 key
143cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T("InProcServer32"), 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
144cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
145cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
146cdf0e10cSrcweir
147cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("ThreadingModel"), 0, REG_SZ, (LPBYTE)_T("Apartment"), 10);
148cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
149cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
150cdf0e10cSrcweir
151cdf0e10cSrcweir // Create the key for the DLL file. First find the filename of the dll
152cdf0e10cSrcweir if (!::GetModuleFileName((HMODULE)_Module.m_hInst, sTemp, (_MAX_PATH + 1)))
153cdf0e10cSrcweir {
154cdf0e10cSrcweir lRet = ::GetLastError();
155cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
156cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
157cdf0e10cSrcweir }
158cdf0e10cSrcweir
159cdf0e10cSrcweir
160cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, NULL, 0, REG_SZ, (LPBYTE)sTemp,
161cdf0e10cSrcweir (::_tcslen(sTemp) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
162cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
163cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
164cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
165cdf0e10cSrcweir
166cdf0e10cSrcweir
167cdf0e10cSrcweir // Setup the PegasusFilter key values
168cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T("PegasusFilter"), 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
169cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
170cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
171cdf0e10cSrcweir
172cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("Description"), 0, REG_SZ, (LPBYTE)CXMergeFilter::m_pszPSWExportDesc,
173cdf0e10cSrcweir (::_tcslen(CXMergeFilter::m_pszPSWExportDesc) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
174cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
175cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
176cdf0e10cSrcweir
177cdf0e10cSrcweir
178cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("Export"), 0, REG_SZ, (LPBYTE)_T(""), (1 * sizeof(TCHAR)));
179cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
180cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
181cdf0e10cSrcweir
182cdf0e10cSrcweir
183cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("NewExtension"), 0, REG_SZ, (LPBYTE)CXMergeFilter::m_pszPSWExportExt,
184cdf0e10cSrcweir (::_tcslen(CXMergeFilter::m_pszPSWExportExt) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
185cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
186cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
187cdf0e10cSrcweir
188cdf0e10cSrcweir
189cdf0e10cSrcweir ::RegCloseKey(hKey); hKey = NULL;
190cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
191cdf0e10cSrcweir
192cdf0e10cSrcweir
193cdf0e10cSrcweir
194cdf0e10cSrcweir
195cdf0e10cSrcweir /*
196cdf0e10cSrcweir * Following calls create the entries for the filter in
197cdf0e10cSrcweir * HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows CE Services\Filters
198cdf0e10cSrcweir */
199cdf0e10cSrcweir
200cdf0e10cSrcweir lRet = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("SOFTWARE\\Microsoft\\Windows CE Services\\Filters"),
201cdf0e10cSrcweir 0, KEY_ALL_ACCESS, &hKey);
202cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
203cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
204cdf0e10cSrcweir
205cdf0e10cSrcweir _snprintf(sTemp, _MAX_PATH + 1, "%c%s\\InstalledFilters\0", '.', CXMergeFilter::m_pszPSWImportExt);
206cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T(sTemp),
207cdf0e10cSrcweir 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
208cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
209cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
210cdf0e10cSrcweir
211cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, CXMergeFilter::m_pszPSWExportCLSID, 0, REG_SZ, (LPBYTE)_T(""), (1 * sizeof(TCHAR)));
212cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
213cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
214cdf0e10cSrcweir
215cdf0e10cSrcweir ::RegCloseKey(hKey); hKey = NULL;
216cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
217cdf0e10cSrcweir
218cdf0e10cSrcweir
219cdf0e10cSrcweir
220cdf0e10cSrcweir /*
221cdf0e10cSrcweir * Following calls create the HKEY_CLASSES_ROOT\CLSID entry for the Writer import filter.
222cdf0e10cSrcweir *
223cdf0e10cSrcweir * Note that import are export are relative to the WinCE device, so files are
224cdf0e10cSrcweir * exported to the desktop format.
225cdf0e10cSrcweir */
226cdf0e10cSrcweir // Get a handle to the CLSID key
227cdf0e10cSrcweir lRet = ::RegOpenKeyEx(HKEY_CLASSES_ROOT, _T("CLSID"), 0, KEY_ALL_ACCESS, &hKey);
228cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
229cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
230cdf0e10cSrcweir
231cdf0e10cSrcweir // Create the CLSID key for the XMergeFilter
232cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, CXMergeFilter::m_pszPSWImportCLSID, 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hKey, NULL);
233cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
234cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
235cdf0e10cSrcweir
236cdf0e10cSrcweir lRet = ::RegSetValueEx(hKey, _T(""), 0, REG_SZ, (LPBYTE)CXMergeFilter::m_pszPSWImportShortDesc,
237cdf0e10cSrcweir (::_tcslen(CXMergeFilter::m_pszPSWImportShortDesc) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
238cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
239cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
240cdf0e10cSrcweir
241cdf0e10cSrcweir
242cdf0e10cSrcweir // Create the DefaultIcon key. For the moment, use one of the Async supplied ones
243cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T("DefaultIcon"), 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
244cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
245cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
246cdf0e10cSrcweir
247cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, NULL, 0, REG_SZ, (LPBYTE)_T("C:\\Program Files\\Microsoft ActiveSync\\pwdcnv.dll,0"),
248cdf0e10cSrcweir (::_tcslen(_T("C:\\Program Files\\Microsoft ActiveSync\\pwdcnv.dll,0"))
249cdf0e10cSrcweir * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
250cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
251cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
252cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
253cdf0e10cSrcweir
254cdf0e10cSrcweir
255cdf0e10cSrcweir // Create the InprocServer32 key
256cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T("InProcServer32"), 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
257cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
258cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
259cdf0e10cSrcweir
260cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("ThreadingModel"), 0, REG_SZ, (LPBYTE)_T("Apartment"), 10);
261cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
262cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
263cdf0e10cSrcweir
264cdf0e10cSrcweir
265cdf0e10cSrcweir // Create the key for the DLL file. First find the filename of the dll
266cdf0e10cSrcweir if (!::GetModuleFileName((HMODULE)_Module.m_hInst, sTemp, (_MAX_PATH + 1)))
267cdf0e10cSrcweir {
268cdf0e10cSrcweir lRet = ::GetLastError();
269cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
270cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
271cdf0e10cSrcweir }
272cdf0e10cSrcweir
273cdf0e10cSrcweir
274cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, NULL, 0, REG_SZ, (LPBYTE)sTemp,
275cdf0e10cSrcweir (::_tcslen(sTemp) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
276cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
277cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
278cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
279cdf0e10cSrcweir
280cdf0e10cSrcweir
281cdf0e10cSrcweir // Setup the PegasusFilter key values
282cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T("PegasusFilter"), 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
283cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
284cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
285cdf0e10cSrcweir
286cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("Description"), 0, REG_SZ, (LPBYTE)CXMergeFilter::m_pszPSWImportDesc,
287cdf0e10cSrcweir (::_tcslen(CXMergeFilter::m_pszPSWImportDesc) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
288cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
289cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
290cdf0e10cSrcweir
291cdf0e10cSrcweir
292cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("Import"), 0, REG_SZ, (LPBYTE)_T(""), (1 * sizeof(TCHAR)));
293cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
294cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
295cdf0e10cSrcweir
296cdf0e10cSrcweir
297cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("NewExtension"), 0, REG_SZ, (LPBYTE)CXMergeFilter::m_pszPSWImportExt,
298cdf0e10cSrcweir (::_tcslen(CXMergeFilter::m_pszPSWImportExt) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
299cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
300cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
301cdf0e10cSrcweir
302cdf0e10cSrcweir
303cdf0e10cSrcweir ::RegCloseKey(hKey); hKey = NULL;
304cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
305cdf0e10cSrcweir
306cdf0e10cSrcweir
307cdf0e10cSrcweir /*
308cdf0e10cSrcweir * Following calls create the entries for the filter in
309cdf0e10cSrcweir * HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows CE Services\Filters
310cdf0e10cSrcweir */
311cdf0e10cSrcweir lRet = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("SOFTWARE\\Microsoft\\Windows CE Services\\Filters"),
312cdf0e10cSrcweir 0, KEY_ALL_ACCESS, &hKey);
313cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
314cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
315cdf0e10cSrcweir
316cdf0e10cSrcweir // Add in defaults for import and export
317cdf0e10cSrcweir _snprintf(sTemp, _MAX_PATH +1, "%c%s\0", '.', CXMergeFilter::m_pszPSWExportExt);
318cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T(sTemp), 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
319cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
320cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
321cdf0e10cSrcweir
322cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("DefaultImport"), 0, REG_SZ,
323cdf0e10cSrcweir (LPBYTE)CXMergeFilter::m_pszPSWImportCLSID,
324cdf0e10cSrcweir (::_tcslen(CXMergeFilter::m_pszPSWImportDesc) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
325cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
326cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
327cdf0e10cSrcweir
328cdf0e10cSrcweir
329cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("DefaultExport"), 0, REG_SZ, (LPBYTE)_T("Binary Copy"),
330cdf0e10cSrcweir (::_tcslen(_T("Binary Copy")) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
331cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
332cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
333cdf0e10cSrcweir
334cdf0e10cSrcweir ::RegCloseKey(hDataKey);
335cdf0e10cSrcweir
336cdf0e10cSrcweir // Update registered filters
337cdf0e10cSrcweir _snprintf(sTemp, _MAX_PATH + 1, "%c%s\\InstalledFilters\0", '.', CXMergeFilter::m_pszPSWExportExt);
338cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T(sTemp),
339cdf0e10cSrcweir 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
340cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
341cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
342cdf0e10cSrcweir
343cdf0e10cSrcweir
344cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, CXMergeFilter::m_pszPSWImportCLSID, 0, REG_SZ, (LPBYTE)_T(""), (1 * sizeof(TCHAR)));
345cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
346cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
347cdf0e10cSrcweir
348cdf0e10cSrcweir ::RegCloseKey(hKey); hKey = NULL;
349cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
350cdf0e10cSrcweir
351cdf0e10cSrcweir
352cdf0e10cSrcweir
353cdf0e10cSrcweir /*
354cdf0e10cSrcweir * Following calls create the HKEY_CLASSES_ROOT\CLSID entry for the Calc export filter.
355cdf0e10cSrcweir *
356cdf0e10cSrcweir * Note that import are export are relative to the WinCE device, so files are
357cdf0e10cSrcweir * exported to the desktop format.
358cdf0e10cSrcweir */
359cdf0e10cSrcweir
360cdf0e10cSrcweir // Get a handle to the CLSID key
361cdf0e10cSrcweir lRet = ::RegOpenKeyEx(HKEY_CLASSES_ROOT, _T("CLSID"), 0, KEY_ALL_ACCESS, &hKey);
362cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
363cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
364cdf0e10cSrcweir
365cdf0e10cSrcweir // Create the CLSID key for the XMerge Filter
366cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, CXMergeFilter::m_pszPXLExportCLSID, 0, _T(""),
367cdf0e10cSrcweir 0, KEY_ALL_ACCESS, NULL, &hKey, NULL);
368cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
369cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
370cdf0e10cSrcweir
371cdf0e10cSrcweir lRet = ::RegSetValueEx(hKey, _T(""), 0, REG_SZ, (LPBYTE)CXMergeFilter::m_pszPXLExportShortDesc,
372cdf0e10cSrcweir (::_tcslen(CXMergeFilter::m_pszPXLExportShortDesc) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
373cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
374cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
375cdf0e10cSrcweir
376cdf0e10cSrcweir
377cdf0e10cSrcweir // Create the DefaultIcon key. For the moment, use one of the Async supplied ones
378cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T("DefaultIcon"), 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
379cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
380cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
381cdf0e10cSrcweir
382cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, NULL, 0, REG_SZ, (LPBYTE)_T("C:\\Program Files\\Microsoft ActiveSync\\pwdcnv.dll,0"),
383cdf0e10cSrcweir (::_tcslen(_T("C:\\Program Files\\Microsoft ActiveSync\\pwdcnv.dll,0"))
384cdf0e10cSrcweir * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
385cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
386cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
387cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
388cdf0e10cSrcweir
389cdf0e10cSrcweir
390cdf0e10cSrcweir // Create the InprocServer32 key
391cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T("InProcServer32"), 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
392cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
393cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
394cdf0e10cSrcweir
395cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("ThreadingModel"), 0, REG_SZ, (LPBYTE)_T("Apartment"), 10);
396cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
397cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
398cdf0e10cSrcweir
399cdf0e10cSrcweir
400cdf0e10cSrcweir // Create the key for the DLL file. First find the filename of the dll
401cdf0e10cSrcweir if (!::GetModuleFileName((HMODULE)_Module.m_hInst, sTemp, (_MAX_PATH + 1)))
402cdf0e10cSrcweir {
403cdf0e10cSrcweir lRet = ::GetLastError();
404cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
405cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
406cdf0e10cSrcweir }
407cdf0e10cSrcweir
408cdf0e10cSrcweir
409cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, NULL, 0, REG_SZ, (LPBYTE)sTemp,
410cdf0e10cSrcweir (::_tcslen(sTemp) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
411cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
412cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
413cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
414cdf0e10cSrcweir
415cdf0e10cSrcweir
416cdf0e10cSrcweir // Setup the PegasusFilter key values
417cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T("PegasusFilter"), 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
418cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
419cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
420cdf0e10cSrcweir
421cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("Description"), 0, REG_SZ, (LPBYTE)CXMergeFilter::m_pszPXLExportDesc,
422cdf0e10cSrcweir (::_tcslen(CXMergeFilter::m_pszPXLExportDesc) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
423cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
424cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
425cdf0e10cSrcweir
426cdf0e10cSrcweir
427cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("Export"), 0, REG_SZ, (LPBYTE)_T(""), (1 * sizeof(TCHAR)));
428cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
429cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
430cdf0e10cSrcweir
431cdf0e10cSrcweir
432cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("NewExtension"), 0, REG_SZ, (LPBYTE)CXMergeFilter::m_pszPXLExportExt,
433cdf0e10cSrcweir (::_tcslen(CXMergeFilter::m_pszPXLExportExt) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
434cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
435cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
436cdf0e10cSrcweir
437cdf0e10cSrcweir
438cdf0e10cSrcweir ::RegCloseKey(hKey); hKey = NULL;
439cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
440cdf0e10cSrcweir
441cdf0e10cSrcweir
442cdf0e10cSrcweir
443cdf0e10cSrcweir
444cdf0e10cSrcweir /*
445cdf0e10cSrcweir * Following calls create the entries for the filter in
446cdf0e10cSrcweir * HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows CE Services\Filters
447cdf0e10cSrcweir */
448cdf0e10cSrcweir
449cdf0e10cSrcweir lRet = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("SOFTWARE\\Microsoft\\Windows CE Services\\Filters"),
450cdf0e10cSrcweir 0, KEY_ALL_ACCESS, &hKey);
451cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
452cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
453cdf0e10cSrcweir
454cdf0e10cSrcweir _snprintf(sTemp, _MAX_PATH + 1, "%c%s\\InstalledFilters\0", '.', CXMergeFilter::m_pszPXLImportExt);
455cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T(sTemp),
456cdf0e10cSrcweir 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
457cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
458cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
459cdf0e10cSrcweir
460cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, CXMergeFilter::m_pszPXLExportCLSID, 0, REG_SZ, (LPBYTE)_T(""), (1 * sizeof(TCHAR)));
461cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
462cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
463cdf0e10cSrcweir
464cdf0e10cSrcweir ::RegCloseKey(hKey); hKey = NULL;
465cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
466cdf0e10cSrcweir
467cdf0e10cSrcweir
468cdf0e10cSrcweir
469cdf0e10cSrcweir /*
470cdf0e10cSrcweir * Following calls create the HKEY_CLASSES_ROOT\CLSID entry for the Calc import filter.
471cdf0e10cSrcweir *
472cdf0e10cSrcweir * Note that import are export are relative to the WinCE device, so files are
473cdf0e10cSrcweir * exported to the desktop format.
474cdf0e10cSrcweir */
475cdf0e10cSrcweir // Get a handle to the CLSID key
476cdf0e10cSrcweir lRet = ::RegOpenKeyEx(HKEY_CLASSES_ROOT, _T("CLSID"), 0, KEY_ALL_ACCESS, &hKey);
477cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
478cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
479cdf0e10cSrcweir
480cdf0e10cSrcweir
481cdf0e10cSrcweir // Create the CLSID key for the XMergeFilter
482cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, CXMergeFilter::m_pszPXLImportCLSID, 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hKey, NULL);
483cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
484cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
485cdf0e10cSrcweir
486cdf0e10cSrcweir lRet = ::RegSetValueEx(hKey, _T(""), 0, REG_SZ, (LPBYTE)CXMergeFilter::m_pszPXLImportShortDesc,
487cdf0e10cSrcweir (::_tcslen(CXMergeFilter::m_pszPXLImportShortDesc) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
488cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
489cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
490cdf0e10cSrcweir
491cdf0e10cSrcweir // Create the DefaultIcon key. For the moment, use one of the Async supplied ones
492cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T("DefaultIcon"), 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
493cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
494cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
495cdf0e10cSrcweir
496cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, NULL, 0, REG_SZ, (LPBYTE)_T("C:\\Program Files\\Microsoft ActiveSync\\pwdcnv.dll,0"),
497cdf0e10cSrcweir (::_tcslen(_T("C:\\Program Files\\Microsoft ActiveSync\\pwdcnv.dll,0"))
498cdf0e10cSrcweir * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
499cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
500cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
501cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
502cdf0e10cSrcweir
503cdf0e10cSrcweir
504cdf0e10cSrcweir // Create the InprocServer32 key
505cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T("InProcServer32"), 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
506cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
507cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
508cdf0e10cSrcweir
509cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("ThreadingModel"), 0, REG_SZ, (LPBYTE)_T("Apartment"), 10);
510cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
511cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
512cdf0e10cSrcweir
513cdf0e10cSrcweir
514cdf0e10cSrcweir // Create the key for the DLL file. First find the filename of the dll
515cdf0e10cSrcweir if (!::GetModuleFileName((HMODULE)_Module.m_hInst, sTemp, (_MAX_PATH + 1)))
516cdf0e10cSrcweir {
517cdf0e10cSrcweir lRet = ::GetLastError();
518cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
519cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
520cdf0e10cSrcweir }
521cdf0e10cSrcweir
522cdf0e10cSrcweir
523cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, NULL, 0, REG_SZ, (LPBYTE)sTemp,
524cdf0e10cSrcweir (::_tcslen(sTemp) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
525cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
526cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
527cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
528cdf0e10cSrcweir
529cdf0e10cSrcweir
530cdf0e10cSrcweir // Setup the PegasusFilter key values
531cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T("PegasusFilter"), 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
532cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
533cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
534cdf0e10cSrcweir
535cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("Description"), 0, REG_SZ, (LPBYTE)CXMergeFilter::m_pszPXLImportDesc,
536cdf0e10cSrcweir (::_tcslen(CXMergeFilter::m_pszPXLImportDesc) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
537cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
538cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
539cdf0e10cSrcweir
540cdf0e10cSrcweir
541cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("Import"), 0, REG_SZ, (LPBYTE)_T(""), (1 * sizeof(TCHAR)));
542cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
543cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
544cdf0e10cSrcweir
545cdf0e10cSrcweir
546cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("NewExtension"), 0, REG_SZ, (LPBYTE)CXMergeFilter::m_pszPXLImportExt,
547cdf0e10cSrcweir (::_tcslen(CXMergeFilter::m_pszPXLImportExt) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
548cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
549cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
550cdf0e10cSrcweir
551cdf0e10cSrcweir
552cdf0e10cSrcweir ::RegCloseKey(hKey); hKey = NULL;
553cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
554cdf0e10cSrcweir
555cdf0e10cSrcweir
556cdf0e10cSrcweir
557cdf0e10cSrcweir /*
558cdf0e10cSrcweir * Following calls create the entries for the filter in
559cdf0e10cSrcweir * HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows CE Services\Filters
560cdf0e10cSrcweir */
561cdf0e10cSrcweir lRet = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("SOFTWARE\\Microsoft\\Windows CE Services\\Filters"),
562cdf0e10cSrcweir 0, KEY_ALL_ACCESS, &hKey);
563cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
564cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
565cdf0e10cSrcweir
566cdf0e10cSrcweir // Add in defaults for import and export
567cdf0e10cSrcweir _snprintf(sTemp, _MAX_PATH +1, "%c%s\0", '.', CXMergeFilter::m_pszPXLExportExt);
568cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T(sTemp), 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
569cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
570cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
571cdf0e10cSrcweir
572cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("DefaultImport"), 0, REG_SZ,
573cdf0e10cSrcweir (LPBYTE)CXMergeFilter::m_pszPXLImportCLSID,
574cdf0e10cSrcweir (::_tcslen(CXMergeFilter::m_pszPSWImportDesc) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
575cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
576cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
577cdf0e10cSrcweir
578cdf0e10cSrcweir
579cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("DefaultExport"), 0, REG_SZ, (LPBYTE)_T("Binary Copy"),
580cdf0e10cSrcweir (::_tcslen(_T("Binary Copy")) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
581cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
582cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
583cdf0e10cSrcweir
584cdf0e10cSrcweir ::RegCloseKey(hDataKey);
585cdf0e10cSrcweir
586cdf0e10cSrcweir // Update registered filters
587cdf0e10cSrcweir
588cdf0e10cSrcweir
589cdf0e10cSrcweir _snprintf(sTemp, _MAX_PATH + 1, "%c%s\\InstalledFilters\0", '.', CXMergeFilter::m_pszPXLExportExt);
590cdf0e10cSrcweir lRet = ::RegCreateKeyEx(hKey, _T(sTemp),
591cdf0e10cSrcweir 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hDataKey, NULL);
592cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
593cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
594cdf0e10cSrcweir
595cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, CXMergeFilter::m_pszPXLImportCLSID, 0, REG_SZ, (LPBYTE)_T(""), (1 * sizeof(TCHAR)));
596cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
597cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
598cdf0e10cSrcweir
599cdf0e10cSrcweir ::RegCloseKey(hKey); hKey = NULL;
600cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
601cdf0e10cSrcweir
602cdf0e10cSrcweir
603cdf0e10cSrcweir
604cdf0e10cSrcweir return HRESULT_FROM_WIN32(lRet);
605cdf0e10cSrcweir }
606cdf0e10cSrcweir
607cdf0e10cSrcweir
DllUnregisterServer()608cdf0e10cSrcweir STDAPI DllUnregisterServer()
609cdf0e10cSrcweir {
610cdf0e10cSrcweir long lRet = 0;
611cdf0e10cSrcweir HKEY hKey = NULL;
612cdf0e10cSrcweir HKEY hDataKey = NULL;
613cdf0e10cSrcweir
614cdf0e10cSrcweir TCHAR szClassName[_MAX_PATH] = "\0";
615cdf0e10cSrcweir TCHAR szKeyName[_MAX_PATH] = "\0";
616cdf0e10cSrcweir DWORD dwClassName = _MAX_PATH;
617cdf0e10cSrcweir DWORD dwKeyName = _MAX_PATH;
618cdf0e10cSrcweir
619cdf0e10cSrcweir /*
620cdf0e10cSrcweir * Remove HKEY_CLASS_ROOT\CLSID\{XXX} entry for the export and import filters
621cdf0e10cSrcweir *
622cdf0e10cSrcweir * Windows 95/98/Me allow one step deletion of a key and all subkeys.
623cdf0e10cSrcweir * Windows NT/2000/XP do not so the subkeys must be deleted individually.
624cdf0e10cSrcweir */
625cdf0e10cSrcweir lRet = ::RegOpenKeyEx(HKEY_CLASSES_ROOT, _T("CLSID"), 0, KEY_ALL_ACCESS, &hKey);
626cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
627cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
628cdf0e10cSrcweir
629cdf0e10cSrcweir
630cdf0e10cSrcweir // First up, the Writer export filter
631cdf0e10cSrcweir lRet = ::RegOpenKeyEx(hKey, CXMergeFilter::m_pszPSWExportCLSID, 0, KEY_ALL_ACCESS, &hDataKey);
632cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
633cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
634cdf0e10cSrcweir
635cdf0e10cSrcweir
636cdf0e10cSrcweir while ((lRet = ::RegEnumKeyEx(hDataKey, 0, szKeyName, &dwKeyName, 0, szClassName, &dwClassName, NULL))
637cdf0e10cSrcweir != ERROR_NO_MORE_ITEMS)
638cdf0e10cSrcweir {
639cdf0e10cSrcweir lRet = ::RegDeleteKey(hDataKey, szKeyName);
640cdf0e10cSrcweir
641cdf0e10cSrcweir ::lstrcpy(szKeyName, "\0");
642cdf0e10cSrcweir ::lstrcpy(szClassName, "\0");
643cdf0e10cSrcweir
644cdf0e10cSrcweir dwClassName = _MAX_PATH;
645cdf0e10cSrcweir dwKeyName = _MAX_PATH;
646cdf0e10cSrcweir }
647cdf0e10cSrcweir
648cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
649cdf0e10cSrcweir
650cdf0e10cSrcweir lRet = ::RegDeleteKey(hKey, CXMergeFilter::m_pszPSWExportCLSID);
651cdf0e10cSrcweir if (lRet != ERROR_SUCCESS && lRet != ERROR_FILE_NOT_FOUND)
652cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
653cdf0e10cSrcweir
654cdf0e10cSrcweir
655cdf0e10cSrcweir
656cdf0e10cSrcweir // Next, the Writer import filter
657cdf0e10cSrcweir lRet = ::RegOpenKeyEx(hKey, CXMergeFilter::m_pszPSWImportCLSID, 0, KEY_ALL_ACCESS, &hDataKey);
658cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
659cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
660cdf0e10cSrcweir
661cdf0e10cSrcweir
662cdf0e10cSrcweir while ((lRet = ::RegEnumKeyEx(hDataKey, 0, szKeyName, &dwKeyName, 0, szClassName, &dwClassName, NULL))
663cdf0e10cSrcweir != ERROR_NO_MORE_ITEMS)
664cdf0e10cSrcweir {
665cdf0e10cSrcweir lRet = ::RegDeleteKey(hDataKey, szKeyName);
666cdf0e10cSrcweir
667cdf0e10cSrcweir ::lstrcpy(szKeyName, "\0");
668cdf0e10cSrcweir ::lstrcpy(szClassName, "\0");
669cdf0e10cSrcweir
670cdf0e10cSrcweir dwClassName = _MAX_PATH;
671cdf0e10cSrcweir dwKeyName = _MAX_PATH;
672cdf0e10cSrcweir }
673cdf0e10cSrcweir
674cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
675cdf0e10cSrcweir
676cdf0e10cSrcweir lRet = ::RegDeleteKey(hKey, CXMergeFilter::m_pszPSWImportCLSID);
677cdf0e10cSrcweir if (lRet != ERROR_SUCCESS && lRet != ERROR_FILE_NOT_FOUND)
678cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
679cdf0e10cSrcweir
680cdf0e10cSrcweir
681cdf0e10cSrcweir // Next up, the Calc export filter
682cdf0e10cSrcweir lRet = ::RegOpenKeyEx(hKey, CXMergeFilter::m_pszPXLExportCLSID, 0, KEY_ALL_ACCESS, &hDataKey);
683cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
684cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
685cdf0e10cSrcweir
686cdf0e10cSrcweir
687cdf0e10cSrcweir while ((lRet = ::RegEnumKeyEx(hDataKey, 0, szKeyName, &dwKeyName, 0, szClassName, &dwClassName, NULL))
688cdf0e10cSrcweir != ERROR_NO_MORE_ITEMS)
689cdf0e10cSrcweir {
690cdf0e10cSrcweir lRet = ::RegDeleteKey(hDataKey, szKeyName);
691cdf0e10cSrcweir
692cdf0e10cSrcweir ::lstrcpy(szKeyName, "\0");
693cdf0e10cSrcweir ::lstrcpy(szClassName, "\0");
694cdf0e10cSrcweir
695cdf0e10cSrcweir dwClassName = _MAX_PATH;
696cdf0e10cSrcweir dwKeyName = _MAX_PATH;
697cdf0e10cSrcweir }
698cdf0e10cSrcweir
699cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
700cdf0e10cSrcweir
701cdf0e10cSrcweir lRet = ::RegDeleteKey(hKey, CXMergeFilter::m_pszPXLExportCLSID);
702cdf0e10cSrcweir if (lRet != ERROR_SUCCESS && lRet != ERROR_FILE_NOT_FOUND)
703cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
704cdf0e10cSrcweir
705cdf0e10cSrcweir
706cdf0e10cSrcweir // Next, the Calc import filter
707cdf0e10cSrcweir lRet = ::RegOpenKeyEx(hKey, CXMergeFilter::m_pszPXLImportCLSID, 0, KEY_ALL_ACCESS, &hDataKey);
708cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
709cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
710cdf0e10cSrcweir
711cdf0e10cSrcweir
712cdf0e10cSrcweir while ((lRet = ::RegEnumKeyEx(hDataKey, 0, szKeyName, &dwKeyName, 0, szClassName, &dwClassName, NULL))
713cdf0e10cSrcweir != ERROR_NO_MORE_ITEMS)
714cdf0e10cSrcweir {
715cdf0e10cSrcweir lRet = ::RegDeleteKey(hDataKey, szKeyName);
716cdf0e10cSrcweir
717cdf0e10cSrcweir ::lstrcpy(szKeyName, "\0");
718cdf0e10cSrcweir ::lstrcpy(szClassName, "\0");
719cdf0e10cSrcweir
720cdf0e10cSrcweir dwClassName = _MAX_PATH;
721cdf0e10cSrcweir dwKeyName = _MAX_PATH;
722cdf0e10cSrcweir }
723cdf0e10cSrcweir
724cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
725cdf0e10cSrcweir
726cdf0e10cSrcweir lRet = ::RegDeleteKey(hKey, CXMergeFilter::m_pszPXLImportCLSID);
727cdf0e10cSrcweir if (lRet != ERROR_SUCCESS && lRet != ERROR_FILE_NOT_FOUND)
728cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
729cdf0e10cSrcweir
730cdf0e10cSrcweir ::RegCloseKey(hKey); hKey = NULL;
731cdf0e10cSrcweir
732cdf0e10cSrcweir
733cdf0e10cSrcweir
734cdf0e10cSrcweir /*
735cdf0e10cSrcweir * Remove the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows CE Services\Filters
736cdf0e10cSrcweir */
737cdf0e10cSrcweir lRet = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("SOFTWARE\\Microsoft\\Windows CE Services\\Filters"),
738cdf0e10cSrcweir 0, KEY_ALL_ACCESS, &hKey);
739cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
740cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
741cdf0e10cSrcweir
742cdf0e10cSrcweir
743cdf0e10cSrcweir // Remove the Writer export filter from the Writer import file extension subkey.
744cdf0e10cSrcweir _snprintf(szKeyName, _MAX_PATH, ".%s\\InstalledFilters", CXMergeFilter::m_pszPSWImportExt);
745cdf0e10cSrcweir lRet = ::RegOpenKeyEx(hKey, _T(szKeyName), 0, KEY_ALL_ACCESS, &hDataKey);
746cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
747cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
748cdf0e10cSrcweir
749cdf0e10cSrcweir lRet = ::RegDeleteValue(hDataKey, CXMergeFilter::m_pszPSWExportCLSID);
750cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
751cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
752cdf0e10cSrcweir
753cdf0e10cSrcweir ::lstrcpyn(szKeyName, "\0", _MAX_PATH);
754cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
755cdf0e10cSrcweir
756cdf0e10cSrcweir
757cdf0e10cSrcweir // Remove the Writer import filter from the Writer export file extension subkey.
758cdf0e10cSrcweir _snprintf(szKeyName, _MAX_PATH, ".%s\\InstalledFilters", CXMergeFilter::m_pszPSWExportExt);
759cdf0e10cSrcweir lRet = ::RegOpenKeyEx(hKey, _T(szKeyName), 0, KEY_ALL_ACCESS, &hDataKey);
760cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
761cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
762cdf0e10cSrcweir
763cdf0e10cSrcweir lRet = ::RegDeleteValue(hDataKey, CXMergeFilter::m_pszPSWImportCLSID);
764cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
765cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
766cdf0e10cSrcweir
767cdf0e10cSrcweir ::lstrcpyn(szKeyName, "\0", _MAX_PATH);
768cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
769cdf0e10cSrcweir
770cdf0e10cSrcweir
771cdf0e10cSrcweir // Make Binary Copy the default for Writer export file extension subkey DefaultImport
772cdf0e10cSrcweir _snprintf(szKeyName, _MAX_PATH, ".%s\0", CXMergeFilter::m_pszPSWExportExt);
773cdf0e10cSrcweir lRet = ::RegOpenKeyEx(hKey, _T(szKeyName), 0, KEY_ALL_ACCESS, &hDataKey);
774cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
775cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
776cdf0e10cSrcweir
777cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("DefaultImport"), 0, REG_SZ, (LPBYTE)_T("Binary Copy"),
778cdf0e10cSrcweir (::_tcslen(_T("Binary Copy")) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
779cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
780cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
781cdf0e10cSrcweir
782cdf0e10cSrcweir ::lstrcpyn(szKeyName, "\0", _MAX_PATH);
783cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
784cdf0e10cSrcweir
785cdf0e10cSrcweir
786cdf0e10cSrcweir // Remove the Calc export filter from the Calc import file extension subkey.
787cdf0e10cSrcweir _snprintf(szKeyName, _MAX_PATH, ".%s\\InstalledFilters", CXMergeFilter::m_pszPXLImportExt);
788cdf0e10cSrcweir lRet = ::RegOpenKeyEx(hKey, _T(szKeyName), 0, KEY_ALL_ACCESS, &hDataKey);
789cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
790cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
791cdf0e10cSrcweir
792cdf0e10cSrcweir lRet = ::RegDeleteValue(hDataKey, CXMergeFilter::m_pszPXLExportCLSID);
793cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
794cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
795cdf0e10cSrcweir
796cdf0e10cSrcweir ::lstrcpyn(szKeyName, "\0", _MAX_PATH);
797cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
798cdf0e10cSrcweir
799cdf0e10cSrcweir // Remove the Calc import filter from the Calc export file extension subkey.
800cdf0e10cSrcweir _snprintf(szKeyName, _MAX_PATH, ".%s\\InstalledFilters", CXMergeFilter::m_pszPXLExportExt);
801cdf0e10cSrcweir lRet = ::RegOpenKeyEx(hKey, _T(szKeyName), 0, KEY_ALL_ACCESS, &hDataKey);
802cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
803cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
804cdf0e10cSrcweir
805cdf0e10cSrcweir lRet = ::RegDeleteValue(hDataKey, CXMergeFilter::m_pszPXLImportCLSID);
806cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
807cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
808cdf0e10cSrcweir
809cdf0e10cSrcweir ::lstrcpyn(szKeyName, "\0", _MAX_PATH);
810cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
811cdf0e10cSrcweir
812cdf0e10cSrcweir
813cdf0e10cSrcweir // Make Binary Copy the default for Calc export file extension subkey DefaultImport
814cdf0e10cSrcweir _snprintf(szKeyName, _MAX_PATH, ".%s\0", CXMergeFilter::m_pszPXLExportExt);
815cdf0e10cSrcweir lRet = ::RegOpenKeyEx(hKey, _T(szKeyName), 0, KEY_ALL_ACCESS, &hDataKey);
816cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
817cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
818cdf0e10cSrcweir
819cdf0e10cSrcweir lRet = ::RegSetValueEx(hDataKey, _T("DefaultImport"), 0, REG_SZ, (LPBYTE)_T("Binary Copy"),
820cdf0e10cSrcweir (::_tcslen(_T("Binary Copy")) * sizeof(TCHAR) + (1 * sizeof(TCHAR))));
821cdf0e10cSrcweir if (lRet != ERROR_SUCCESS)
822cdf0e10cSrcweir return _signalRegError(lRet, hKey, hDataKey);
823cdf0e10cSrcweir
824cdf0e10cSrcweir ::lstrcpyn(szKeyName, "\0", _MAX_PATH);
825cdf0e10cSrcweir ::RegCloseKey(hDataKey); hDataKey = NULL;
826cdf0e10cSrcweir
827cdf0e10cSrcweir
828cdf0e10cSrcweir
829cdf0e10cSrcweir ::RegCloseKey(hKey); hKey = NULL;
830cdf0e10cSrcweir
831cdf0e10cSrcweir return HRESULT_FROM_WIN32(lRet);
832cdf0e10cSrcweir }
833cdf0e10cSrcweir
834cdf0e10cSrcweir
835cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////
836cdf0e10cSrcweir // CXMergeSyncModule methods
837cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////
CXMergeSyncModule()838cdf0e10cSrcweir CXMergeSyncModule::CXMergeSyncModule ()
839cdf0e10cSrcweir {
840cdf0e10cSrcweir }
841cdf0e10cSrcweir
~CXMergeSyncModule()842cdf0e10cSrcweir CXMergeSyncModule::~CXMergeSyncModule ()
843cdf0e10cSrcweir {
844cdf0e10cSrcweir }
845cdf0e10cSrcweir
LockServer(BOOL fLock)846cdf0e10cSrcweir long CXMergeSyncModule::LockServer(BOOL fLock)
847cdf0e10cSrcweir {
848cdf0e10cSrcweir if(fLock)
849cdf0e10cSrcweir return ::InterlockedIncrement(&m_lLocks);
850cdf0e10cSrcweir else
851cdf0e10cSrcweir return ::InterlockedDecrement(&m_lLocks);
852cdf0e10cSrcweir }
853cdf0e10cSrcweir
GetLockCount()854cdf0e10cSrcweir long CXMergeSyncModule::GetLockCount()
855cdf0e10cSrcweir {
856cdf0e10cSrcweir return m_lLocks + m_lObjs;
857cdf0e10cSrcweir }
858cdf0e10cSrcweir
859