A Simple Resource Manager

• Download source files - 1.78 Kb

Introduction

I have created this class to help me load a different resource DLL if it is present during runtime. An example would be a multi-language application. If another resource DLL (with a name specified at compile time) is present, it can load and use it as the resource for the application.

Let's look at the class header. It is quite simple and I think the comments describe well about the individual methods.

class CResourceManager  
{
// Operations

public:

    // Constructor

    CResourceManager();

    // Destructor

    virtual ~CResourceManager();

    // Load external resource dll. If file not present or unable to load,

    // it returns FALSE. If it is present, it is loaded but does not affect

    // the default resource of the application. You should call this if you

    // want to manage the current application resource and an external one.

    BOOL Setup(CString);

    // Load external resource dll and set it as default for application.

    // Before setting as default, the current resource handle is stored

    // in case when you need to access the resource there.

    // If file not present or unable to load, the current application

    // resource is being used. 

    BOOL SetupEx(CString);

    // Get string from string table of external resource if any

    // If there is an external resource loaded, GetString will retrieve from

    // there. If not, it will retrieve from the application default resource.

    CString GetString(UINT);

// Attributes

private:

    HINSTANCE m_hExternalResource; // Handle to external resource loaded

    HINSTANCE m_hApplicationResource; // Handle to current application resource

};

Using the code

Below is an example of how you may use the methods of the class. First you need to create an object of CResourceManager. You can put it as global or as a member of your application class. Then, call the Setup(...) method in InitInstance(...) as shown below.

BOOL CtestApp::InitInstance()
{
    // InitCommonControls() is required on Windows XP if an application

    // manifest specifies use of ComCtl32.dll version 6 or later to enable

    // visual styles.  Otherwise, any window creation will fail.

    InitCommonControls();

    CWinApp::InitInstance();

    // Initialize OLE libraries

    if (!AfxOleInit())
    {
        AfxMessageBox(IDP_OLE_INIT_FAILED);
        return FALSE;
    }
    AfxEnableControlContainer();



    // Load and set the specified resource dll as default if it is present.

    // Normally the location of the dll would be the same as the executable

    // and you would need to determine it with GetModuleFileName(...), but

    // in this case, i assume i know where the dll is located.

    m_oResourceManager.SetupEx(_T("C:\\MyProjects\\anotherres.dll"));

    .
    .
    .
    
    // The one and only window has been initialized, so show and update it

    m_pMainWnd->ShowWindow(SW_SHOW);
    m_pMainWnd->UpdateWindow();
    // call DragAcceptFiles only if there's a suffix

    //  In an SDI app, this should occur after ProcessShellCommand

    return TRUE;
}

As for cleaning up the loaded resource DLL, the destructor will handle it as shown below.

CResourceManager::~CResourceManager()
{
    // Check if handle is valid, free library

    if (m_hExternalResource != NULL)
        FreeLibrary(m_hExternalResource);

    // Init handles

    m_hExternalResource = NULL;
    m_hApplicationResource = NULL;
}

Points of interest

I admit that this class do fall short in terms of the other resource problems that could be addressed, but feel free to extend it if you want. :)