Click here to Skip to main content
15,074,668 members
Articles / Desktop Programming / WTL
Posted 27 Jan 2003


80 bookmarked

Mix up WTL with MFC

Rate me:
Please Sign up or sign in to vote.
4.76/5 (21 votes)
27 Jan 2003Public Domain7 min read
An easy way to enhance MFC windows with WTL templates

Sample Image - mixed.png

What is it?

This article presents a way to use WTL template classes on MFC window classes, that is how to transform the MFC CWnd class to its ATL/WTL counterpart CWindow, while leaving the class usable from MFC code.

Here you can find the required files, a detailed explanation in 10 steps and a working demo.

How to do it, step by step

These are the basic steps to obtain hybrid MFC/WTL windows. They have been used on MFC dialog based projects, but should work with any MFC application.

Add WTL support to an MFC application

  1. Take an MFC project you want to modify so that it supports ATL/WTL functions and classes.
  2. Open its precompiled header file (usually "stdafx.h") and add the following lines:
    // Add support for ATL/WTL

    This prevents the WTL headers to automatically merge the WTL namespace to the global namespace. This avoids conflicts with MFC classes with the same names, such as CRect, CDC and others.

    #include <atlbase.h>
    #include <atlapp.h>
    extern WTL::CAppModule _Module;

    The ATL/WTL code may access the global _Module variable, so it must have external linkage.

    #include <atlwin.h>

    We add the common WTL header here to exploit precompiled headers, but you may want to include it only where you really need it.

  3. Open the project main file, where the CWinApp-derived class is implemented, and modify it as follows:
    // The one and only CMixedWindowApp object
    CMixedWindowApp theApp;
    WTL::CAppModule _Module;	// add this line

    The global _Module variable must be defined somewhere and this is a good place.

  4. Modify InitInstance() as follows:
    // CMixedWindowApp initialization
    BOOL CMixedWindowApp::InitInstance()
        // Initialize ATL
        _Module.Init(NULL, AfxGetInstanceHandle());
  5. If not present, add the ExitInstance() virtual function to the application object, for example using ClassWizard, then modify it as follows:
    int CMixedWindowApp::ExitInstance() 
        // Terminate ATL
        return CWinApp::ExitInstance();

Make an hybrid window class

Assume we want to add scrolling capabilities to a static bitmap control. We may want to use the WTL template class CScrollImpl<...> together with the MFC class CStatic, as there is no such a window class in MFC.

  1. Make a new class, derived from CStatic (or any other CWnd-derived class), for example using ClassWizard.
  2. Open the class header file and include any WTL header you need:
    // Add support for scrolling windows
    #include <atlscrl.h>

    Remember that if you didn't choose to use the precompiled header at point 3 above, you need to add that line here, before any other WTL header:

    #include <atlwin.h>
  3. Include the necessary header to turn a CWnd class into a CWindow. It contains a template class that defines the missing members:
    // Make this class CWindow compatible
    #include "Wnd2Window.h"

    You may want to put the above line into your precompiled header instead, like all the other WTL headers, if you use them many times, to speed up recompilation. That's completely at your choice.

  4. Then modify the class declaration to make the conversion to CWindow and to use the WTL template class you have chosen:
    class CScrollPicture : public CWnd2Window<CScrollPicture, CStatic>,
                           public WTL::CScrollImpl<CScrollPicture>
  5. Add any other function the WTL class may require, paying attention to specify the WTL namespace for its arguments. In this example we need to implement DoPaint() to work with scrolling:
  6. public:
        // Inline helper
        void DoPaint(WTL::CDCHandle dc)
        // Implement painting with scroll support
        void OnDraw(CDC* pDC);

Notes on implementation

It may be a good idea not to mix the code too much with MFC and WTL classes used anywhere, as it could become quite confusing. An efficient way could be defining inline helper functions that translates WTL arguments to their MFC counterpart, unless you want to write the required functions using only WTL. Note that you can safely mix WTL objects with MFC code, but you always need to specify the WTL namespace when appropriate.

Using helper functions could also make writing "bridge" classes easier. For example, you could define a CScrollWnd class to reuse (through inheritance) whenever you need scrolling capabilities and custom drawing, declaring a virtual OnDraw() function like in CView and CScrollView:

    // Inline helper
    void DoPaint(WTL::CDCHandle dc)

    // Must be implemented in derived class
    virtual void OnDraw(CDC* pDC) = 0;
