windows-xp/Source/XPSP1/NT/enduser/stuff/hhctrl/ipserver.cpp

// Copyright (C) 1996-1997 Microsoft Corporation. All rights reserved.

//
// implements all exported DLL functions for the program, as well as a few
// others that will be used by same
//
#include "header.h"
#include "internet.h"

#include "AutoObj.H"
#include "ClassF.H"
#include "Unknown.H"
#include "strtable.h"
#include "hhifc.h"
#include "hhsort.h"

#include "resource.h"

#ifdef _DEBUG
#undef THIS_FILE
static const char THIS_FILE[] = __FILE__;
#endif

#include "atlinc.h"     // includes for ATL.

#include "iterror.h"
#include "itSort.h"
#include "itSortid.h"
#include "hhsyssrt.h"
#include "hhfinder.h"

#include "msitstg.h"

// Only including for the pahwnd declaration.
#include "secwin.h"

// So we can cleanup the lasterror object.
#include "lasterr.h"

#include <atlimpl.cpp>

extern HMODULE  g_hmodMSI;      // msi.dll module handle

CHtmlHelpModule _Module;

BEGIN_OBJECT_MAP(ObjectMap)
  OBJECT_ENTRY(CLSID_HHSysSort, CHHSysSort)
  OBJECT_ENTRY(CLSID_HHFinder, CHHFinder)
END_OBJECT_MAP()

