src/msw/frame.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/frame.cpp
   3 // Purpose:     wxFrame
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "frame.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/frame.h"
  33     #include "wx/app.h"
  34     #include "wx/menu.h"
  35     #include "wx/utils.h"
  36     #include "wx/dialog.h"
  37     #include "wx/settings.h"
  38     #include "wx/dcclient.h"
  39     #include "wx/mdi.h"
  40     #include "wx/panel.h"
  41 #endif // WX_PRECOMP
  42
  43 #include "wx/msw/private.h"
  44
  45 #if wxUSE_STATUSBAR
  46     #include "wx/statusbr.h"
  47     #include "wx/generic/statusbr.h"
  48 #endif // wxUSE_STATUSBAR
  49
  50 #if wxUSE_TOOLBAR
  51     #include "wx/toolbar.h"
  52 #endif // wxUSE_TOOLBAR
  53
  54 #include "wx/menuitem.h"
  55 #include "wx/log.h"
  56
  57 #ifdef __WXUNIVERSAL__
  58     #include "wx/univ/theme.h"
  59     #include "wx/univ/colschem.h"
  60 #endif // __WXUNIVERSAL__
  61
  62 // ----------------------------------------------------------------------------
  63 // globals
  64 // ----------------------------------------------------------------------------
  65
  66 #if wxUSE_MENUS_NATIVE
  67     extern wxMenu *wxCurrentPopupMenu;
  68 #endif // wxUSE_MENUS_NATIVE
  69
  70 // ----------------------------------------------------------------------------
  71 // event tables
  72 // ----------------------------------------------------------------------------
  73
  74 BEGIN_EVENT_TABLE(wxFrame, wxFrameBase)
  75     EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
  76 END_EVENT_TABLE()
  77
  78 IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxTopLevelWindow)
  79
  80 // ============================================================================
  81 // implementation
  82 // ============================================================================
  83
  84 // ----------------------------------------------------------------------------
  85 // static class members
  86 // ----------------------------------------------------------------------------
  87
  88 #if wxUSE_STATUSBAR
  89     #if wxUSE_NATIVE_STATUSBAR
  90         bool wxFrame::m_useNativeStatusBar = TRUE;
  91     #else
  92         bool wxFrame::m_useNativeStatusBar = FALSE;
  93     #endif
  94 #endif // wxUSE_NATIVE_STATUSBAR
  95
  96 // ----------------------------------------------------------------------------
  97 // creation/destruction
  98 // ----------------------------------------------------------------------------
  99
 100 void wxFrame::Init()
 101 {
 102 #if wxUSE_TOOLTIPS
 103     m_hwndToolTip = 0;
 104 #endif
 105
 106     // Data to save/restore when calling ShowFullScreen
 107     m_fsStatusBarFields = 0;
 108     m_fsStatusBarHeight = 0;
 109     m_fsToolBarHeight = 0;
 110
 111     m_wasMinimized = FALSE;
 112 }
 113
 114 bool wxFrame::Create(wxWindow *parent,
 115                      wxWindowID id,
 116                      const wxString& title,
 117                      const wxPoint& pos,
 118                      const wxSize& size,
 119                      long style,
 120                      const wxString& name)
 121 {
 122     if ( !wxTopLevelWindow::Create(parent, id, title, pos, size, style, name) )
 123         return FALSE;
 124
 125     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
 126
 127     wxModelessWindows.Append(this);
 128
 129     return TRUE;
 130 }
 131
 132 wxFrame::~wxFrame()
 133 {
 134     m_isBeingDeleted = TRUE;
 135
 136     DeleteAllBars();
 137 }
 138
 139 // ----------------------------------------------------------------------------
 140 // wxFrame client size calculations
 141 // ----------------------------------------------------------------------------
 142
 143 void wxFrame::DoSetClientSize(int width, int height)
 144 {
 145     // leave enough space for the status bar if we have (and show) it
 146 #if wxUSE_STATUSBAR
 147     wxStatusBar *statbar = GetStatusBar();
 148     if ( statbar && statbar->IsShown() )
 149     {
 150         height += statbar->GetSize().y;
 151     }
 152 #endif // wxUSE_STATUSBAR
 153
 154     // call GetClientAreaOrigin() to take the toolbar into account
 155     wxPoint pt = GetClientAreaOrigin();
 156     width += pt.x;
 157     height += pt.y;
 158
 159     wxTopLevelWindow::DoSetClientSize(width, height);
 160 }
 161
 162 // Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
 163 void wxFrame::DoGetClientSize(int *x, int *y) const
 164 {
 165     wxTopLevelWindow::DoGetClientSize(x, y);
 166
 167     // account for the possible toolbar
 168     wxPoint pt = GetClientAreaOrigin();
 169     if ( x )
 170         *x -= pt.x;
 171
 172     if ( y )
 173         *y -= pt.y;
 174
 175 #if wxUSE_STATUSBAR
 176     // adjust client area height to take the status bar into account
 177     if ( y )
 178     {
 179         wxStatusBar *statbar = GetStatusBar();
 180         if ( statbar && statbar->IsShown() )
 181         {
 182             *y -= statbar->GetClientSize().y;
 183         }
 184     }
 185 #endif // wxUSE_STATUSBAR
 186 }
 187
 188 // ----------------------------------------------------------------------------
 189 // wxFrame: various geometry-related functions
 190 // ----------------------------------------------------------------------------
 191
 192 void wxFrame::Raise()
 193 {
 194 #ifdef __WIN16__
 195     // no SetForegroundWindow() in Win16
 196     wxFrameBase::Raise();
 197 #else // Win32
 198     ::SetForegroundWindow(GetHwnd());
 199 #endif // Win16/32
 200 }
 201
 202 // generate an artificial resize event
 203 void wxFrame::SendSizeEvent()
 204 {
 205     if ( !m_iconized )
 206     {
 207         RECT r = wxGetWindowRect(GetHwnd());
 208
 209         (void)::PostMessage(GetHwnd(), WM_SIZE,
 210                             IsMaximized() ? SIZE_MAXIMIZED : SIZE_RESTORED,
 211                             MAKELPARAM(r.right - r.left, r.bottom - r.top));
 212     }
 213 }
 214
 215 #if wxUSE_STATUSBAR
 216 wxStatusBar *wxFrame::OnCreateStatusBar(int number,
 217                                         long style,
 218                                         wxWindowID id,
 219                                         const wxString& name)
 220 {
 221     wxStatusBar *statusBar = NULL;
 222
 223 #if wxUSE_NATIVE_STATUSBAR
 224     if ( !UsesNativeStatusBar() )
 225     {
 226         statusBar = (wxStatusBar *)new wxStatusBarGeneric(this, id, style);
 227     }
 228     else
 229 #endif
 230     {
 231         statusBar = new wxStatusBar(this, id, style, name);
 232     }
 233
 234     statusBar->SetFieldsCount(number);
 235
 236     return statusBar;
 237 }
 238
 239 void wxFrame::PositionStatusBar()
 240 {
 241     if ( !m_frameStatusBar || !m_frameStatusBar->IsShown() )
 242         return;
 243
 244     int w, h;
 245     GetClientSize(&w, &h);
 246     int sw, sh;
 247     m_frameStatusBar->GetSize(&sw, &sh);
 248
 249     // Since we wish the status bar to be directly under the client area,
 250     // we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
 251     m_frameStatusBar->SetSize(0, h, w, sh);
 252 }
 253 #endif // wxUSE_STATUSBAR
 254
 255 #if wxUSE_MENUS_NATIVE
 256
 257 void wxFrame::AttachMenuBar(wxMenuBar *menubar)
 258 {
 259     wxFrameBase::AttachMenuBar(menubar);
 260
 261     if ( !menubar )
 262     {
 263         // actually remove the menu from the frame
 264         m_hMenu = (WXHMENU)0;
 265         InternalSetMenuBar();
 266     }
 267     else // set new non NULL menu bar
 268     {
 269         // Can set a menubar several times.
 270         if ( menubar->GetHMenu() )
 271         {
 272             m_hMenu = menubar->GetHMenu();
 273         }
 274         else // no HMENU yet
 275         {
 276             m_hMenu = menubar->Create();
 277
 278             if ( !m_hMenu )
 279             {
 280                 wxFAIL_MSG( _T("failed to create menu bar") );
 281                 return;
 282             }
 283         }
 284
 285         InternalSetMenuBar();
 286     }
 287 }
 288
 289 void wxFrame::InternalSetMenuBar()
 290 {
 291 #ifndef __WXMICROWIN__
 292     if ( !::SetMenu(GetHwnd(), (HMENU)m_hMenu) )
 293     {
 294         wxLogLastError(wxT("SetMenu"));
 295     }
 296 #endif
 297 }
 298
 299 #endif // wxUSE_MENUS_NATIVE
 300
 301 // Responds to colour changes, and passes event on to children.
 302 void wxFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
 303 {
 304     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
 305     Refresh();
 306
 307 #if wxUSE_STATUSBAR
 308     if ( m_frameStatusBar )
 309     {
 310         wxSysColourChangedEvent event2;
 311         event2.SetEventObject( m_frameStatusBar );
 312         m_frameStatusBar->GetEventHandler()->ProcessEvent(event2);
 313     }
 314 #endif // wxUSE_STATUSBAR
 315
 316     // Propagate the event to the non-top-level children
 317     wxWindow::OnSysColourChanged(event);
 318 }
 319
 320 // Pass TRUE to show full screen, FALSE to restore.
 321 bool wxFrame::ShowFullScreen(bool show, long style)
 322 {
 323     if ( IsFullScreen() == show )
 324         return FALSE;
 325
 326     if (show)
 327     {
 328 #if wxUSE_TOOLBAR
 329         wxToolBar *theToolBar = GetToolBar();
 330         if (theToolBar)
 331             theToolBar->GetSize(NULL, &m_fsToolBarHeight);
 332
 333         // zap the toolbar, menubar, and statusbar
 334
 335         if ((style & wxFULLSCREEN_NOTOOLBAR) && theToolBar)
 336         {
 337             theToolBar->SetSize(-1,0);
 338             theToolBar->Show(FALSE);
 339         }
 340 #endif // wxUSE_TOOLBAR
 341
 342 #ifndef __WXMICROWIN__
 343         if (style & wxFULLSCREEN_NOMENUBAR)
 344             SetMenu((HWND)GetHWND(), (HMENU) NULL);
 345 #endif
 346
 347 #if wxUSE_STATUSBAR
 348         wxStatusBar *theStatusBar = GetStatusBar();
 349         if (theStatusBar)
 350             theStatusBar->GetSize(NULL, &m_fsStatusBarHeight);
 351
 352         // Save the number of fields in the statusbar
 353         if ((style & wxFULLSCREEN_NOSTATUSBAR) && theStatusBar)
 354         {
 355             //m_fsStatusBarFields = theStatusBar->GetFieldsCount();
 356             //SetStatusBar((wxStatusBar*) NULL);
 357             //delete theStatusBar;
 358             theStatusBar->Show(FALSE);
 359         }
 360         else
 361             m_fsStatusBarFields = 0;
 362 #endif // wxUSE_STATUSBAR
 363     }
 364     else
 365     {
 366 #if wxUSE_TOOLBAR
 367         wxToolBar *theToolBar = GetToolBar();
 368
 369         // restore the toolbar, menubar, and statusbar
 370         if (theToolBar && (m_fsStyle & wxFULLSCREEN_NOTOOLBAR))
 371         {
 372             theToolBar->SetSize(-1, m_fsToolBarHeight);
 373             theToolBar->Show(TRUE);
 374         }
 375 #endif // wxUSE_TOOLBAR
 376
 377 #if wxUSE_STATUSBAR
 378         if ( m_fsStyle & wxFULLSCREEN_NOSTATUSBAR )
 379         {
 380             //CreateStatusBar(m_fsStatusBarFields);
 381             if (GetStatusBar())
 382             {
 383                 GetStatusBar()->Show(TRUE);
 384                 PositionStatusBar();
 385             }
 386         }
 387 #endif // wxUSE_STATUSBAR
 388
 389 #ifndef __WXMICROWIN__
 390         if ((m_fsStyle & wxFULLSCREEN_NOMENUBAR) && (m_hMenu != 0))
 391             SetMenu((HWND)GetHWND(), (HMENU)m_hMenu);
 392 #endif
 393     }
 394
 395     return wxFrameBase::ShowFullScreen(show, style);
 396 }
 397
 398 // ----------------------------------------------------------------------------
 399 // tool/status bar stuff
 400 // ----------------------------------------------------------------------------
 401
 402 #if wxUSE_TOOLBAR
 403
 404 wxToolBar* wxFrame::CreateToolBar(long style, wxWindowID id, const wxString& name)
 405 {
 406     if ( wxFrameBase::CreateToolBar(style, id, name) )
 407     {
 408         PositionToolBar();
 409     }
 410
 411     return m_frameToolBar;
 412 }
 413
 414 void wxFrame::PositionToolBar()
 415 {
 416     wxToolBar *toolbar = GetToolBar();
 417     if ( toolbar && toolbar->IsShown() )
 418     {
 419         // don't call our (or even wxTopLevelWindow) version because we want
 420         // the real (full) client area size, not excluding the tool/status bar
 421         int width, height;
 422         wxWindow::DoGetClientSize(&width, &height);
 423
 424 #if wxUSE_STATUSBAR
 425         wxStatusBar *statbar = GetStatusBar();
 426         if ( statbar && statbar->IsShown() )
 427         {
 428             height -= statbar->GetClientSize().y;
 429         }
 430 #endif // wxUSE_STATUSBAR
 431
 432         int tw, th;
 433         toolbar->GetSize(&tw, &th);
 434
 435         if ( toolbar->GetWindowStyleFlag() & wxTB_VERTICAL )
 436         {
 437             th = height;
 438         }
 439         else
 440         {
 441             tw = width;
 442             if ( toolbar->GetWindowStyleFlag() & wxTB_FLAT )
 443                 th -= 3;
 444         }
 445
 446         // use the 'real' MSW position here, don't offset relativly to the
 447         // client area origin
 448         toolbar->SetSize(0, 0, tw, th, wxSIZE_NO_ADJUSTMENTS);
 449     }
 450 }
 451
 452 #endif // wxUSE_TOOLBAR
 453
 454 // ----------------------------------------------------------------------------
 455 // frame state (iconized/maximized/...)
 456 // ----------------------------------------------------------------------------
 457
 458 // propagate our state change to all child frames: this allows us to emulate X
 459 // Windows behaviour where child frames float independently of the parent one
 460 // on the desktop, but are iconized/restored with it
 461 void wxFrame::IconizeChildFrames(bool bIconize)
 462 {
 463     for ( wxWindowList::Node *node = GetChildren().GetFirst();
 464           node;
 465           node = node->GetNext() )
 466     {
 467         wxWindow *win = node->GetData();
 468
 469         // iconizing the frames with this style under Win95 shell puts them at
 470         // the bottom of the screen (as the MDI children) instead of making
 471         // them appear in the taskbar because they are, by virtue of this
 472         // style, not managed by the taskbar - instead leave Windows take care
 473         // of them
 474 #ifdef __WIN95__
 475         if ( win->GetWindowStyle() & wxFRAME_TOOL_WINDOW )
 476             continue;
 477 #endif // Win95
 478
 479         // the child MDI frames are a special case and should not be touched by
 480         // the parent frame - instead, they are managed by the user
 481         wxFrame *frame = wxDynamicCast(win, wxFrame);
 482         if ( frame
 483 #if wxUSE_MDI_ARCHITECTURE
 484                 && !wxDynamicCast(frame, wxMDIChildFrame)
 485 #endif // wxUSE_MDI_ARCHITECTURE
 486            )
 487         {
 488             // we don't want to restore the child frames which had been
 489             // iconized even before we were iconized, so save the child frame
 490             // status when iconizing the parent frame and check it when
 491             // restoring it
 492             if ( bIconize )
 493             {
 494                 // note that we shouldn't touch the hidden frames neither
 495                 // because iconizing/restoring them would show them as a side
 496                 // effect
 497                 frame->m_wasMinimized = frame->IsIconized() || !frame->IsShown();
 498             }
 499
 500             // this test works for both iconizing and restoring
 501             if ( !frame->m_wasMinimized )
 502                 frame->Iconize(bIconize);
 503         }
 504     }
 505 }
 506
 507 WXHICON wxFrame::GetDefaultIcon() const
 508 {
 509     return (WXHICON)(wxSTD_FRAME_ICON ? wxSTD_FRAME_ICON
 510                                       : wxDEFAULT_FRAME_ICON);
 511 }
 512
 513 // ===========================================================================
 514 // message processing
 515 // ===========================================================================
 516
 517 // ---------------------------------------------------------------------------
 518 // preprocessing
 519 // ---------------------------------------------------------------------------
 520
 521 bool wxFrame::MSWTranslateMessage(WXMSG* pMsg)
 522 {
 523     if ( wxWindow::MSWTranslateMessage(pMsg) )
 524         return TRUE;
 525
 526 #if wxUSE_MENUS && wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
 527     // try the menu bar accels
 528     wxMenuBar *menuBar = GetMenuBar();
 529     if ( !menuBar )
 530         return FALSE;
 531
 532     const wxAcceleratorTable& acceleratorTable = menuBar->GetAccelTable();
 533     return acceleratorTable.Translate(this, pMsg);
 534 #else
 535     return FALSE;
 536 #endif // wxUSE_MENUS && wxUSE_ACCEL
 537 }
 538
 539 // ---------------------------------------------------------------------------
 540 // our private (non virtual) message handlers
 541 // ---------------------------------------------------------------------------
 542
 543 bool wxFrame::HandlePaint()
 544 {
 545     RECT rect;
 546     if ( GetUpdateRect(GetHwnd(), &rect, FALSE) )
 547     {
 548 #ifndef __WXMICROWIN__
 549         if ( m_iconized )
 550         {
 551             const wxIcon& icon = GetIcon();
 552             HICON hIcon = icon.Ok() ? GetHiconOf(icon)
 553                                     : (HICON)GetDefaultIcon();
 554
 555             // Hold a pointer to the dc so long as the OnPaint() message
 556             // is being processed
 557             PAINTSTRUCT ps;
 558             HDC hdc = ::BeginPaint(GetHwnd(), &ps);
 559
 560             // Erase background before painting or we get white background
 561             MSWDefWindowProc(WM_ICONERASEBKGND, (WORD)(LONG)ps.hdc, 0L);
 562
 563             if ( hIcon )
 564             {
 565                 RECT rect;
 566                 ::GetClientRect(GetHwnd(), &rect);
 567
 568                 // FIXME: why hardcoded?
 569                 static const int icon_width = 32;
 570                 static const int icon_height = 32;
 571
 572                 int icon_x = (int)((rect.right - icon_width)/2);
 573                 int icon_y = (int)((rect.bottom - icon_height)/2);
 574
 575                 ::DrawIcon(hdc, icon_x, icon_y, hIcon);
 576             }
 577
 578             ::EndPaint(GetHwnd(), &ps);
 579
 580             return TRUE;
 581         }
 582         else
 583  #endif
 584         {
 585             return wxWindow::HandlePaint();
 586         }
 587     }
 588     else
 589     {
 590         // nothing to paint - processed
 591         return TRUE;
 592     }
 593 }
 594
 595 bool wxFrame::HandleSize(int x, int y, WXUINT id)
 596 {
 597     bool processed = FALSE;
 598 #ifndef __WXMICROWIN__
 599
 600     switch ( id )
 601     {
 602         case SIZENORMAL:
 603             // only do it it if we were iconized before, otherwise resizing the
 604             // parent frame has a curious side effect of bringing it under it's
 605             // children
 606             if ( !m_iconized )
 607                 break;
 608
 609             // restore all child frames too
 610             IconizeChildFrames(FALSE);
 611
 612             (void)SendIconizeEvent(FALSE);
 613
 614             // fall through
 615
 616         case SIZEFULLSCREEN:
 617             m_iconized = FALSE;
 618             break;
 619
 620         case SIZEICONIC:
 621             // iconize all child frames too
 622             IconizeChildFrames(TRUE);
 623
 624             (void)SendIconizeEvent();
 625
 626             m_iconized = TRUE;
 627             break;
 628     }
 629 #endif
 630
 631     if ( !m_iconized )
 632     {
 633 #if wxUSE_STATUSBAR
 634         PositionStatusBar();
 635 #endif // wxUSE_STATUSBAR
 636
 637 #if wxUSE_TOOLBAR
 638         PositionToolBar();
 639 #endif // wxUSE_TOOLBAR
 640
 641         processed = wxWindow::HandleSize(x, y, id);
 642     }
 643
 644     return processed;
 645 }
 646
 647 bool wxFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
 648 {
 649     if ( control )
 650     {
 651         // In case it's e.g. a toolbar.
 652         wxWindow *win = wxFindWinFromHandle(control);
 653         if ( win )
 654             return win->MSWCommand(cmd, id);
 655     }
 656
 657     // handle here commands from menus and accelerators
 658     if ( cmd == 0 || cmd == 1 )
 659     {
 660 #if wxUSE_MENUS_NATIVE
 661         if ( wxCurrentPopupMenu )
 662         {
 663             wxMenu *popupMenu = wxCurrentPopupMenu;
 664             wxCurrentPopupMenu = NULL;
 665
 666             return popupMenu->MSWCommand(cmd, id);
 667         }
 668 #endif // wxUSE_MENUS_NATIVE
 669
 670         if ( ProcessCommand(id) )
 671         {
 672             return TRUE;
 673         }
 674     }
 675
 676     return FALSE;
 677 }
 678
 679 bool wxFrame::HandleMenuSelect(WXWORD nItem, WXWORD flags, WXHMENU hMenu)
 680 {
 681     int item;
 682     if ( flags == 0xFFFF && hMenu == 0 )
 683     {
 684         // menu was removed from screen
 685         item = -1;
 686     }
 687 #ifndef __WXMICROWIN__
 688     else if ( !(flags & MF_POPUP) && !(flags & MF_SEPARATOR) )
 689     {
 690         item = nItem;
 691     }
 692 #endif
 693     else
 694     {
 695         // don't give hints for separators (doesn't make sense) nor for the
 696         // items opening popup menus (they don't have them anyhow) but do clear
 697         // the status line - otherwise, we would be left with the help message
 698         // for the previous item which doesn't apply any more
 699         DoGiveHelp(wxEmptyString, FALSE);
 700
 701         return FALSE;
 702     }
 703
 704     wxMenuEvent event(wxEVT_MENU_HIGHLIGHT, item);
 705     event.SetEventObject(this);
 706
 707     return GetEventHandler()->ProcessEvent(event);
 708 }
 709
 710 bool wxFrame::HandleMenuLoop(const wxEventType& evtType, WXWORD isPopup)
 711 {
 712     // we don't have the menu id here, so we use the id to specify if the event
 713     // was from a popup menu or a normal one
 714     wxMenuEvent event(evtType, isPopup ? -1 : 0);
 715     event.SetEventObject(this);
 716
 717     return GetEventHandler()->ProcessEvent(event);
 718 }
 719
 720 // ---------------------------------------------------------------------------
 721 // the window proc for wxFrame
 722 // ---------------------------------------------------------------------------
 723
 724 long wxFrame::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
 725 {
 726     long rc = 0;
 727     bool processed = FALSE;
 728
 729     switch ( message )
 730     {
 731         case WM_CLOSE:
 732             // if we can't close, tell the system that we processed the
 733             // message - otherwise it would close us
 734             processed = !Close();
 735             break;
 736
 737         case WM_SIZE:
 738             processed = HandleSize(LOWORD(lParam), HIWORD(lParam), wParam);
 739             break;
 740
 741         case WM_COMMAND:
 742             {
 743                 WORD id, cmd;
 744                 WXHWND hwnd;
 745                 UnpackCommand((WXWPARAM)wParam, (WXLPARAM)lParam,
 746                               &id, &hwnd, &cmd);
 747
 748                 processed = HandleCommand(id, cmd, (WXHWND)hwnd);
 749             }
 750             break;
 751
 752         case WM_PAINT:
 753             processed = HandlePaint();
 754             break;
 755
 756 #ifndef __WXMICROWIN__
 757         case WM_MENUSELECT:
 758             {
 759                 WXWORD item, flags;
 760                 WXHMENU hmenu;
 761                 UnpackMenuSelect(wParam, lParam, &item, &flags, &hmenu);
 762
 763                 processed = HandleMenuSelect(item, flags, hmenu);
 764             }
 765             break;
 766
 767 #ifndef __WIN16__
 768         case WM_ENTERMENULOOP:
 769             processed = HandleMenuLoop(wxEVT_MENU_OPEN, wParam);
 770             break;
 771
 772         case WM_EXITMENULOOP:
 773             processed = HandleMenuLoop(wxEVT_MENU_CLOSE, wParam);
 774             break;
 775 #endif // __WIN16__
 776
 777         case WM_QUERYDRAGICON:
 778             {
 779                 const wxIcon& icon = GetIcon();
 780                 HICON hIcon = icon.Ok() ? GetHiconOf(icon)
 781                                         : (HICON)GetDefaultIcon();
 782                 rc = (long)hIcon;
 783                 processed = rc != 0;
 784             }
 785             break;
 786 #endif // !__WXMICROWIN__
 787     }
 788
 789     if ( !processed )
 790         rc = wxFrameBase::MSWWindowProc(message, wParam, lParam);
 791
 792     return rc;
 793 }
 794