I used a pure virtual function, but CView defines a base implementation that just fires an assertion. These are just some ideas, but feel free to suggest new.

Sounds good... but how does it work?

Well, nothing special or mysterious. The ATL class CWindow, which is used by WTL, has only one member variable, m_hWnd, that is exactly the same as the one you can find in the CWnd class. So all the CWindow member functions need just that member variable, that can also be found in a CWnd-derived class.

What I did was to copy all the CWindow members, except m_hWnd, to a include file and define a new template class.

template <class T, class TBase> class CWnd2Window : public TBase

To use the template you need to pass both the derived class and the base class, as you can see in the example above about a scrolling control.

Then I added the necessary code to enable WTL message maps. I implemented the MFC function DefWindowProc(), that is called after WindowProc(), when no entry is found in the MFC message map.

    virtual LRESULT DefWindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam)
        T* pT = static_cast<T*>(this);

        LRESULT lResult;
        if (pT->ProcessWindowMessage(m_hWnd, nMsg, wParam, lParam, lResult))
                return lResult;

        return TBase::DefWindowProc(nMsg, wParam, lParam);

Remember that WindowProc() is called first. If it is not overridden or if you pass the message to the base implementation in CWnd, the MFC message handler is called. If the corresponding entry is not found in the MFC message map or if you call the base implementation in your message handler or if you explicitly call Default(), the message finally arrives to DefWindowProc() that calls the ATL/WTL message map implementation.

Note that you don't have to change the MFC message map macros, that skip to the MFC base class ignoring the intermediate template CWnd2Window. I don't define an MFC message map there, so this is perfectly legal.

I also commented out "dangerous" member functions already defined by MFC, such as Attach(), Detach(), CreateWindow() and DestroyWindow(), but there may be others to comment out I'm not aware of. As far as I know Attach/Detach deal with CWnd maps, while CreateWindow/DestroyWindow set up Windows hooks or call some virtual functions. So if you still want to use your class as a CWnd, you need to call the original functions, not those defined by CWindow.

There may be also some functions identical to the MFC ones, that could be removed. Feel free to suggest improvements.

So far, so good... but what changes?

Well, you have to pay attention to a few things:

  • You need to explicitly specify namespaces when accessing WTL objects, which is not a bad practice anyway.
  • And you may find that the compiler complains about some member functions of your hybrid classes. That's because many CWnd and CWindow members have the same name and you must resolve the ambiguity to compile.

That's all. I just used this method a couple of times, so I'm not aware of any other problems. But I expect comments...


I suppose you can freely use the code as long as you have the right to use ATL source code. There is no original code here, except for the CScrollPicture class, only a nice idea. All the source code by me is released to the public domain, you may do what you want with it. As for the CWnd2Window class, almost all the code is copyright of Microsoft Corporation.

The demo project

In the attached demo project you can find a very simple implementation of a scrolling picture control. Since I subclass a CStatic control, I need to override the default behaviour sometimes. A much cleaner implementation would have used a CWnd, but that way I can show that message routing works as expected, even mixing MFC message handlers with WindowProc().

To test the control use the mouse on the scroll bars or move the focus on it and use the keyboard arrows, holding down the CTRL key to scroll by pages. There is no focus indicator, so you have to guess by exclusion. There is also a button to load external BMP files.

Please note that this control is not meant to be fully featured, but only an example of use for WTL templates in MFC projects. In particular, I expect bugs if the control is used in a resizable dialog, as to my experience the WTL classes that implement scrolling are not "perfect" from that point of view. I'm working on a replacement class, but no time to release it yet.

Any idea to improve this article, please let me know!


This article, along with any associated source code and files, is licensed under A Public Domain dedication


About the Author

Paolo Messina
Technical Lead RoboTech srl
Italy Italy
Paolo began programming at the age of 9 with a glorious Olivetti M24 (i8086) and GW-BASIC, then he played a bit with Turbo C, Turbo Pascal and Assembly (using the MS-DOS Debug). Quick BASIC and Visual Basic shortly followed, until he learned C++ in College. He tought himself MFC and Windows programming, along with some DHTML and Javascript.

Always attracted by low-level programming and Assembly, he started to appreciate the joys of templates and STL while working for his Master Thesis. For seven months he was playing with airplanes and automatic control at the Unversity of Illinois at Urbana-Champaign, where he first met QNX and embedded systems.