const IID IID_ICatRegister = {0x0002E012,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
const GUID CATID_SafeForScripting      = {0x7dd95801,0x9882,0x11cf,{0x9f,0xa9,0x00,0xaa,0x00,0x6c,0x42,0xc4}};
const GUID CATID_SafeForInitializing   = {0x7dd95802,0x9882,0x11cf,{0x9f,0xa9,0x00,0xaa,0x00,0x6c,0x42,0xc4}};

// In 1996-1997 alone, these two constants appeared and disappeared in 3 different
// header files. I got tired or finding out which !@$! header file they
// got moved to this time and just defined them here.

#define LANG_ARABIC                      0x01
#define LANG_HEBREW                      0x0d

static const char txtCplDesktop[] = "Control Panel\\Desktop\\ResourceLocale";
static const char txtShellOpenFmt[] = "%s\\shell\\open\\%s";
static const char txtCommand[] = "command";
static const char txtStdOpen[] = "[open(\"%1\")]";
static const char txtStdArg[] = " %1";
static const char txtChmFile[] = "chm.file";
static const char txtHhExe[] = "hh.exe";
static const char txtItssDll[] = "itss.dll";
static const char txtItirclDll[] = "itircl.dll";
static const char txtDllRegisterServer[] = "DllRegisterServer";
static const char txtDllUnRegisterServer[] = "DllUnregisterServer";
static const char txtIE4[] = "SOFTWARE\\Microsoft\\Internet Explorer";
static const char txtVersion[] = "version";
static const char txtMouseWheel[] = "MSWHEEL_ROLLMSG";

static const char txtStringGuid[] = "{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}";
static const char txtInProc[] = "CLSID\\%s\\InprocServer32";

static void SetRegKey(LPCTSTR pszKey, LPCTSTR pszValue);
void RegisterHH(PCSTR pszHHPath);   // also called by hh.cpp
extern HANDLE g_hsemMemory;

//=--------------------------------------------------------------------------=

// private routines for this file.

int       IndexOfOleObject(REFCLSID);
HRESULT   RegisterAllObjects(void);
HRESULT   UnregisterAllObjects(void);

//=--------------------------------------------------------------------------=
// StringFromGuidA
//=--------------------------------------------------------------------------=
// returns an ANSI string from a CLSID or GUID
//
// Parameters:
//    REFIID               - [in]  clsid to make string out of.
//    LPSTR                - [in/out]  buffer in which to place resultant GUID.
//
// Output:
//    int                  - number of chars written out.
//
// Notes:
//
int StringFromGuidA( CLSID riid, LPSTR pszBuf )
{
  return wsprintf( (char*) pszBuf,
    txtStringGuid,
    riid.Data1, riid.Data2, riid.Data3,
    riid.Data4[0], riid.Data4[1], riid.Data4[2], riid.Data4[3],
    riid.Data4[4], riid.Data4[5], riid.Data4[6], riid.Data4[7]);
}

#define GUID_STR_LEN  40

//=--------------------------------------------------------------------------=
// GetRegisteredLocation
//=--------------------------------------------------------------------------=
// Returns the registered location of an inproc server given the CLSID
//
// HKEY_CLASSES_ROOT\CLSID\<CLSID>\InprocServer32 = <path to local server>
//
// Parameters:
//    REFCLSID     - [in] CLSID of the object
//    LPTSTR       - [in/out] Pathname
//
// Output:
//    BOOL         - FALSE means couldn't find it

BOOL GetRegisteredLocation( CLSID riid, LPTSTR pszPathname )
{
  BOOL bReturn = FALSE;
  HKEY hKey = NULL;
  char szGuidStr[GUID_STR_LEN];
  char szScratch[MAX_PATH];

  if( !StringFromGuidA( riid, szGuidStr ) )
    return FALSE;

  wsprintf( szScratch, txtInProc, szGuidStr );
  if( RegOpenKeyEx( HKEY_CLASSES_ROOT, szScratch, 0, KEY_READ, &hKey ) == ERROR_SUCCESS ) {
    DWORD dwSize = MAX_PATH;
    if( RegQueryValueExA( hKey, "", 0, 0, (BYTE*) szScratch, &dwSize ) == ERROR_SUCCESS ) {
      strcpy( pszPathname, szScratch );
      bReturn = TRUE;
    }
  }

  if( hKey )
    RegCloseKey( hKey );

  return bReturn;
}

BOOL WINAPI DllMain(HANDLE hInstance, DWORD  dwReason, void  *pvReserved)
{
    int i;

    switch (dwReason) {
      // set up some global variables, and get some OS/Version information
      // set up.
      //
      case DLL_PROCESS_ATTACH:
        {
            //NOTE: Do not handle resources until after the _Module.Init call below.

            OSVERSIONINFO versionInfo;
	         versionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

            GetVersionEx(&versionInfo);

		     g_bWinNT5   = ((versionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) && (versionInfo.dwMajorVersion >= 5));
			 g_bWin98 = (versionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) && ((versionInfo.dwMajorVersion > 4)
				|| ((versionInfo.dwMajorVersion == 4) && (versionInfo.dwMinorVersion > 0)));

            // Check version
            DWORD dwVer = GetVersion();
            DWORD dwWinVer;

            //  swap the two lowest bytes of dwVer so that the major and minor version
            //  numbers are in a usable order.
            //  for dwWinVer: high byte = major version, low byte = minor version
            //     OS               Sys_WinVersion  (as of 5/2/95)
            //     =-------------=  =-------------=
            //     Win95            0x035F   (3.95)
            //     WinNT ProgMan    0x0333   (3.51)
            //     WinNT Win95 UI   0x0400   (4.00)
            //
            dwWinVer = (UINT)(((dwVer & 0xFF) << 8) | ((dwVer >> 8) & 0xFF));
            g_fSysWinNT = FALSE;
            g_fSysWin95 = FALSE;
            g_fSysWin95Shell = FALSE;

            if (dwVer < 0x80000000) {
                g_fSysWinNT = TRUE;
                g_fSysWin95Shell = (dwWinVer >= 0x0334);
            } else  {
                g_fSysWin95 = TRUE;
                g_fSysWin95Shell = TRUE;
            }
            if ( !g_fCoInitialized )
            {
                OleInitialize(NULL);
                g_fCoInitialized = TRUE;    // so that we call CoUninitialize() when dll is unloaded
            }

            // Initialize ATL's module information.
            _Module.Init(ObjectMap, (HINSTANCE) hInstance);
            DisableThreadLibraryCalls((HINSTANCE) hInstance);

            // Now it is okay to read the resources.
            g_fDBCSSystem = (BOOL) GetSystemMetrics(SM_DBCSENABLED);
            g_lcidSystem = GetUserDefaultLCID();

            // Determine if we are on a BiDi system

            g_langSystem = PRIMARYLANGID(LANGIDFROMLCID(g_lcidSystem));

            // Get the language of the UI (Satalite DLL)
			//
            LANGID lid = PRIMARYLANGID(_Module.m_Language.GetUiLanguage());

            // determine if we are running with a localized Hebrew or Arabic UI
			//
            if(lid == LANG_ARABIC || lid == LANG_HEBREW)
                g_bBiDiUi=TRUE;				
			else
                g_bBiDiUi=FALSE;				

            // determine if we are running with a localized Hebrew or Arabic UI
			//
            if(lid == LANG_ARABIC)
                g_bArabicUi=TRUE;				
			else
                g_bArabicUi=FALSE;				

            MSG_MOUSEWHEEL = RegisterWindowMessage(txtMouseWheel);

            // Find out if we are on IE 4 or later

            {
                HKEY hkey;
                if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, txtIE4, 0, KEY_READ, &hkey) ==
                        ERROR_SUCCESS) {
                    char szVersion[MAX_PATH];
                    DWORD cbPath = sizeof(szVersion);
                    if (RegQueryValueEx(hkey, txtVersion, NULL, NULL, (LPBYTE) szVersion, &cbPath) == ERROR_SUCCESS) {

                        // IE 3 didn't have a version key, so if this succeeds,
                        // we know we aren't on IE 3.

                        g_fIE3 = FALSE; // we're on IE 4, not IE 3
                        g_bMsItsMonikerSupport = FALSE; // Don't make this TRUE. See bug 6984 & 6876
                    }
                    RegCloseKey(hkey);
                }
            }


            // register our server if the pathname is not the same as the
            // one that is already registered
            TCHAR szHHCtrl[MAX_PATH];
            szHHCtrl[0] = 0;
            TCHAR szModulePathname[MAX_PATH];
            szModulePathname[0] = 0;
            BOOL bRegister = FALSE;
            bRegister = !GetRegisteredLocation( CLSID_HHCtrl, szHHCtrl );
            if( !bRegister ) {
              GetModuleFileName( _Module.GetModuleInstance(), szModulePathname, MAX_PATH );
              if( lstrcmpi( szHHCtrl, szModulePathname ) != 0 )
                bRegister = TRUE;
            }
            if( bRegister )
              DllRegisterServer();

            // TODO: pahwnd needs to be incapsulated into a class and allocated on demand.
            g_cWindowSlots = 5;
            pahwnd = (CHHWinType**) lcCalloc(g_cWindowSlots * sizeof(CHHWinType*));
            memset( pahwnd, 0, g_cWindowSlots * sizeof(CHHWinType*) );

            return TRUE;
        }

      case DLL_PROCESS_DETACH:
        // DBWIN("HHCtrl unloading");

        // DeleteCriticalSection(&g_CriticalSection);

        // unregister all the registered window classes.

        // Clean out the memory in the last error object, since the heap is screwed before the destructor is called.
        g_LastError.Finish() ;

        i = 0;

        while (!ISEMPTYOBJECT(i)) {
            if (g_ObjectInfo[i].usType == OI_CONTROL) {
#ifdef _DEBUG
CONTROLOBJECTINFO* pinfo = (CONTROLOBJECTINFO*) g_ObjectInfo[i].pInfo;
#endif
                if (CTLWNDCLASSREGISTERED(i))
                    UnregisterClass(WNDCLASSNAMEOFCONTROL(i), _Module.GetModuleInstance());
            }
            i++;
        }

        // clean up our parking window.

        if (g_hwndParking) {
            DestroyWindow(g_hwndParking);
            UnregisterClass("CtlFrameWork_Parking", _Module.GetModuleInstance());
            --g_cLocks;
        }

        // free our window types list
        for( int i = 0; i < g_cWindowSlots; i++ )
          if( pahwnd[i] ) {

            CHECK_AND_FREE( pahwnd[i]->pszType );
            CHECK_AND_FREE( pahwnd[i]->pszCaption );
            CHECK_AND_FREE( pahwnd[i]->pszToc );
            CHECK_AND_FREE( pahwnd[i]->pszIndex );
            CHECK_AND_FREE( pahwnd[i]->pszFile );
            CHECK_AND_FREE( pahwnd[i]->pszHome );
            CHECK_AND_FREE( pahwnd[i]->pszJump1 );
            CHECK_AND_FREE( pahwnd[i]->pszJump2 );
            CHECK_AND_FREE( pahwnd[i]->pszUrlJump1 );
            CHECK_AND_FREE( pahwnd[i]->pszUrlJump2 );
            CHECK_AND_FREE( pahwnd[i]->pszCustomTabs );

            pahwnd[i]->ProcessDetachSafeCleanup();
          }
        CHECK_AND_FREE( pahwnd );

        // free the CHmData
        CHECK_AND_FREE( g_phmData );

        // don't call DBWIN here since it will cause a GPF

        if (g_hmodMSI != NULL)
            FreeLibrary(g_hmodMSI);
        if (g_hpalSplash)
            DeleteObject(g_hpalSplash);
        _Module.Term();
        if (g_hsemMemory)
            CloseHandle(g_hsemMemory);

        if (g_hsemNavigate)
            CloseHandle(g_hsemNavigate);

        // DeleteAllHmData();
        if (g_hmodHHA != NULL)
        {
            FreeLibrary(g_hmodHHA);
            g_hmodHHA = NULL;
        }
        if (g_fCoInitialized)
        {
           OleUninitialize();
           g_fCoInitialized = FALSE;
        }
        return TRUE;
    }

    return TRUE;
}

