This is a simple article showing how one can internationalize a Windows program, changing
the menu, accelerators, dialog boxes, and common dialogs (the file open dialog is used in this example) etc.
on the fly. I have seen many questions on the newsgroups about this, but have yet
to see a good, simple, example.
This code is based on snippets of information found in various newsgroups.
The code is contained primarily in one function,
it is partially displayed below. The source code does have more comments and also
has the ability to set the language based on the PC's locale.
If a resource DLL has been loaded we should remove it, this is done in the destructor.
We simply branch on the language we want and load the relevant DLL using
The library is kept in memory once it is loaded, because removing it when a new language
was required caused problems with accelerators in NT4, this is described later.
m_hInstFrench = LoadLibrary(_T("LangFRA.dll"));
If a resource DLL was loaded we need to set the MultiLang's resource handle to
the handle of the DLL from which the application’s resources will be loaded. Otherwise
we use m_hInstEnglish, which is initially set to
AfxGetInstanceHandle(), to obtain the current instance of the application, and use that
to load the resource from the EXE.
The menu has to be changed to be the one from our resource DLL.
It should be noted that we need to get the menu from the
CMainFrame, this is because we in
effect need to force a change of any elements that are currently displayed. The dialog boxes,
as you will see will be displayed in the correct language automatically, in this example, the About box.
New is used to create the new
CMenu so we can then use
SetMenu() to set the
current menu to the new menu. This causes the window to be redrawn to
reflect the menu change.
Any other redraws etc. must be done as well, such as updating the status bar
with "Ready", using new accelerators, or re-painting any windows that display text.
CMenu *pMenuCurrent = GetMenu();
m_pMenuNew = new CMenu;
if(pMenuCurrent->m_hMenu != m_hMenuDefault)
CMainFrame::GetDate() shows how to use
_tcsftime() to display the current date the langauge we have specified.
These need to be loaded every time the language changes, during testing on NT4 it was found
that if the resource only DLL was unloaded when not required the accelerators would not change
the next time the language changed. So once loaded they stay in memory until no longer required.
Each language uses a different set of accelerators as a test.
m_hAccelTable = NULL;
bOK = LoadAccelTable(MAKEINTRESOURCE(IDR_MAINFRAME));
Custom Common Dialog
MSDN article Q102332 "How to Show a Custom Common Dialog using CFileDialog"
describes how to do this using
CFileDialog, this example uses the Win32 function
GetOpenFileName(). Although the code is the same for both methods there appears
to be a bug when using
CFileDialog and Visual C++ 6.0, this will be investigated later.
The code for this is
CMainFrame::OnFileOpen(). Visual C++ provides some templates, these can be found in one of the Visual C++ directories they have .dlg
suffices, the example uses
Fileopen.dlg, to use this do the following:-
- Find the correct template from
- Add this to your resource, open the resource as a text file to do this.
- Select the resource and using View - Resource Includes menu, add
as a "Read-only symbol directive".
#include <dlgs.h> to the source file in which
GetOpenFileName is to be used.
OFN_ENABLETEMPLATE has to be added to the Flags member of the
OPENFILENAME structure, the magic number
1537 is the resource template ID.
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST |
OFN_ENABLETEMPLATE | OFN_NONETWORKBUTTON;
ofn.hInstance = AfxGetResourceHandle();
ofn.lpTemplateName = MAKEINTRESOURCE(1537);
Should there be a mistake in the template, the dialog will not be displayed! There has to be one template
per language, so this is not an ideal solution, and every common dialog box, and
style of dialog box, that is used would need to be called this way.
Resource Code DLL
This is a "Win32 Dynamic-Link Library", a Resource Only DLL. To create it, do the following:
- Create a new project, add it to the current workplace, a Win32 Dynamic-Link Library project.
- Make it "An empty DLL Project"
- Now click "Finish"
- To the linker option add
\NOENTRY in the "Project Settings", "Linker" pane,
"Project Options" section.
- Copy all the resources from the main program to the new DLL.
- A useful trick is to create a dummy project, and select the language that you want the resources
to be in, then copy the strings, menus etc. across, this does save a bit of time.
- Possibly changing the properties to the language that matches the DLL, although this is not strictly required.
- Now "simply" translate the Strings, Menu, Dialog boxes etc.
- Certain languages will have far longer text strings than English, therefore it is likely that the dialog box layouts may change.
- The resource ID values MUST be consistent (i.e. the same) between all the resources language DLLs.
- You may find that the DLLs do not always compile correctly when doing a build, you may need to do a "Rebuild All" on them.
- The DLLs are placed into the MultiLang Release or Debug directory after linking.
- The translations were done on the Internet, so they may not be 100% correct!
- The sample project MUST be compiled using the "Build", "Batch Build" option.
- The EXE and DLLs are provided in the demo.
- Display today's date in the selected language
- Use Accelerators
- Use a Custom Common Dialog
Ted wrote his first program c. 1972, and has been writing software professionally since 1975. For his sins he has been a user of Visual C++ from version 1.0 days.
On the odd days that he leaves his PC he is into walking in the Peak District, but tends to get waylaid at the lunch time pub.