windows-xp/Source/XPSP1/NT/shell/ext/brfcase/filesync/syncui/init.c

//---------------------------------------------------------------------------
//
// 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 <brfcasep.h>

#define INITGUID            // Initialize GUIDs
#include <initguid.h>
#include <oleguid.h>
#include <coguid.h>
#include <shlguid.h>
#include <shguidp.h>        // Contains CLSID_Briefcase

#include "res.h"
#include "recact.h"

#ifdef DEBUG
#include <debugstr.h>
#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 <path>
    // is the fully qualified pathname of the briefcase to create,
    // and <xxxx> 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;
}