#ifndef HHUTIL
//=--------------------------------------------------------------------------=
// DllRegisterServer
//=--------------------------------------------------------------------------=
// registers the Automation server

STDAPI DllRegisterServer(void)
{
    HRESULT hr;

    hr = RegisterAllObjects();
    ASSERT(SUCCEEDED(hr));
    RETURN_ON_FAILURE(hr);

    CreateComponentCategory(CATID_SafeForScripting, L"Controls that are safely scriptable");
    CreateComponentCategory(CATID_SafeForInitializing, L"Controls safely initializable from persistent data");
    RegisterCLSIDInCategory(CLSID_HHCtrl, CATID_SafeForScripting);
    RegisterCLSIDInCategory(CLSID_HHCtrl, CATID_SafeForInitializing);

    char szPath[MAX_PATH];
    GetRegWindowsDirectory(szPath);
    AddTrailingBackslash(szPath);
    strcat(szPath, txtHhExe);
    if (GetFileAttributes(szPath) != HFILE_ERROR)
        RegisterHH(szPath);

    GetSystemDirectory(szPath, sizeof(szPath));
    AddTrailingBackslash(szPath);
    PSTR pszEnd = szPath + strlen(szPath);
    strcpy(pszEnd, txtItssDll);

    // Register decompression DLL (for .CHM files)

    HMODULE hmod = LoadLibrary(szPath);
    if (hmod) {
        void (STDCALL *pDllRegisterServer)(void);
        (FARPROC&) pDllRegisterServer =
            GetProcAddress(hmod, txtDllRegisterServer);
        if (pDllRegisterServer)
            pDllRegisterServer();
        FreeLibrary(hmod);
    }

    // Register the full-text search module

   strcpy(pszEnd, txtItirclDll);
   hmod = LoadLibrary(szPath);
   if (hmod) {
      void (STDCALL *pDllRegisterServer)(void);
      (FARPROC&) pDllRegisterServer =
         GetProcAddress(hmod, txtDllRegisterServer);
      if (pDllRegisterServer)
         pDllRegisterServer();
      FreeLibrary(hmod);
   }

   // register our file extensions for Removable Media Support
   HKEY hKey;
   LPCTSTR szGUID = HHFINDER_GUID;
   LPCTSTR szExt  = HHFINDER_EXTENSION;
   RegCreateKeyEx( HKEY_LOCAL_MACHINE, ITSS_FINDER, 0, NULL,
     REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, NULL);
   RegSetValueEx( hKey, szExt, 0, REG_SZ, (const unsigned char*) szGUID,
     (int)(strlen(szGUID) + 1) );
   RegCloseKey( hKey );

   _Module.RegisterServer(TRUE);
   return S_OK;
}
#endif

