You might want to take a look at PreTranslateMsg. This is very useful for
"catching" msgs before MFC gets a shot at them.

Tom Archer

Hello-

I need to subclass a window created within MFC.  I have no
problem subclassing "normal" (non-mfc) windows using SetWindowLong().
Everything works fine in the "normal" case.

In the MFC my subclass procedure doesn't get any window messages.
Wandering through the MFC source, it would seem that they're re-subclassing
the window for thier own purposes.

My question:
How do I either
a) subclass an MFC window in such a way that I'm guaranteed to get all the
   messages first
   -- or --
b) let MFC know that there are certain messages I want dropped through to
   my subclass, and it should let them go (it appears in the MFC source
that
  most messages get filtered off).

Thanks,
Derek

Hi Derek,

Along with the reply by Tom Archer, windows in MFC are subclassed by the
CWnd function SubclassWindow.  If you use the Win32 SubclassWindow MFC
won't know about your subclass.

HTH
--
===================
Frank Hickman
SecurTech, Inc.

===================

If you're creating the window with the MFC Create() functionality, but
not seeing the messages you want in your derived class, you can
override either CWnd::PreTranslateMessage or CWnd::WindowProc.

It's not entirely clear to me from your posting why you need to
subclass the window if MFC has created it; wouldn't it be easier to
let MFC create a derived class with your special processing in it?  I
realize there are cases when this isn't the way to go, just don't have
enough information to offer more.  hth.  -steve
____________________________________________________________________
McAdams Research - http://www.CodeTools.com/showcase
  MFC Toolkit: flat-style toolbar, resizable docking windows, more

--------------------------------------------------------------------------------


XIOtech Corporation               Personal Home Page:   http://www.visi.com/~nde
Eden Prairie, MN

"Question authority...and the authorities will end up questioning YOU!"
--------------------------------------------------------------------------------

and if you use ClassWizard to do it, you'll get much of what
subclassing normally buys you.  A phrase I love to use about MFC is
that the C++ object model is almost, but not quite, totally unlike the
Windows object model; the subclassing Microsoft does is an amazing
tour-de-force that makes these two nearly disjoint object models
cooperate.

Another case, let's say you want to subclass a listbox.  Use
classWizard to declare your new class, essentially
        class MyListBox : public CListBox {...}

Now for most of the events, you just use the ClassWizard to build
handlers for the events.  Let's say this is in a dialog which you've
derived from CDialog.  Use the ClassWizard to declare a variable of
the type MyListBox, let's say 'whatever',  which will put the
following declaration in your .h file:
        MyListBox whatever;

Once your dialog has initialized, you can use the MyListBox:: methods
(and even add your own cool methods to this class), and you will get
just about everything you need.

This works well for *almost* everything.  Unfortunately, it is
sometimes necessary to really subvert the MFC mechanisms for authentic

"Windows" subclassing.  This is only moderately tricky.  I do
something like this:

add to your class definition
        DWORD m_oldproc;

then add this function

        void CMyListBox::subclass(WNDPROC proc)
                      {
                        m_oldproc = ::GetWindowLong(m_hWnd,
GWL_WNDPROC);
                        ::SetWindowLong(m_hWnd, GWL_WNDPROC,
(DWORD)proc);
                        ::SetWindowLong(m_hWnd, GWL_USERDATA,
(LPARAM)this);
                      }

Now your callback works like you'd expect....

static CALLBACK MyWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM
lParam)
     {
       CMyListBox * object = (CMyListBox *)GetWindowLong(hWnd,
GWL_USERDATA);
       ....// do your usual window stuff here
       return ::CallWindowProc(object->m_oldproc, hWmd, msg, wParam,
lParam);
     }

Note that because you've stored the 'this' pointer in GWL_USERDATA,
you can now call methods of the class to do whatever you want while
working within the MFC structure.  

But before you go through all of this, make sure that the ordinary MFC
subclassing isn't adequate for the job.  I can do probably 99% of the
subclassing I need.

(At the risk of sounding commercial, I recently completed a book on
Win32 programming that has a CDROM with 150K+ lines of MFC examples
just full of neat tricks)
                                joe