//--------------------------------------------------------------------------- // // Copyright (c) Microsoft Corporation 1993-1994 // // File: init.c // // This file contains the library entry points // // Usage and assumptions used in this DLL. // // 1) Message crackers are used. See windowsx.h and windowsx.txt. // // 2) Many functions are considered "member functions" of a // particular class. Because this is not C++, the function // names follow a special naming convention: "Class_Name". // In addition, it is common practice that the first // argument for these type of functions is a "this" pointer // to the particular object. // // History: // 08-06-93 ScottH Transferred from twin code // //--------------------------------------------------------------------------- ///////////////////////////////////////////////////// INCLUDES #include "brfprv.h" // common headers #include #define INITGUID // Initialize GUIDs #include #include #include #include #include // Contains CLSID_Briefcase #include "res.h" #include "recact.h" #ifdef DEBUG #include #endif //--------------------------------------------------------------------------- // Per instance data //--------------------------------------------------------------------------- HINSTANCE g_hinst = 0; TWINRESULT g_tr = TR_SUCCESS; // Debugging variables UINT g_uBreakFlags = 0; // Controls when to int 3 UINT g_uTraceFlags = 0; // Controls what trace messages are spewed UINT g_uDumpFlags = 0; // Controls what structs get dumped // The delay mutex and the cs that protects the cRef is per-instance HANDLE g_hMutexDelay = NULL; static UINT g_cRefMutex = 0; static CRITICAL_SECTION s_csDelay = { 0 }; //--------------------------------------------------------------------------- // Global data //--------------------------------------------------------------------------- CRITICAL_SECTION g_csSyncUI = { 0 }; DEBUG_CODE( UINT g_cRefSyncUI = 0; ) UINT g_cfBriefObj = 0; BOOL g_bMirroredOS = FALSE; // Use the helper macros in brfprv.h UINT g_cBusyRef = 0; // Semaphore UINT g_cBriefRef = 0; // Semaphore // Metrics int g_cxIconSpacing = 0; int g_cyIconSpacing = 0; int g_cxBorder = 0; int g_cyBorder = 0; int g_cxIcon = 0; int g_cyIcon = 0; int g_cxIconMargin = 0; int g_cyIconMargin = 0; int g_cxLabelMargin = 0; int g_cyLabelSpace = 0; int g_cxMargin = 0; // System colors COLORREF g_clrHighlightText = 0; COLORREF g_clrHighlight = 0; COLORREF g_clrWindowText = 0; COLORREF g_clrWindow = 0; HBRUSH g_hbrHighlight = 0; HBRUSH g_hbrWindow = 0; // Strings TCHAR g_szDBName[MAXPATHLEN]; TCHAR g_szDBNameShort[MAXPATHLEN]; // Get the system metrics we need void PRIVATE GetMetrics(WPARAM wParam) // wParam from WM_WININICHANGE { if ((wParam == 0) || (wParam == SPI_SETNONCLIENTMETRICS)) { g_cxIconSpacing = GetSystemMetrics( SM_CXICONSPACING ); g_cyIconSpacing = GetSystemMetrics( SM_CYICONSPACING ); g_cxBorder = GetSystemMetrics(SM_CXBORDER); g_cyBorder = GetSystemMetrics(SM_CYBORDER); g_cxIcon = GetSystemMetrics(SM_CXICON); g_cyIcon = GetSystemMetrics(SM_CYICON); g_cxIconMargin = g_cxBorder * 8; g_cyIconMargin = g_cyBorder * 2; g_cyLabelSpace = g_cyIconMargin + (g_cyBorder * 2); g_cxLabelMargin = (g_cxBorder * 2); g_cxMargin = g_cxBorder * 5; } } // Initializes colors void PRIVATE InitGlobalColors() { g_clrWindowText = GetSysColor(COLOR_WINDOWTEXT); g_clrWindow = GetSysColor(COLOR_WINDOW); g_clrHighlightText = GetSysColor(COLOR_HIGHLIGHTTEXT); g_clrHighlight = GetSysColor(COLOR_HIGHLIGHT); g_hbrWindow = GetSysColorBrush(COLOR_WINDOW); g_hbrHighlight = GetSysColorBrush(COLOR_HIGHLIGHT); } // Initialize global strings void PRIVATE InitGlobalStrings() { SzFromIDS(IDS_BC_DATABASE, g_szDBName, ARRAYSIZE(g_szDBName)); SzFromIDS(IDS_BC_DATABASE_SHORT, g_szDBNameShort, ARRAYSIZE(g_szDBNameShort)); } // Initialize the DLL on the first PROCESS_ATTACH BOOL PRIVATE InitializeFirstTime(void) { BOOL bRet = FALSE; InitCommonControls(); GetMetrics(0); CPATH_InitCS(); CBS_InitCS(); CRL_InitCS(); if (!Atom_Init()) goto Init_Cleanup; if (!CPATH_Init()) goto Init_Cleanup; // We do not load the engine DLL until we really need it. // Initialize our global imagelist // g_cfBriefObj = RegisterClipboardFormat(CFSTR_BRIEFOBJECT); if (g_cfBriefObj == 0) goto Init_Cleanup; bRet = TRUE; Init_Cleanup: if (bRet == FALSE) { Atom_Term(); } return bRet; } // Register window classes per process BOOL PRIVATE InitWindowClasses(HINSTANCE hinst) { return RecAct_Init(hinst); } // Terminate DLL on the last PROCESS_DETACH void PRIVATE FinalTerminate(HINSTANCE hinst) { CPATH_Term(); Atom_Term(); CRL_DeleteCS(); CBS_DeleteCS(); CPATH_DeleteCS(); Mem_Terminate(); } // Unregister window classes per process void PRIVATE TermWindowClasses(HINSTANCE hinst) { RecAct_Term(hinst); } // Purpose: Obtain ownership of the delay-calculation mutex // Returns: reference count UINT PUBLIC Delay_Own(void) { UINT cRef; EnterCriticalSection(&s_csDelay); { if (0 == g_cRefMutex++) { // Obtain ownership of the mutex. This will get released // when Delay_Release is called. LeaveCriticalSection(&s_csDelay); { MsgWaitObjectsSendMessage(1, &g_hMutexDelay, INFINITE); } EnterCriticalSection(&s_csDelay); TRACE_MSG(TF_GENERAL, TEXT("Set delay mutex")); } cRef = g_cRefMutex; } LeaveCriticalSection(&s_csDelay); return cRef; } /*---------------------------------------------------------- Purpose: Release ownership of the delay-calculation mutex Returns: reference count Cond: -- */ UINT PUBLIC Delay_Release(void) { UINT cRef; EnterCriticalSection(&s_csDelay); { ASSERT(0 < g_cRefMutex); if (0 < g_cRefMutex) { if (0 == --g_cRefMutex) { ReleaseMutex(g_hMutexDelay); TRACE_MSG(TF_GENERAL, TEXT("Release delay mutex")); } } cRef = g_cRefMutex; } LeaveCriticalSection(&s_csDelay); return cRef; } void PUBLIC Brief_EnterExclusive(void) { EnterCriticalSection(&g_csSyncUI); #ifdef DEBUG g_cRefSyncUI++; #endif } void PUBLIC Brief_LeaveExclusive(void) { #ifdef DEBUG g_cRefSyncUI--; #endif LeaveCriticalSection(&g_csSyncUI); } BOOL ProcessAttach(HINSTANCE hDll) { DWORD dwLayout = 0; BOOL bSuccess = TRUE; SHFusionInitializeFromModule(hDll); InitializeCriticalSection(&g_csSyncUI); InitializeCriticalSection(&s_csDelay); g_hinst = hDll; #ifdef DEBUG // We do this simply to load the debug .ini flags ProcessIniFile(); DEBUG_BREAK(BF_ONPROCESSATT); #endif // Under NT, we need to initialize on every process attach, not just the first bSuccess = InitializeFirstTime(); if (bSuccess) { g_hMutexDelay = CreateMutex(NULL, FALSE, TEXT("SYNCUI")); bSuccess = (NULL != g_hMutexDelay); } if (bSuccess) { // (Only do this if we succeeded above) // // Do the following for every process bSuccess = InitWindowClasses(hDll); } InitGlobalColors(); InitGlobalStrings(); //Bug 199701, 199647, 199699 //Apparently this is either broke or never worked: g_bMirroredOS = IS_MIRRORING_ENABLED(); GetProcessDefaultLayout(&dwLayout); if (dwLayout == LAYOUT_RTL) { g_bMirroredOS = TRUE; } //End bug 199701, 199647, 199699 return bSuccess; } BOOL ProcessDetach(HINSTANCE hDll) { BOOL bSuccess = TRUE; ASSERT(hDll == g_hinst); DEBUG_CODE( DEBUG_BREAK(BF_ONPROCESSDET); ) ASSERT(0 == g_cRefMutex); if (g_hMutexDelay) { CloseHandle(g_hMutexDelay); g_hMutexDelay = NULL; } FinalTerminate(g_hinst); Sync_ReleaseVTable(); DeleteCriticalSection(&g_csSyncUI); DeleteCriticalSection(&s_csDelay); TermWindowClasses(hDll); SHFusionUninitialize(); return bSuccess; } BOOL APIENTRY LibMain(HANDLE hDll, DWORD dwReason, void *lpReserved) { switch(dwReason) { case DLL_PROCESS_ATTACH: ProcessAttach(hDll); #ifndef DEBUG DisableThreadLibraryCalls(hDll); #endif break; case DLL_PROCESS_DETACH: ProcessDetach(hDll); break; case DLL_THREAD_ATTACH: #ifdef DEBUG // We do this simply to load the debug .ini flags ProcessIniFile(); #endif break; case DLL_THREAD_DETACH: #ifdef DEBUG DEBUG_BREAK(BF_ONTHREADDET); #endif break; default: break; } return TRUE; } /*---------------------------------------------------------- Purpose: Registers property sheet and context menu extensions for the briefcase. Returns: TRUE on success Cond: -- */ BOOL PRIVATE RegisterShellExtension(void) { const static TCHAR c_szPage[] = STRREG_SHEX_PROPSHEET TEXT("\\BriefcasePage"); const static TCHAR c_szCM[] = STRREG_SHEX_MENUHANDLER TEXT("\\BriefcaseMenu"); const static TCHAR c_szFolder[] = TEXT("Folder"); const static TCHAR c_szStar[] = TEXT("*"); const static TCHAR c_szFmt[] = TEXT("SOFTWARE\\Classes\\%s\\%s"); // This must be per instance, else it will cause a fixup in // shared data segment. const static LPCTSTR rgpsz[2] = { c_szFolder, c_szStar }; TCHAR sz[MAXBUFLEN]; int i; for (i = 0; i < ARRAYSIZE(rgpsz); i++) { // Add briefcase page extension wsprintf(sz, c_szFmt, (LPCTSTR)rgpsz[i], (LPCTSTR)c_szPage); RegSetValue(HKEY_LOCAL_MACHINE, sz, REG_SZ, c_szCLSID, lstrlen(c_szCLSID)); // Add briefcase context menu extension wsprintf(sz, c_szFmt, (LPCTSTR)rgpsz[i], (LPCTSTR)c_szCM); RegSetValue(HKEY_LOCAL_MACHINE, sz, REG_SZ, c_szCLSID, lstrlen(c_szCLSID)); } return TRUE; } /*---------------------------------------------------------- Purpose: Create a briefcase at the specified location. Returns: TRUE on success Cond: -- */ BOOL PRIVATE CreateTheBriefcase(HWND hwnd, LPCTSTR pszNewPath) { BOOL bRet = FALSE; TCHAR szParent[MAX_PATH]; TCHAR szTmp[MAX_PATH]; DEBUG_CODE( TRACE_MSG(TF_ALWAYS, TEXT("Creating %s"), (LPCTSTR)pszNewPath); ) // We do not allow briefcases to be created inside other briefcases. lstrcpy(szParent, pszNewPath); PathRemoveFileSpec(szParent); // Is this inside another briefcase? if (PL_FALSE != PathGetLocality(szParent, szTmp)) { // Yes; don't do it! MsgBox(hwnd, MAKEINTRESOURCE(IDS_ERR_CREATE_INANOTHER), MAKEINTRESOURCE(IDS_CAP_CREATE), NULL, MB_WARNING); } else if (CreateDirectory(pszNewPath, NULL)) { // Mark the briefcase as a system directory // if (!SetFileAttributes(pszNewPath, FILE_ATTRIBUTE_READONLY)) { TRACE_MSG(TF_ALWAYS, TEXT("Cannot make %s a system directory"), (LPCTSTR)pszNewPath); RemoveDirectory(pszNewPath); MsgBox(hwnd, MAKEINTRESOURCE(IDS_ERR_CANTCREATEBC), MAKEINTRESOURCE(IDS_CAP_CREATE), NULL, MB_ERROR, pszNewPath); } else { const static TCHAR c_szConfirmFileOp[] = TEXT("ConfirmFileOp"); HBRFCASE hbrf; TWINRESULT tr; LPCTSTR pszDBName; DECLAREHOURGLASS; if (PathsTooLong(pszNewPath, c_szDesktopIni) || PathsTooLong(pszNewPath, g_szDBName) || PathsTooLong(pszNewPath, g_szDBNameShort)) { MsgBox(hwnd, MAKEINTRESOURCE(IDS_ERR_CREATE_TOOLONG), MAKEINTRESOURCE(IDS_CAP_CREATE), NULL, MB_ERROR); } else { // Write in the desktop.ini the briefcase class ID PathCombine(szTmp, pszNewPath, c_szDesktopIni); // (First, flush the cache to make sure the desktop.ini // file is really created.) WritePrivateProfileString(NULL, NULL, NULL, szTmp); WritePrivateProfileString(STRINI_CLASSINFO, c_szIniKeyCLSID, c_szCLSID, szTmp); WritePrivateProfileString(STRINI_CLASSINFO, c_szConfirmFileOp, TEXT("0"), szTmp); // Make wizard run the first time it is opened. WritePrivateProfileString(STRINI_CLASSINFO, c_szRunWizard, TEXT("1"), szTmp); // Hide the desktop.ini since the shell does not selectively hide it. // Also make it readonly so that the user can't customize the briefcase. if (!SetFileAttributes(szTmp, FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM)) { TRACE_MSG(TF_ALWAYS, TEXT("Cannot hide and/or make read-only %s"), (LPCTSTR)szTmp); } RegisterShellExtension(); PathNotifyShell(pszNewPath, NSE_MKDIR, TRUE); // Create the database file SetHourglass(); if (IsLFNDrive(pszNewPath)) pszDBName = g_szDBName; else pszDBName = g_szDBNameShort; PathCombine(szTmp, pszNewPath, pszDBName); if (Sync_QueryVTable()) { tr = Sync_OpenBriefcase(szTmp, OB_FL_OPEN_DATABASE | OB_FL_TRANSLATE_DB_FOLDER | OB_FL_ALLOW_UI, hwnd, &hbrf); if (TR_SUCCESS == tr) { // (Don't really care about errors here) Sync_SaveBriefcase(hbrf); Sync_CloseBriefcase(hbrf); } } ResetHourglass(); bRet = TRUE; } } } else { // Could not create the directory. Is it because a briefcase // already exists at this location? if (PathExists(pszNewPath)) { // Yes TRACE_MSG(TF_ALWAYS, TEXT("Briefcase already exists at this location: %s"), (LPCTSTR)pszNewPath); } else { // No MsgBox(hwnd, MAKEINTRESOURCE(IDS_ERR_CANTCREATEBC), MAKEINTRESOURCE(IDS_CAP_CREATE), NULL, MB_ERROR, pszNewPath); } } return bRet; } /*---------------------------------------------------------- Purpose: Adds the briefcase at pszPath to the SendTo folder Returns: standard result Cond: -- */ HRESULT PRIVATE AddBriefcaseToSendToFolder(HWND hwnd, LPCTSTR pszPath) { HRESULT hres = E_OUTOFMEMORY; TCHAR szSendTo[MAX_PATH]; Shell_GetImageLists( NULL, NULL ); // make sure icon cache is around if (SHGetSpecialFolderPath(hwnd, szSendTo, CSIDL_SENDTO, FALSE)) { LPITEMIDLIST pidl = ILCreateFromPath(pszPath); if (pidl) { LPITEMIDLIST pidlParent = ILClone(pidl); if (pidlParent) { IShellFolder * psf; IShellFolder * psfDesktop; ILRemoveLastID(pidlParent); hres = SHGetDesktopFolder(&psfDesktop); if (SUCCEEDED(hres)) { hres = psfDesktop->lpVtbl->BindToObject(psfDesktop, pidlParent, NULL, &IID_IShellFolder, &psf); if (SUCCEEDED(hres)) { IDataObject *pdtobj; LPCITEMIDLIST pidlName = ILFindLastID(pidl); hres = psf->lpVtbl->GetUIObjectOf(psf, hwnd, 1, &pidlName, &IID_IDataObject, NULL, &pdtobj); if (SUCCEEDED(hres)) { SHCreateLinks(hwnd, szSendTo, pdtobj, 0, NULL); pdtobj->lpVtbl->Release(pdtobj); } psf->lpVtbl->Release(psf); } psfDesktop->lpVtbl->Release(psfDesktop); } ILFree(pidlParent); } ILFree(pidl); } } return hres; } /*---------------------------------------------------------- Purpose: Creates a briefcase in the specified directory. Returns: -- Cond: -- */ void WINAPI Briefcase_CreateInDirectory(HWND hwnd, HWND hwndCabinet, LPCTSTR pszPath) { if (CreateTheBriefcase(hwnd, pszPath)) { // Select the newly created item to edit it LPITEMIDLIST pidl = ILCreateFromPath(pszPath); if (pidl) { SelectItemInCabinet(hwndCabinet, ILFindLastID(pidl), TRUE); ILFree(pidl); } } } /*---------------------------------------------------------- Purpose: Creates a briefcase on the desktop. Returns: -- Cond: -- */ void WINAPI Briefcase_CreateOnDesktop(HWND hwnd) { // Place it on the desktop TCHAR szPath[MAX_PATH]; if (SHGetSpecialFolderPath(hwnd, szPath, CSIDL_DESKTOPDIRECTORY, FALSE)) { int cch; UINT ids; if (IsLFNDrive(szPath)) ids = IDS_BC_NAME; else ids = IDS_BC_NAME_SHORT; lstrcat(szPath, TEXT("\\")); cch = lstrlen(szPath); LoadString(g_hinst, ids, &szPath[cch], ARRAYSIZE(szPath)-cch); if (CreateTheBriefcase(hwnd, szPath)) { // Add a shortcut of this briefcase to the SendTo folder AddBriefcaseToSendToFolder(hwnd, szPath); } } } /*---------------------------------------------------------- Purpose: Create a briefcase folder in the specified directory or on the desktop. Returns: -- Cond: -- */ void WINAPI _export Briefcase_Create_Common(HWND hwnd, HINSTANCE hAppInstance, LPTSTR pszCmdLine, int nCmdShow) { DEBUG_CODE( DEBUG_BREAK(BF_ONRUNONCE); ) // Command line should be of format "xxxx path" where // is the fully qualified pathname of the briefcase to create, // and is the explorer hwnd. if (pszCmdLine && *pszCmdLine) { LPTSTR psz; HWND hwndCabinet; // Get hwnd hwndCabinet = IntToPtr(AnsiToInt(pszCmdLine)); psz = StrChr(pszCmdLine, TEXT(' ')); if (NULL != hwndCabinet && NULL != psz) { Briefcase_CreateInDirectory(hwnd, hwndCabinet, CharNext(psz)); return; } } Briefcase_CreateOnDesktop(hwnd); } void WINAPI _export Briefcase_Create(HWND hwnd, HINSTANCE hAppInstance, LPSTR pszCmdLine, int nCmdShow) { UINT iLength = lstrlenA(pszCmdLine)+1; LPWSTR lpwszCmdLine; lpwszCmdLine = (LPWSTR)LocalAlloc(LPTR, iLength *SIZEOF(TCHAR)); if (lpwszCmdLine) { MultiByteToWideChar(CP_ACP, 0, pszCmdLine, -1, lpwszCmdLine, iLength); Briefcase_Create_Common(hwnd, hAppInstance, lpwszCmdLine, nCmdShow); LocalFree((HANDLE)lpwszCmdLine); } } void WINAPI _export Briefcase_CreateW(HWND hwnd, HINSTANCE hAppInstance, LPWSTR pwszCmdLine, int nCmdShow) { Briefcase_Create_Common(hwnd, hAppInstance, pwszCmdLine, nCmdShow); } /*---------------------------------------------------------- Purpose: Display the introduction "wizard". (It's really not a wizard since it is not making anything for us.) NOTE: This function serves double duty for both the ansi and unicode versions. It never uses the command line. Returns: -- Cond: -- */ void WINAPI _export Briefcase_Intro( HWND hwnd, HINSTANCE hAppInstance, LPTSTR lpszCmdLine, int nCmdShow) { Intro_DoModal(hwnd); } //--------------------------------------------------------------------------- // DLL entry-points //--------------------------------------------------------------------------- /*---------------------------------------------------------- Purpose: This function is called back from within IClassFactory::CreateInstance() of the default class factory object, which is created by SHCreateClassObject. Returns: standard Cond: -- */ HRESULT CALLBACK DllFactoryCallback(IUnknown *punkOuter, REFIID riid, void **ppvOut) { HRESULT hres; if (IsEqualIID(riid, &IID_IShellExtInit)) { hres = BriefExt_CreateInstance(punkOuter, riid, ppvOut); } else if (IsEqualIID(riid, &IID_IBriefcaseStg)) { hres = BriefStg_CreateInstance(punkOuter, riid, ppvOut); } else { hres = E_NOINTERFACE; *ppvOut = NULL; } return hres; } /*---------------------------------------------------------- Purpose: Standard OLE 2.0 entry-point Returns: standard Cond: -- */ STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **ppvOut) { HRESULT hres; if (IsEqualIID(rclsid, &CLSID_Briefcase)) { // We are supposed return the class object for this class. Instead // of fully implementing it in this DLL, we just call a helper // function in the shell DLL which creates a default class factory // object for us. When its CreateInstance member is called, it // will call back our create instance function. hres = SHCreateDefClassObject( riid, // Interface ID ppvOut, // Non-null to aggregate DllFactoryCallback, // callback function &g_cBusyRef, // reference count of this DLL NULL); // init interface } else { hres = REGDB_E_CLASSNOTREG; *ppvOut = NULL; } return hres; } /*---------------------------------------------------------- Purpose: "Can Unload Now" entry point. Called by the shell DLL task handler list. Returns: S_OK to unload Cond: -- */ STDAPI DllCanUnloadNow(void) { HRESULT hr; // We only unload when: // 2) We are not busy processing anything else *and* // 3) No briefcases are currently open // ENTEREXCLUSIVE(); { if (!IsBusySemaphore() && !IsOpenBriefSemaphore()) { DEBUG_CODE( TRACE_MSG(TF_GENERAL, TEXT("DllCanUnloadNow says OK (Busy=%d, Brief=%d)"), g_cBusyRef, g_cBriefRef); ) hr = S_OK; } else { DEBUG_CODE( TRACE_MSG(TF_GENERAL, TEXT("DllCanUnloadNow says FALSE (Busy=%d, Brief=%d)"), g_cBusyRef, g_cBriefRef); ) hr = S_FALSE; } } LEAVEEXCLUSIVE(); return hr; }