void RegisterHH(PCSTR pszHHPath)
{
    char szFullPath[MAX_PATH];

    SetRegKey(txtDefExtension, txtChmFile);

    LoadString(_Module.GetResourceInstance(),IDS_COMPILEDHTMLFILE,szFullPath,sizeof(szFullPath));

    SetRegKey(txtChmFile, szFullPath);

    // Put path in quotes, in case there are spaces in the folder name

    szFullPath[0] = '\042';
    strcpy(szFullPath + 1, pszHHPath);
    strcat(szFullPath, "\"");

    PSTR pszPathEnd = szFullPath + strlen(szFullPath);
    strcat(szFullPath, txtStdArg);     // "pathname %1"

    char szBuf[MAX_PATH * 2];
    wsprintf(szBuf, txtShellOpenFmt, txtChmFile, txtCommand);
    SetRegKey(szBuf, szFullPath);

    // Register the icon to use for .chm files

    *pszPathEnd = '\0'; // remove the arguments
    strcpy(szFullPath + strlen(szFullPath) - 1, ",0");  // remove the close quote
    SetRegKey("chm.file\\DefaultIcon", szFullPath + 1);
}

static void SetRegKey(LPCTSTR pszKey, LPCTSTR pszValue)
{
    RegSetValue(HKEY_CLASSES_ROOT, pszKey, REG_SZ, pszValue, (int)strlen(pszValue));
}