In his job experience he learned Java to develop user interfaces and graphical editors, and re-discovered the Eclipse IDE that he had used in its early versions with the QNX SDK. He also deepened his knowledge of Linux and embedded systems, microcontrollers firmware and embedded voice recognition, while also practicing electronics design.

He graduated in Computer Engineering (Ingegneria informatica) at the University of Pisa, Italy, in December 2003. Currently working for an electronics and robotics company (

He lives in Peccioli (Pisa) and Follonica (GR), Italy.

Comments and Discussions

Questionvc2010:// error C2039: 'CString' : is not a member of 'ATL' Pin
Funfound22-Apr-12 6:29
MemberFunfound22-Apr-12 6:29 
AnswerRe: vc2010:// error C2039: 'CString' : is not a member of 'ATL' Pin
Paolo Messina23-Apr-12 0:05
professionalPaolo Messina23-Apr-12 0:05 
AnswerRe: vc2010:// error C2039: 'CString' : is not a member of 'ATL' Pin
free2000fly3-Jul-13 14:05
Memberfree2000fly3-Jul-13 14:05 
GeneralRe: vc2010:// error C2039: 'CString' : is not a member of 'ATL' Pin
raistlin9992-Mar-15 21:17
Memberraistlin9992-Mar-15 21:17 
AnswerRe: vc2010:// error C2039: 'CString' : is not a member of 'ATL' Pin
zhivot23-Apr-15 16:01
Memberzhivot23-Apr-15 16:01 
Questionuse MFC in WTL based project Pin
wshcdr20-May-09 18:55
Memberwshcdr20-May-09 18:55 
GeneralDeriving from WTL::CSpinListBox : help needed Pin
Vince Ricci23-Mar-07 1:12
MemberVince Ricci23-Mar-07 1:12 
GeneralRe: Deriving from WTL::CSpinListBox : help needed Pin
Alain Rist16-Apr-07 15:09
MemberAlain Rist16-Apr-07 15:09 
GeneralOnly works for a limited subset of WTL Pin
roel_5-Mar-07 23:02
Memberroel_5-Mar-07 23:02 
GeneralRe: Only works for a limited subset of WTL Pin
Paolo Messina5-Mar-07 23:52
professionalPaolo Messina5-Mar-07 23:52 
GeneralRe: Only works for a limited subset of WTL Pin
roel_6-Mar-07 0:03
Memberroel_6-Mar-07 0:03 
GeneralRe: Only works for a limited subset of WTL Pin
roel_6-Mar-07 0:22
Memberroel_6-Mar-07 0:22 
GeneralRe: Only works for a limited subset of WTL Pin
roel_11-Mar-07 22:36
Memberroel_11-Mar-07 22:36 
GeneralRe: Only works for a limited subset of WTL Pin
hellomytools17-Jun-09 17:20
Memberhellomytools17-Jun-09 17:20 
QuestionCompile error: WTL 8.0 VS6 + MFC42 Pin
matakk17-Dec-06 18:01
Membermatakk17-Dec-06 18:01 
GeneralChanging the Mainfrm basecalss Pin
Maryam Kasravi27-Nov-06 1:53
MemberMaryam Kasravi27-Nov-06 1:53 
GeneralRe: Changing the Mainfrm basecalss Pin
Paolo Messina27-Nov-06 3:45
professionalPaolo Messina27-Nov-06 3:45 
Generaladding MFC support into WTL project Pin
Maryam Kasravi21-Nov-06 23:55
MemberMaryam Kasravi21-Nov-06 23:55 
GeneralRe: adding MFC support into WTL project Pin
Paolo Messina27-Nov-06 3:35
professionalPaolo Messina27-Nov-06 3:35 
GeneralWTL Oscilloscope classes in a MFC Project Pin
Member 181305413-Jun-05 5:37
MemberMember 181305413-Jun-05 5:37 
GeneralHelp Pin
peipeishu24-Feb-05 8:04
Memberpeipeishu24-Feb-05 8:04 
GeneralRe: Help Pin
Paolo Messina26-Feb-05 8:56
professionalPaolo Messina26-Feb-05 8:56 
GeneralRe: Help Pin
peipeishu9-Mar-05 12:26
Memberpeipeishu9-Mar-05 12:26 
GeneralPlease Translate CWindow to CWnd again Pin
yixiu19-Feb-05 22:45
Memberyixiu19-Feb-05 22:45 
GeneralRe: Please Translate CWindow to CWnd again Pin
Paolo Messina20-Feb-05 22:04
professionalPaolo Messina20-Feb-05 22:04 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.