#ifndef HHUTIL
//=--------------------------------------------------------------------------=
// DllUnregisterServer
//=--------------------------------------------------------------------------=
// unregister's the Automation server

STDAPI DllUnregisterServer(void)
{
    HRESULT hr;

    hr = UnregisterAllObjects();
    RETURN_ON_FAILURE(hr);

    // call user unregistration function

    hr = UnregisterData();

    // Remove registration for decompression DLL (for .CHM files)

    HMODULE hmod = LoadLibrary(txtItssDll);
    if (hmod) {
        void (STDCALL *pDllRegisterServer)(void);
        (FARPROC&) pDllRegisterServer =
            GetProcAddress(hmod, txtDllUnRegisterServer);
        if (pDllRegisterServer)
            pDllRegisterServer();
        FreeLibrary(hmod);
    }

    // Remove registration for the full-text search module

    hmod = LoadLibrary(txtItirclDll);
    if (hmod) {
        void (STDCALL *pDllRegisterServer)(void);
        (FARPROC&) pDllRegisterServer =
            GetProcAddress(hmod, txtDllUnRegisterServer);
        if (pDllRegisterServer)
            pDllRegisterServer();
        FreeLibrary(hmod);
    }

   // unregister our file extensions for Removable Media Support

   HKEY hKey;
   LPCTSTR szGUID = HHFINDER_GUID;
   LPCTSTR szExt  = HHFINDER_EXTENSION;
   RegCreateKeyEx( HKEY_LOCAL_MACHINE, ITSS_FINDER, 0, NULL,
     REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, NULL);
   RegDeleteKey( hKey, szExt );
   RegCloseKey( hKey );

   _Module.UnregisterServer();

    // BUGBUG: remove association with .CHM files

    return hr;
}
#endif

#ifndef HHUTIL
//=--------------------------------------------------------------------------=
// DllCanUnloadNow
//=--------------------------------------------------------------------------=
// we are being asked whether or not it's okay to unload the DLL.  just check
// the lock counts on remaining objects ...
//
// Output:
//    HRESULT        - S_OK, can unload now, S_FALSE, can't.

STDAPI DllCanUnloadNow(void)
{
    // if there are any objects lying around, then we can't unload.  The
    // controlling CUnknownObject class that people should be inheriting from
    // takes care of this

    return (g_cLocks) ? S_FALSE : S_OK;
}
#endif

#ifndef HHUTIL
//=--------------------------------------------------------------------------=
// DllGetClassObject
//=--------------------------------------------------------------------------=
// creates a ClassFactory object, and returns it.
//
// Parameters:
//    REFCLSID        - CLSID for the class object
//    REFIID          - interface we want class object to be.
//    void **         - pointer to where we should ptr to new object.
//
// Output:
//    HRESULT         - S_OK, CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY,
//                      E_INVALIDARG, E_UNEXPECTED

STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **ppvObjOut)
{
    HRESULT hr;
    void   *pv;
    int     iIndex;

   if( IsEqualCLSID( rclsid, CLSID_HHSysSort ) || IsEqualCLSID( rclsid, CLSID_HHFinder ) )
     return _Module.GetClassObject( rclsid, riid, ppvObjOut );

    // arg checking

    if (!ppvObjOut)
        return E_INVALIDARG;

    // first of all, make sure they're asking for something we work with.

    iIndex = IndexOfOleObject(rclsid);
    if (iIndex == -1)
        return CLASS_E_CLASSNOTAVAILABLE;

    // create the blank object.

    pv = (void *)new CClassFactory(iIndex);
    if (!pv)
        return E_OUTOFMEMORY;

    // QI for whatever the user has asked for.
    //
    hr = ((IUnknown *)pv)->QueryInterface(riid, ppvObjOut);
    ((IUnknown *)pv)->Release();

    return hr;
}
#endif

//=--------------------------------------------------------------------------=
// IndexOfOleObject
//=--------------------------------------------------------------------------=
// returns the index in our global table of objects of the given CLSID.  if
// it's not a supported object, then we return -1
//
// Parameters:
//    REFCLSID     - [in] duh.
//
// Output:
//    int          - >= 0 is index into global table, -1 means not supported

int IndexOfOleObject(REFCLSID rclsid)
{
    int x = 0;

    // an object is creatable if it's CLSID is in the table of all allowable object
    // types.

    while (!ISEMPTYOBJECT(x)) {
#ifdef _DEBUG
CONTROLOBJECTINFO* pinfo = (CONTROLOBJECTINFO*) g_ObjectInfo[x].pInfo;
#endif

        if (OBJECTISCREATABLE(x)) {
            if (rclsid == CLSIDOFOBJECT(x))
                return x;
        }
        x++;
    }

    return -1;
}

//=--------------------------------------------------------------------------=
// RegisterAllObjects
//=--------------------------------------------------------------------------=
// registers all the objects for the given automation server.
//
// Parameters:
//    none
//
// Output:
//    HERSULT        - S_OK, E_FAIL
//
// Notes:
//

const char g_szLibName[] = "Internet";

HRESULT RegisterAllObjects(void)
{
    HRESULT hr;
    int     x = 0;

    // loop through all of our creatable objects [those that have a clsid in
    // our global table] and register them.

    while (!ISEMPTYOBJECT(x)) {
#ifdef _DEBUG
CONTROLOBJECTINFO* pinfo = (CONTROLOBJECTINFO*) g_ObjectInfo[x].pInfo;
#endif

        if (!OBJECTISCREATABLE(x)) {
            x++;
            continue;
        }

        // depending on the object type, register different pieces of information

        switch (g_ObjectInfo[x].usType) {

          // for both simple co-creatable objects and proeprty pages, do the same
          // thing

          case OI_UNKNOWN:
          case OI_PROPERTYPAGE:
            RegisterUnknownObject(NAMEOFOBJECT(x), CLSIDOFOBJECT(x));
            break;

          case OI_AUTOMATION:
            RegisterAutomationObject(g_szLibName, NAMEOFOBJECT(x),
                VERSIONOFOBJECT(x), *g_pLibid, CLSIDOFOBJECT(x));
            break;

          case OI_CONTROL:
            RegisterControlObject(g_szLibName, NAMEOFOBJECT(x),
                VERSIONOFOBJECT(x), *g_pLibid, CLSIDOFOBJECT(x),
                    OLEMISCFLAGSOFCONTROL(x), BITMAPIDOFCONTROL(x));
            break;

        }
        x++;
    }

    // Load and register our type library.

    if (g_fServerHasTypeLibrary) {
        char szTmp[MAX_PATH];
        DWORD dwPathLen = GetModuleFileName(_Module.GetModuleInstance(), szTmp, MAX_PATH);
        MAKE_WIDEPTR_FROMANSI(pwsz, szTmp);

        ITypeLib *pTypeLib;
        hr = LoadTypeLib(pwsz, &pTypeLib);
        RETURN_ON_FAILURE(hr);
        hr = RegisterTypeLib(pTypeLib, pwsz, NULL);
        pTypeLib->Release();
        RETURN_ON_FAILURE(hr);
    }

    return S_OK;
}

//=--------------------------------------------------------------------------=
// UnregisterAllObjects
//=--------------------------------------------------------------------------=
// un-registers all the objects for the given automation server.
//
// Parameters:
//    none
//
// Output:
//    HRESULT        - S_OK

HRESULT UnregisterAllObjects(void)
{
    int x = 0;

    // loop through all of our creatable objects [those that have a clsid in
    // our global table] and register them.
    //
    while (!ISEMPTYOBJECT(x)) {
#ifdef _DEBUG
CONTROLOBJECTINFO* pinfo = (CONTROLOBJECTINFO*) g_ObjectInfo[x].pInfo;
#endif

        if (!OBJECTISCREATABLE(x)) {
            x++;
            continue;
        }

        switch (g_ObjectInfo[x].usType) {

            case OI_UNKNOWN:
            case OI_PROPERTYPAGE:
                UnregisterUnknownObject(CLSIDOFOBJECT(x));
                break;

            case OI_CONTROL:
                UnregisterControlObject(g_szLibName, NAMEOFOBJECT(x),
                    VERSIONOFOBJECT(x), CLSIDOFOBJECT(x));

            case OI_AUTOMATION:
                UnregisterAutomationObject(g_szLibName, NAMEOFOBJECT(x),
                    VERSIONOFOBJECT(x), CLSIDOFOBJECT(x));
                break;

        }
        x++;
    }

    /*
     * if we've got one, unregister our type library [this isn't an API
     * function -- we've implemented this ourselves]
     */

    if (g_pLibid)
        UnregisterTypeLibrary(*g_pLibid);

    return S_OK;
}

//=--------------------------------------------------------------------------=
// UnregisterData
//=--------------------------------------------------------------------------=
// inproc server writers should unregister anything they registered in
// RegisterData() here.
//
// Output:
//    BOOL            - false means failure.

BOOL UnregisterData(void)
{
    HRESULT hr;

    hr = UnRegisterCLSIDInCategory(CLSID_HHCtrl, CATID_SafeForScripting);
    hr = UnRegisterCLSIDInCategory(CLSID_HHCtrl, CATID_SafeForInitializing);
    return TRUE;
}