src/msw/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        windows.cpp
   3 // Purpose:     wxWindow
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "window.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24 #include <stdio.h>
  25 #include "wx/setup.h"
  26 #include "wx/menu.h"
  27 #include "wx/dc.h"
  28 #include "wx/dcclient.h"
  29 #include "wx/utils.h"
  30 #include "wx/app.h"
  31 #include "wx/panel.h"
  32 #include "wx/layout.h"
  33 #include "wx/dialog.h"
  34 #include "wx/listbox.h"
  35 #include "wx/button.h"
  36 #include "wx/settings.h"
  37 #include "wx/msgdlg.h"
  38 #endif
  39
  40 #if     USE_OWNER_DRAWN
  41 #include "wx/ownerdrw.h"
  42 #endif
  43
  44 #if     USE_DRAG_AND_DROP
  45 #include "wx/msw/ole/droptgt.h"
  46 #endif
  47
  48 #include "wx/menuitem.h"
  49 #include "wx/msw/private.h"
  50
  51 #include <string.h>
  52
  53 #ifndef __GNUWIN32__
  54 #include <shellapi.h>
  55 #include <mmsystem.h>
  56 #endif
  57
  58 #ifdef __WIN32__
  59 #include <windowsx.h>
  60 #endif
  61
  62 #ifdef __GNUWIN32__
  63 #include <wx/msw/gnuwin32/extra.h>
  64 #endif
  65
  66 #ifdef GetCharWidth
  67 #undef GetCharWidth
  68 #endif
  69
  70 #ifdef FindWindow
  71 #undef FindWindow
  72 #endif
  73
  74 #ifdef GetClassName
  75 #undef GetClassName
  76 #endif
  77
  78 #ifdef GetClassInfo
  79 #undef GetClassInfo
  80 #endif
  81
  82 #define WINDOW_MARGIN 3 // This defines sensitivity of Leave events
  83
  84 wxMenu *wxCurrentPopupMenu = NULL;
  85 extern wxList wxPendingDelete;
  86
  87 void wxRemoveHandleAssociation(wxWindow *win);
  88 void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win);
  89 wxWindow *wxFindWinFromHandle(WXHWND hWnd);
  90
  91 #if !USE_SHARED_LIBRARY
  92 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxEvtHandler)
  93
  94 BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
  95   EVT_CHAR(wxWindow::OnChar)
  96   EVT_SIZE(wxWindow::OnSize)
  97   EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
  98   EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
  99   EVT_INIT_DIALOG(wxWindow::OnInitDialog)
 100   EVT_IDLE(wxWindow::OnIdle)
 101 END_EVENT_TABLE()
 102
 103 #endif
 104
 105 // Find an item given the MS Windows id
 106 wxWindow *wxWindow::FindItem(const int id) const
 107 {
 108   if (!GetChildren())
 109     return NULL;
 110   wxNode *current = GetChildren()->First();
 111   while (current)
 112   {
 113     wxWindow *childWin = (wxWindow *)current->Data();
 114
 115     wxWindow *wnd = childWin->FindItem(id) ;
 116     if (wnd)
 117       return wnd ;
 118
 119     if (childWin->IsKindOf(CLASSINFO(wxControl)))
 120     {
 121       wxControl *item = (wxControl *)childWin;
 122       if (item->m_windowId == id)
 123         return item;
 124       else
 125       {
 126         // In case it's a 'virtual' control (e.g. radiobox)
 127         if (item->GetSubcontrols().Member((wxObject *)id))
 128           return item;
 129       }
 130     }
 131     current = current->Next();
 132   }
 133   return NULL;
 134 }
 135
 136 // Find an item given the MS Windows handle
 137 wxWindow *wxWindow::FindItemByHWND(const WXHWND hWnd, bool controlOnly) const
 138 {
 139   if (!GetChildren())
 140     return NULL;
 141   wxNode *current = GetChildren()->First();
 142   while (current)
 143   {
 144     wxObject *obj = (wxObject *)current->Data() ;
 145     // Do a recursive search.
 146     wxWindow *parent = (wxWindow *)obj ;
 147     wxWindow *wnd = parent->FindItemByHWND(hWnd) ;
 148     if (wnd)
 149       return wnd ;
 150
 151     if ((!controlOnly) || obj->IsKindOf(CLASSINFO(wxControl)))
 152     {
 153       wxWindow *item = (wxWindow *)current->Data();
 154       if ((HWND)(item->GetHWND()) == (HWND) hWnd)
 155         return item;
 156       else
 157       {
 158                 if ( item->ContainsHWND(hWnd) )
 159                         return item;
 160       }
 161     }
 162     current = current->Next();
 163   }
 164   return NULL;
 165 }
 166
 167 // Default command handler
 168 bool wxWindow::MSWCommand(const WXUINT WXUNUSED(param), const WXWORD WXUNUSED(id))
 169 {
 170   return FALSE;
 171 }
 172
 173 bool wxWindow::MSWNotify(const WXWPARAM WXUNUSED(wParam), const WXLPARAM WXUNUSED(lParam))
 174 {
 175   return FALSE;
 176 }
 177
 178 void wxWindow::PreDelete(const WXHDC WXUNUSED(dc))
 179 {
 180 }
 181
 182 WXHWND wxWindow::GetHWND(void) const
 183 {
 184   return (WXHWND) m_hWnd;
 185 }
 186
 187 void wxWindow::SetHWND(WXHWND hWnd)
 188 {
 189         m_hWnd = hWnd;
 190 }
 191
 192 // Constructor
 193 wxWindow::wxWindow(void)
 194 {
 195   // Generic
 196   m_windowId = 0;
 197   m_isShown = TRUE;
 198   m_windowStyle = 0;
 199   m_windowParent = NULL;
 200   m_windowEventHandler = this;
 201   m_windowName = "";
 202   m_windowCursor = *wxSTANDARD_CURSOR;
 203   m_children = new wxList;
 204   m_doubleClickAllowed = 0 ;
 205   m_winCaptured = FALSE;
 206   m_constraints = NULL;
 207   m_constraintsInvolvedIn = NULL;
 208   m_windowSizer = NULL;
 209   m_sizerParent = NULL;
 210   m_autoLayout = FALSE;
 211   m_windowValidator = NULL;
 212
 213   // MSW-specific
 214   m_hWnd = 0;
 215   m_winEnabled = TRUE;
 216   m_caretWidth = 0; m_caretHeight = 0;
 217   m_caretEnabled = FALSE;
 218   m_caretShown = FALSE;
 219   m_inOnSize = FALSE;
 220   m_minSizeX = -1;
 221   m_minSizeY = -1;
 222   m_maxSizeX = -1;
 223   m_maxSizeY = -1;
 224 //  m_paintHDC = 0;
 225 //  m_tempHDC = 0;
 226   m_isBeingDeleted = FALSE;
 227   m_oldWndProc = 0;
 228 #ifndef __WIN32__
 229   m_globalHandle = 0;
 230 #endif
 231   m_useCtl3D = FALSE;
 232
 233   m_defaultItem = NULL;
 234
 235   wxSystemSettings settings;
 236
 237   m_backgroundColour = settings.GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
 238   m_foregroundColour = *wxBLACK;
 239   m_defaultForegroundColour = *wxBLACK ;
 240   m_defaultBackgroundColour = settings.GetSystemColour(wxSYS_COLOUR_3DFACE) ;
 241
 242 /*
 243     wxColour(GetRValue(GetSysColor(COLOR_WINDOW)),
 244         GetGValue(GetSysColor(COLOR_BTNFACE)), GetBValue(GetSysColor(COLOR_BTNFACE)));
 245 */
 246
 247   // wxWnd
 248   m_lastMsg = 0;
 249   m_lastWParam = 0;
 250   m_lastLParam = 0;
 251   m_acceleratorTable = 0;
 252   m_hMenu = 0;
 253
 254   m_xThumbSize = 0;
 255   m_yThumbSize = 0;
 256   m_backgroundTransparent = FALSE;
 257
 258   m_lastXPos = (float)-1.0;
 259   m_lastYPos = (float)-1.0;
 260   m_lastEvent = -1;
 261   m_returnCode = 0;
 262
 263 #if  USE_DRAG_AND_DROP
 264   m_pDropTarget = NULL;
 265 #endif
 266 }
 267
 268 // Destructor
 269 wxWindow::~wxWindow(void)
 270 {
 271   m_isBeingDeleted = TRUE;
 272
 273   // JACS - if behaviour is odd, restore this
 274   // to the start of ~wxWindow. Vadim has changed
 275   // it to nearer the end. Unsure of side-effects
 276   // e.g. when deleting associated global data.
 277   // Restore old Window proc, if required
 278 //  UnsubclassWin();
 279
 280         // Have to delete constraints/sizer FIRST otherwise
 281         // sizers may try to look at deleted windows as they
 282         // delete themselves.
 283 #if USE_CONSTRAINTS
 284   DeleteRelatedConstraints();
 285   if (m_constraints)
 286   {
 287     // This removes any dangling pointers to this window
 288     // in other windows' constraintsInvolvedIn lists.
 289     UnsetConstraints(m_constraints);
 290     delete m_constraints;
 291     m_constraints = NULL;
 292   }
 293   if (m_windowSizer)
 294   {
 295     delete m_windowSizer;
 296     m_windowSizer = NULL;
 297   }
 298   // If this is a child of a sizer, remove self from parent
 299   if (m_sizerParent)
 300     m_sizerParent->RemoveChild((wxWindow *)this);
 301 #endif
 302
 303   // wxWnd
 304   MSWDetachWindowMenu();
 305
 306   // TODO for backward compatibility
 307 #if 0
 308   // WX_CANVAS
 309   if (m_windowDC)
 310   {
 311     HWND hWnd = (HWND) GetHWND();
 312     HDC dc = ::GetDC(hWnd);
 313     m_windowDC->SelectOldObjects (dc);
 314     ReleaseDC(hWnd, dc);
 315     delete m_windowDC;
 316   }
 317 #endif
 318
 319   if (m_windowParent)
 320     m_windowParent->RemoveChild(this);
 321
 322   DestroyChildren();
 323
 324   if (m_hWnd)
 325     ::DestroyWindow((HWND)m_hWnd);
 326
 327   wxRemoveHandleAssociation(this);
 328   m_hWnd = 0;
 329 #ifndef __WIN32__
 330   if (m_globalHandle)
 331   {
 332     GlobalFree((HGLOBAL) m_globalHandle);
 333     m_globalHandle = 0;
 334   }
 335 #endif
 336
 337   delete m_children;
 338   m_children = NULL;
 339
 340   // Just in case the window has been Closed, but
 341   // we're then deleting immediately: don't leave
 342   // dangling pointers.
 343   wxPendingDelete.DeleteObject(this);
 344
 345   // Just in case we've loaded a top-level window via
 346   // wxWindow::LoadNativeDialog but we weren't a dialog
 347   // class
 348   wxTopLevelWindows.DeleteObject(this);
 349
 350 //  if (GetFont() && GetFont()->Ok())
 351 //    GetFont()->ReleaseResource();
 352
 353   if ( m_windowValidator )
 354         delete m_windowValidator;
 355
 356   // Restore old Window proc, if required
 357   // and remove hWnd <-> wxWindow association
 358   UnsubclassWin();
 359 }
 360
 361 // Destroy the window (delayed, if a managed window)
 362 bool wxWindow::Destroy(void)
 363 {
 364     delete this;
 365     return TRUE;
 366 }
 367
 368 extern char wxCanvasClassName[];
 369
 370 // Constructor
 371 bool wxWindow::Create(wxWindow *parent, const wxWindowID id,
 372            const wxPoint& pos,
 373            const wxSize& size,
 374            const long style,
 375            const wxString& name)
 376 {
 377   // Generic
 378   m_isBeingDeleted = FALSE;
 379   m_windowId = 0;
 380   m_isShown = TRUE;
 381   m_windowStyle = 0;
 382   m_windowParent = NULL;
 383   m_windowEventHandler = this;
 384 //  m_windowFont = NULL;
 385   // We don't wish internal (potentially transient) fonts to be found
 386   // by FindOrCreate
 387 //  wxTheFontList->RemoveFont(& m_windowFont);
 388   m_windowName = "";
 389   m_windowCursor = *wxSTANDARD_CURSOR;
 390   m_doubleClickAllowed = 0 ;
 391   m_winCaptured = FALSE;
 392   m_constraints = NULL;
 393   m_constraintsInvolvedIn = NULL;
 394   m_windowSizer = NULL;
 395   m_sizerParent = NULL;
 396   m_autoLayout = FALSE;
 397   m_windowValidator = NULL;
 398 #if  USE_DRAG_AND_DROP
 399   m_pDropTarget = NULL;
 400 #endif
 401
 402   // MSW-specific
 403   m_hWnd = 0;
 404   m_winEnabled = TRUE;
 405   m_caretWidth = 0; m_caretHeight = 0;
 406   m_caretEnabled = FALSE;
 407   m_caretShown = FALSE;
 408   m_inOnSize = FALSE;
 409   m_minSizeX = -1;
 410   m_minSizeY = -1;
 411   m_maxSizeX = -1;
 412   m_maxSizeY = -1;
 413 //  m_paintHDC = 0;
 414 //  m_tempHDC = 0;
 415   m_oldWndProc = 0;
 416 #ifndef __WIN32__
 417   m_globalHandle = 0;
 418 #endif
 419   m_useCtl3D = FALSE;
 420   m_defaultItem = NULL;
 421   m_windowParent = NULL;
 422 //  m_windowDC = NULL;
 423   m_mouseInWindow = FALSE;
 424   if (!parent)
 425     return FALSE;
 426
 427   if (parent) parent->AddChild(this);
 428
 429   // wxWnd
 430   m_lastMsg = 0;
 431   m_lastWParam = 0;
 432   m_lastLParam = 0;
 433   m_acceleratorTable = 0;
 434   m_hMenu = 0;
 435
 436   m_xThumbSize = 0;
 437   m_yThumbSize = 0;
 438   m_backgroundTransparent = FALSE;
 439
 440   m_lastXPos = (float)-1.0;
 441   m_lastYPos = (float)-1.0;
 442   m_lastEvent = -1;
 443   m_returnCode = 0;
 444
 445   SetName(name);
 446
 447   if ( id == -1 )
 448         m_windowId = (int)NewControlId();
 449   else
 450         m_windowId = id;
 451
 452   int x = pos.x;
 453   int y = pos.y;
 454   int width = size.x;
 455   int height = size.y;
 456
 457   wxSystemSettings settings;
 458
 459   m_backgroundColour = settings.GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
 460   m_foregroundColour = *wxBLACK;
 461   m_defaultForegroundColour = *wxBLACK ;
 462   m_defaultBackgroundColour = settings.GetSystemColour(wxSYS_COLOUR_3DFACE) ;
 463 /*
 464   m_defaultBackgroundColour = wxColour(GetRValue(GetSysColor(COLOR_BTNFACE)),
 465         GetGValue(GetSysColor(COLOR_BTNFACE)), GetBValue(GetSysColor(COLOR_BTNFACE)));
 466 */
 467
 468   m_windowStyle = style;
 469
 470   DWORD msflags = 0;
 471   if (style & wxBORDER)
 472     msflags |= WS_BORDER;
 473   if (style & wxTHICK_FRAME)
 474     msflags |= WS_THICKFRAME;
 475   // TODO: probably make WS_CLIPCHILDREN this a setting in wx/setup.h,
 476   // to reduce flicker with the trade-off that groupboxes must paint in a solid
 477   // colour (so your control order must be correct, and you can't easily draw a
 478   // transparent group).
 479   msflags |= WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN;
 480
 481   bool want3D;
 482   WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D) ;
 483
 484   // Even with extended styles, need to combine with WS_BORDER
 485   // for them to look right.
 486   if (want3D || (m_windowStyle & wxSIMPLE_BORDER) || (m_windowStyle & wxRAISED_BORDER) ||
 487        (m_windowStyle & wxSUNKEN_BORDER) || (m_windowStyle & wxDOUBLE_BORDER))
 488     msflags |= WS_BORDER;
 489
 490   m_mouseInWindow = FALSE ;
 491
 492   if ( id == -1 )
 493         m_windowId = (int)NewControlId();
 494   else
 495         m_windowId = id;
 496
 497   MSWCreate(m_windowId, (wxWindow *)parent, wxCanvasClassName, this, NULL, x, y, width, height, msflags,
 498     NULL, exStyle);
 499
 500   return TRUE;
 501 }
 502
 503 void wxWindow::SetFocus(void)
 504 {
 505   HWND hWnd = (HWND) GetHWND();
 506   if (hWnd)
 507     ::SetFocus(hWnd);
 508 }
 509
 510 void wxWindow::Enable(const bool enable)
 511 {
 512   m_winEnabled = enable;
 513   HWND hWnd = (HWND) GetHWND();
 514   if (hWnd)
 515     ::EnableWindow(hWnd, (BOOL)enable);
 516 }
 517
 518 void wxWindow::CaptureMouse(void)
 519 {
 520   HWND hWnd = (HWND) GetHWND();
 521   if (hWnd && !m_winCaptured)
 522   {
 523     SetCapture(hWnd);
 524     m_winCaptured = TRUE;
 525   }
 526 }
 527
 528 void wxWindow::ReleaseMouse(void)
 529 {
 530   if (m_winCaptured)
 531   {
 532     ReleaseCapture();
 533     m_winCaptured = FALSE;
 534   }
 535 }
 536
 537 // Push/pop event handler (i.e. allow a chain of event handlers
 538 // be searched)
 539 void wxWindow::PushEventHandler(wxEvtHandler *handler)
 540 {
 541         handler->SetNextHandler(GetEventHandler());
 542         SetEventHandler(handler);
 543 }
 544
 545 wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
 546 {
 547         if ( GetEventHandler() )
 548         {
 549                 wxEvtHandler *handlerA = GetEventHandler();
 550                 wxEvtHandler *handlerB = handlerA->GetNextHandler();
 551                 handlerA->SetNextHandler(NULL);
 552                 SetEventHandler(handlerB);
 553                 if ( deleteHandler )
 554                 {
 555                         delete handlerA;
 556                         return NULL;
 557                 }
 558                 else
 559                         return handlerA;
 560         }
 561         else
 562                 return NULL;
 563 }
 564
 565 #if    USE_DRAG_AND_DROP
 566
 567 void wxWindow::SetDropTarget(wxDropTarget *pDropTarget)
 568 {
 569   if ( m_pDropTarget != 0 ) {
 570     m_pDropTarget->Revoke(m_hWnd);
 571     delete m_pDropTarget;
 572   }
 573
 574   m_pDropTarget = pDropTarget;
 575   if ( m_pDropTarget != 0 )
 576     m_pDropTarget->Register(m_hWnd);
 577 }
 578
 579 #endif
 580
 581 //old style file-manager drag&drop support
 582 // I think we should retain the old-style
 583 // DragAcceptFiles in parallel with SetDropTarget.
 584 // JACS
 585 void wxWindow::DragAcceptFiles(const bool accept)
 586 {
 587   HWND hWnd = (HWND) GetHWND();
 588   if (hWnd)
 589     ::DragAcceptFiles(hWnd, (BOOL)accept);
 590 }
 591
 592 // Get total size
 593 void wxWindow::GetSize(int *x, int *y) const
 594 {
 595   HWND hWnd = (HWND) GetHWND();
 596   RECT rect;
 597   GetWindowRect(hWnd, &rect);
 598   *x = rect.right - rect.left;
 599   *y = rect.bottom - rect.top;
 600 }
 601
 602 void wxWindow::GetPosition(int *x, int *y) const
 603 {
 604   HWND hWnd = (HWND) GetHWND();
 605   HWND hParentWnd = 0;
 606   if (GetParent())
 607     hParentWnd = (HWND) GetParent()->GetHWND();
 608
 609   RECT rect;
 610   GetWindowRect(hWnd, &rect);
 611
 612   // Since we now have the absolute screen coords,
 613   // if there's a parent we must subtract its top left corner
 614   POINT point;
 615   point.x = rect.left;
 616   point.y = rect.top;
 617   if (hParentWnd)
 618   {
 619     ::ScreenToClient(hParentWnd, &point);
 620   }
 621   *x = point.x;
 622   *y = point.y;
 623 }
 624
 625 void wxWindow::ScreenToClient(int *x, int *y) const
 626 {
 627   HWND hWnd = (HWND) GetHWND();
 628   POINT pt;
 629   pt.x = *x;
 630   pt.y = *y;
 631   ::ScreenToClient(hWnd, &pt);
 632
 633   *x = pt.x;
 634   *y = pt.y;
 635 }
 636
 637 void wxWindow::ClientToScreen(int *x, int *y) const
 638 {
 639   HWND hWnd = (HWND) GetHWND();
 640   POINT pt;
 641   pt.x = *x;
 642   pt.y = *y;
 643   ::ClientToScreen(hWnd, &pt);
 644
 645   *x = pt.x;
 646   *y = pt.y;
 647 }
 648
 649 void wxWindow::SetCursor(const wxCursor& cursor)
 650 {
 651   m_windowCursor = cursor;
 652   if (m_windowCursor.Ok())
 653   {
 654     HWND hWnd = (HWND) GetHWND();
 655
 656     // Change the cursor NOW if we're within the correct window
 657     POINT point;
 658     ::GetCursorPos(&point);
 659
 660     RECT rect;
 661     ::GetWindowRect(hWnd, &rect);
 662
 663     if (::PtInRect(&rect, point) && !wxIsBusy())
 664       ::SetCursor((HCURSOR) m_windowCursor.GetHCURSOR());
 665   }
 666
 667   // This will cause big reentrancy problems if wxFlushEvents is implemented.
 668 //  wxFlushEvents();
 669 //  return old_cursor;
 670 }
 671
 672
 673 // Get size *available for subwindows* i.e. excluding menu bar etc.
 674 // For XView, this is the same as GetSize
 675 void wxWindow::GetClientSize(int *x, int *y) const
 676 {
 677   HWND hWnd = (HWND) GetHWND();
 678   RECT rect;
 679   GetClientRect(hWnd, &rect);
 680   *x = rect.right;
 681   *y = rect.bottom;
 682 }
 683
 684 void wxWindow::SetSize(const int x, const int y, const int width, const int height, const int sizeFlags)
 685 {
 686   int currentX, currentY;
 687   GetPosition(&currentX, &currentY);
 688   int actualWidth = width;
 689   int actualHeight = height;
 690   int actualX = x;
 691   int actualY = y;
 692   if (x == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 693     actualX = currentX;
 694   if (y == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 695     actualY = currentY;
 696
 697   int currentW,currentH;
 698   GetSize(&currentW, &currentH);
 699   if (width == -1)
 700     actualWidth = currentW ;
 701   if (height == -1)
 702     actualHeight = currentH ;
 703
 704   HWND hWnd = (HWND) GetHWND();
 705   if (hWnd)
 706     MoveWindow(hWnd, actualX, actualY, actualWidth, actualHeight, (BOOL)TRUE);
 707
 708 /* Not needed? should be called anyway via MoveWindow
 709   if (!(width == -1) && (height == -1))
 710   {
 711 #if WXWIN_COMPATIBILITY
 712   GetEventHandler()->OldOnSize(width, height);
 713 #else
 714   wxSizeEvent event(wxSize(width, height), m_windowId);
 715   event.eventObject = this;
 716   GetEventHandler()->ProcessEvent(event);
 717 #endif
 718   }
 719 */
 720 }
 721
 722 void wxWindow::SetClientSize(const int width, const int height)
 723 {
 724   wxWindow *parent = GetParent();
 725   HWND hWnd = (HWND) GetHWND();
 726   HWND hParentWnd = (HWND) (HWND) parent->GetHWND();
 727
 728   RECT rect;
 729   GetClientRect(hWnd, &rect);
 730
 731   RECT rect2;
 732   GetWindowRect(hWnd, &rect2);
 733
 734   // Find the difference between the entire window (title bar and all)
 735   // and the client area; add this to the new client size to move the
 736   // window
 737   int actual_width = rect2.right - rect2.left - rect.right + width;
 738   int actual_height = rect2.bottom - rect2.top - rect.bottom + height;
 739
 740   // If there's a parent, must subtract the parent's top left corner
 741   // since MoveWindow moves relative to the parent
 742
 743   POINT point;
 744   point.x = rect2.left;
 745   point.y = rect2.top;
 746   if (parent)
 747   {
 748     ::ScreenToClient(hParentWnd, &point);
 749   }
 750
 751   MoveWindow(hWnd, point.x, point.y, actual_width, actual_height, (BOOL)TRUE);
 752 #if WXWIN_COMPATIBILITY
 753   GetEventHandler()->OldOnSize(width, height);
 754 #else
 755   wxSizeEvent event(wxSize(width, height), m_windowId);
 756   event.m_eventObject = this;
 757   GetEventHandler()->ProcessEvent(event);
 758 #endif
 759 }
 760
 761 bool wxWindow::Show(const bool show)
 762 {
 763   HWND hWnd = (HWND) GetHWND();
 764   int cshow;
 765   if (show)
 766     cshow = SW_SHOW;
 767   else
 768     cshow = SW_HIDE;
 769   ShowWindow(hWnd, (BOOL)cshow);
 770   if (show)
 771   {
 772     BringWindowToTop(hWnd);
 773     // Next line causes a crash on NT, apparently.
 774 //    UpdateWindow(hWnd); // Should this be here or will it cause inefficiency?
 775   }
 776   return TRUE;
 777 }
 778
 779 bool wxWindow::IsShown(void) const
 780 {
 781   return (::IsWindowVisible((HWND) GetHWND()) != 0);
 782 }
 783
 784 int wxWindow::GetCharHeight(void) const
 785 {
 786   TEXTMETRIC lpTextMetric;
 787   HWND hWnd = (HWND) GetHWND();
 788   HDC dc = ::GetDC(hWnd);
 789
 790   GetTextMetrics(dc, &lpTextMetric);
 791   ::ReleaseDC(hWnd, dc);
 792
 793   return lpTextMetric.tmHeight;
 794 }
 795
 796 int wxWindow::GetCharWidth(void) const
 797 {
 798   TEXTMETRIC lpTextMetric;
 799   HWND hWnd = (HWND) GetHWND();
 800   HDC dc = ::GetDC(hWnd);
 801
 802   GetTextMetrics(dc, &lpTextMetric);
 803   ::ReleaseDC(hWnd, dc);
 804
 805   return lpTextMetric.tmAveCharWidth;
 806 }
 807
 808 void wxWindow::GetTextExtent(const wxString& string, int *x, int *y,
 809                            int *descent, int *externalLeading, const wxFont *theFont, const bool) const
 810 {
 811   wxFont *fontToUse = (wxFont *)theFont;
 812   if (!fontToUse)
 813     fontToUse = (wxFont *) & m_windowFont;
 814
 815   HWND hWnd = (HWND) GetHWND();
 816   HDC dc = ::GetDC(hWnd);
 817
 818   HFONT fnt = 0;
 819   HFONT was = 0;
 820   if (fontToUse && fontToUse->Ok())
 821   {
 822 //    fontToUse->UseResource();
 823
 824 //    fontToUse->RealizeResource();
 825     if ((fnt=(HFONT) fontToUse->GetResourceHandle()))
 826       was = SelectObject(dc,fnt) ;
 827   }
 828
 829   SIZE sizeRect;
 830   TEXTMETRIC tm;
 831   GetTextExtentPoint(dc, (const char *)string, (int)string.Length(), &sizeRect);
 832   GetTextMetrics(dc, &tm);
 833
 834   if (fontToUse && fnt && was)
 835     SelectObject(dc,was) ;
 836
 837   ReleaseDC(hWnd, dc);
 838
 839   *x = sizeRect.cx;
 840   *y = sizeRect.cy;
 841   if (descent) *descent = tm.tmDescent;
 842   if (externalLeading) *externalLeading = tm.tmExternalLeading;
 843
 844 //  if (fontToUse)
 845 //    fontToUse->ReleaseResource();
 846 }
 847
 848 #if WXWIN_COMPATIBILITY
 849 void wxWindow::GetTextExtent(const wxString& string, float *x, float *y,
 850                              float *descent,
 851                              float *externalLeading,
 852                              const wxFont *theFont, const bool use16) const
 853   {
 854     int x1, y1, descent1, externalLeading1;
 855     GetTextExtent(string, &x1, &y1, &descent1, &externalLeading1, theFont, use16);
 856     *x = x1; *y = y1;
 857     if ( descent )
 858         *descent = descent1;
 859     if ( externalLeading )
 860         *externalLeading = externalLeading1;
 861   }
 862 #endif
 863
 864 void wxWindow::Refresh(const bool eraseBack, const wxRectangle *rect)
 865 {
 866   HWND hWnd = (HWND) GetHWND();
 867   if (hWnd)
 868   {
 869     if (rect)
 870     {
 871       RECT mswRect;
 872       mswRect.left = rect->x;
 873       mswRect.top = rect->y;
 874       mswRect.right = rect->x + rect->width;
 875       mswRect.bottom = rect->y + rect->height;
 876
 877       ::InvalidateRect(hWnd, &mswRect, eraseBack);
 878     }
 879     else
 880       ::InvalidateRect(hWnd, NULL, eraseBack);
 881   }
 882 }
 883
 884 // TODO: Are these really necessary now?
 885 /*
 886 WXHDC wxWindow::GetHDC(void) const
 887 {
 888   wxWindow *nonConst = (wxWindow *)this;
 889   if (m_paintHDC)
 890     return(m_paintHDC) ;
 891   nonConst->m_tempHDC = (WXHDC) ::GetDC((HWND) GetHWND()) ;
 892   return(m_tempHDC) ;
 893 }
 894
 895 void wxWindow::ReleaseHDC(void)
 896 {
 897   // We're within an OnPaint: it'll be released.
 898   if (m_paintHDC)
 899     return ;
 900
 901   ::ReleaseDC((HWND) GetHWND(),(HDC) m_tempHDC) ;
 902 }
 903 */
 904
 905 // Hook for new window just as it's being created,
 906 // when the window isn't yet associated with the handle
 907 wxWindow *wxWndHook = NULL;
 908
 909 /*
 910 #if HAVE_SOCKET
 911 // DDE Interface Handler
 912 extern  "C" {
 913   long  ddeWindowProc(HWND hwnd,UINT message,WPARAM wparam,LPARAM lparam);
 914   void __ddeUnblock(HWND hWnd, WPARAM wParam);
 915 };
 916 #endif
 917 */
 918
 919 // Main Windows 3 window proc
 920 LRESULT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 921 {
 922   wxWindow *wnd = wxFindWinFromHandle((WXHWND) hWnd);
 923
 924   if (!wnd && wxWndHook)
 925   {
 926         wxAssociateWinWithHandle(hWnd, wxWndHook);
 927     wnd = wxWndHook;
 928         wxWndHook = NULL;
 929     wnd->m_hWnd = (WXHWND) hWnd;
 930   }
 931 #if (DEBUG > 1)
 932   wxDebugMsg("hWnd = %d, m_hWnd = %d, msg = %d\n", hWnd, m_hWnd, message);
 933 #endif
 934   // Stop right here if we don't have a valid handle
 935   // in our wxWnd object.
 936   if (wnd && !wnd->m_hWnd) {
 937 //    wxDebugMsg("Warning: could not find a valid handle, wx_win.cc/wxWndProc.\n");
 938     wnd->m_hWnd = (WXHWND) hWnd;
 939     long res = wnd->MSWDefWindowProc(message, wParam, lParam );
 940     wnd->m_hWnd = 0;
 941     return res;
 942   }
 943
 944   if (wnd) {
 945     wnd->m_lastMsg = message;
 946     wnd->m_lastWParam = wParam;
 947     wnd->m_lastLParam = lParam;
 948 /* Don't know why this was here
 949     if (message == WM_SETFONT)
 950       return 0;
 951     else if (message == WM_INITDIALOG)
 952       return TRUE;
 953 */
 954   }
 955   if (wnd)
 956     return wnd->MSWWindowProc(message, wParam, lParam);
 957   else
 958     return DefWindowProc( hWnd, message, wParam, lParam );
 959 }
 960
 961 // Should probably have a test for 'genuine' NT
 962 #if defined(__WIN32__)
 963 #define DIMENSION_TYPE short
 964 #else
 965 #define DIMENSION_TYPE int
 966 #endif
 967
 968 // Main Windows 3 window proc
 969 long wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
 970 {
 971 #if 0
 972   switch (message)
 973   {
 974         case WM_INITDIALOG:
 975         case WM_ACTIVATE:
 976         case WM_SETFOCUS:
 977         case WM_KILLFOCUS:
 978         case WM_CREATE:
 979         case WM_PAINT:
 980         case WM_QUERYDRAGICON:
 981         case WM_SIZE:
 982         case WM_RBUTTONDOWN:
 983         case WM_RBUTTONUP:
 984         case WM_RBUTTONDBLCLK:
 985         case WM_MBUTTONDOWN:
 986         case WM_MBUTTONUP:
 987         case WM_MBUTTONDBLCLK:
 988         case WM_LBUTTONDOWN:
 989         case WM_LBUTTONUP:
 990         case WM_LBUTTONDBLCLK:
 991         case WM_MOUSEMOVE:
 992 //        case WM_DESTROY:
 993         case WM_COMMAND:
 994         case WM_NOTIFY:
 995         case WM_MENUSELECT:
 996         case WM_INITMENUPOPUP:
 997         case WM_DRAWITEM:
 998         case WM_MEASUREITEM:
 999         case WM_KEYDOWN:
1000         case WM_KEYUP:
1001         case WM_CHAR: // Always an ASCII character
1002         case WM_HSCROLL:
1003         case WM_VSCROLL:
1004         case WM_CTLCOLORBTN:
1005         case WM_CTLCOLORDLG:
1006         case WM_CTLCOLORLISTBOX:
1007         case WM_CTLCOLORMSGBOX:
1008         case WM_CTLCOLORSCROLLBAR:
1009         case WM_CTLCOLORSTATIC:
1010         case WM_CTLCOLOREDIT:
1011         case WM_SYSCOLORCHANGE:
1012         case WM_ERASEBKGND:
1013         case WM_MDIACTIVATE:
1014         case WM_DROPFILES:
1015         case WM_QUERYENDSESSION:
1016 //        case WM_CLOSE:
1017         case WM_GETMINMAXINFO:
1018             return MSWDefWindowProc(message, wParam, lParam );
1019     }
1020 #endif
1021
1022
1023   HWND hWnd = (HWND)m_hWnd;
1024
1025   switch (message)
1026   {
1027 /*
1028         case WM_SETFONT:
1029         {
1030           return 0;
1031         }
1032 */
1033         case WM_ACTIVATE:
1034         {
1035 #ifdef __WIN32__
1036             WORD state = LOWORD(wParam);
1037             WORD minimized = HIWORD(wParam);
1038             HWND hwnd = (HWND)lParam;
1039 #else
1040             WORD state = (WORD)wParam;
1041             WORD minimized = LOWORD(lParam);
1042             HWND hwnd = (HWND)HIWORD(lParam);
1043 #endif
1044             MSWOnActivate(state, (minimized != 0), (WXHWND) hwnd);
1045             return 0;
1046             break;
1047         }
1048         case WM_SETFOCUS:
1049         {
1050             HWND hwnd = (HWND)wParam;
1051 //            return OnSetFocus(hwnd);
1052
1053             if (MSWOnSetFocus((WXHWND) hwnd))
1054               return 0;
1055             else return MSWDefWindowProc(message, wParam, lParam );
1056             break;
1057         }
1058         case WM_KILLFOCUS:
1059         {
1060             HWND hwnd = (HWND)lParam;
1061 //            return OnKillFocus(hwnd);
1062             if (MSWOnKillFocus((WXHWND) hwnd))
1063               return 0;
1064             else
1065               return MSWDefWindowProc(message, wParam, lParam );
1066             break;
1067         }
1068         case WM_CREATE:
1069         {
1070           MSWOnCreate((WXLPCREATESTRUCT) (LPCREATESTRUCT)lParam);
1071           return 0;
1072           break;
1073         }
1074         case WM_SHOWWINDOW:
1075         {
1076           MSWOnShow((wParam != 0), (int) lParam);
1077           break;
1078         }
1079         case WM_PAINT:
1080         {
1081           if (MSWOnPaint())
1082             return 0;
1083           else return MSWDefWindowProc(message, wParam, lParam );
1084           break;
1085         }
1086         case WM_QUERYDRAGICON:
1087         {
1088           HICON hIcon = 0;
1089           if ((hIcon = (HICON) MSWOnQueryDragIcon()))
1090             return (long)hIcon;
1091           else return MSWDefWindowProc(message, wParam, lParam );
1092           break;
1093         }
1094
1095         case WM_SIZE:
1096         {
1097           int width = LOWORD(lParam);
1098           int height = HIWORD(lParam);
1099           MSWOnSize(width, height, wParam);
1100           break;
1101         }
1102
1103         case WM_WINDOWPOSCHANGING:
1104         {
1105           WINDOWPOS *pos = (WINDOWPOS *)lParam;
1106           MSWOnWindowPosChanging((void *)pos);
1107           break;
1108         }
1109
1110         case WM_RBUTTONDOWN:
1111         {
1112             int x = (DIMENSION_TYPE) LOWORD(lParam);
1113             int y = (DIMENSION_TYPE) HIWORD(lParam);
1114             MSWOnRButtonDown(x, y, wParam);
1115             break;
1116         }
1117         case WM_RBUTTONUP:
1118         {
1119             int x = (DIMENSION_TYPE) LOWORD(lParam);
1120             int y = (DIMENSION_TYPE) HIWORD(lParam);
1121             MSWOnRButtonUp(x, y, wParam);
1122             break;
1123         }
1124         case WM_RBUTTONDBLCLK:
1125         {
1126             int x = (DIMENSION_TYPE) LOWORD(lParam);
1127             int y = (DIMENSION_TYPE) HIWORD(lParam);
1128             MSWOnRButtonDClick(x, y, wParam);
1129             break;
1130         }
1131         case WM_MBUTTONDOWN:
1132         {
1133             int x = (DIMENSION_TYPE) LOWORD(lParam);
1134             int y = (DIMENSION_TYPE) HIWORD(lParam);
1135             MSWOnMButtonDown(x, y, wParam);
1136             break;
1137         }
1138         case WM_MBUTTONUP:
1139         {
1140             int x = (DIMENSION_TYPE) LOWORD(lParam);
1141             int y = (DIMENSION_TYPE) HIWORD(lParam);
1142             MSWOnMButtonUp(x, y, wParam);
1143             break;
1144         }
1145         case WM_MBUTTONDBLCLK:
1146         {
1147             int x = (DIMENSION_TYPE) LOWORD(lParam);
1148             int y = (DIMENSION_TYPE) HIWORD(lParam);
1149             MSWOnMButtonDClick(x, y, wParam);
1150             break;
1151         }
1152         case WM_LBUTTONDOWN:
1153         {
1154             int x = (DIMENSION_TYPE) LOWORD(lParam);
1155             int y = (DIMENSION_TYPE) HIWORD(lParam);
1156             MSWOnLButtonDown(x, y, wParam);
1157             break;
1158         }
1159         case WM_LBUTTONUP:
1160         {
1161             int x = (DIMENSION_TYPE) LOWORD(lParam);
1162             int y = (DIMENSION_TYPE) HIWORD(lParam);
1163             MSWOnLButtonUp(x, y, wParam);
1164             break;
1165         }
1166         case WM_LBUTTONDBLCLK:
1167         {
1168             int x = (DIMENSION_TYPE) LOWORD(lParam);
1169             int y = (DIMENSION_TYPE) HIWORD(lParam);
1170             MSWOnLButtonDClick(x, y, wParam);
1171             break;
1172         }
1173         case WM_MOUSEMOVE:
1174         {
1175             int x = (DIMENSION_TYPE) LOWORD(lParam);
1176             int y = (DIMENSION_TYPE) HIWORD(lParam);
1177             MSWOnMouseMove(x, y, wParam);
1178             break;
1179         }
1180         case MM_JOY1BUTTONDOWN:
1181         {
1182             int x = LOWORD(lParam);
1183             int y = HIWORD(lParam);
1184             MSWOnJoyDown(wxJOYSTICK1, x, y, wParam);
1185             break;
1186         }
1187         case MM_JOY2BUTTONDOWN:
1188         {
1189             int x = LOWORD(lParam);
1190             int y = HIWORD(lParam);
1191             MSWOnJoyDown(wxJOYSTICK2, x, y, wParam);
1192             break;
1193         }
1194         case MM_JOY1BUTTONUP:
1195         {
1196             int x = LOWORD(lParam);
1197             int y = HIWORD(lParam);
1198             MSWOnJoyUp(wxJOYSTICK1, x, y, wParam);
1199             break;
1200         }
1201         case MM_JOY2BUTTONUP:
1202         {
1203             int x = LOWORD(lParam);
1204             int y = HIWORD(lParam);
1205             MSWOnJoyUp(wxJOYSTICK2, x, y, wParam);
1206             break;
1207         }
1208         case MM_JOY1MOVE:
1209         {
1210             int x = LOWORD(lParam);
1211             int y = HIWORD(lParam);
1212             MSWOnJoyMove(wxJOYSTICK1, x, y, wParam);
1213             break;
1214         }
1215         case MM_JOY2MOVE:
1216         {
1217             int x = LOWORD(lParam);
1218             int y = HIWORD(lParam);
1219             MSWOnJoyMove(wxJOYSTICK2, x, y, wParam);
1220             break;
1221         }
1222         case MM_JOY1ZMOVE:
1223         {
1224             int z = LOWORD(lParam);
1225             MSWOnJoyZMove(wxJOYSTICK1, z, wParam);
1226             break;
1227         }
1228         case MM_JOY2ZMOVE:
1229         {
1230             int z = LOWORD(lParam);
1231             MSWOnJoyZMove(wxJOYSTICK2, z, wParam);
1232             break;
1233         }
1234         case WM_DESTROY:
1235         {
1236           if (MSWOnDestroy())
1237             return 0;
1238           else return MSWDefWindowProc(message, wParam, lParam );
1239           break;
1240         }
1241         case WM_SYSCOMMAND:
1242         {
1243             return MSWOnSysCommand(wParam, lParam);
1244             break;
1245         }
1246         case WM_COMMAND:
1247         {
1248 #ifdef __WIN32__
1249             WORD id = LOWORD(wParam);
1250             HWND hwnd = (HWND)lParam;
1251             WORD cmd = HIWORD(wParam);
1252 #else
1253             WORD id = (WORD)wParam;
1254             HWND hwnd = (HWND)LOWORD(lParam) ;
1255             WORD cmd = HIWORD(lParam);
1256 #endif
1257             if (!MSWOnCommand(id, cmd, (WXHWND) hwnd))
1258               return MSWDefWindowProc(message, wParam, lParam );
1259             break;
1260          }
1261 #if defined(__WIN95__)
1262         case WM_NOTIFY:
1263         {
1264           if (!MSWOnNotify(wParam, lParam))
1265             return MSWDefWindowProc(message, wParam, lParam );
1266           break;
1267         }
1268 #endif
1269         case WM_MENUSELECT:
1270         {
1271 #ifdef __WIN32__
1272             WORD flags = HIWORD(wParam);
1273             HMENU sysmenu = (HMENU)lParam;
1274 #else
1275             WORD flags = LOWORD(lParam);
1276             HMENU sysmenu = (HMENU)HIWORD(lParam);
1277 #endif
1278             MSWOnMenuHighlight((WORD)wParam, flags, (WXHMENU) sysmenu);
1279             break;
1280         }
1281         case WM_INITMENUPOPUP:
1282         {
1283             MSWOnInitMenuPopup((WXHMENU) (HMENU)wParam, (int)LOWORD(lParam), (HIWORD(lParam) != 0));
1284             break;
1285         }
1286         case WM_DRAWITEM:
1287         {
1288           return MSWOnDrawItem((int)wParam, (WXDRAWITEMSTRUCT *)lParam);
1289           break;
1290         }
1291         case WM_MEASUREITEM:
1292         {
1293           return MSWOnMeasureItem((int)wParam, (WXMEASUREITEMSTRUCT *)lParam);
1294           break;
1295         }
1296         case WM_KEYDOWN:
1297         {
1298 //            return Default();
1299
1300             if (wParam == VK_SHIFT)
1301                 return Default();
1302
1303             else if (wParam == VK_CONTROL)
1304                 return Default();
1305
1306             // Avoid duplicate messages to OnChar
1307             else if ((wParam != VK_ESCAPE) && (wParam != VK_SPACE) && (wParam != VK_RETURN) && (wParam != VK_BACK) && (wParam != VK_TAB))
1308                 {
1309               MSWOnChar((WORD)wParam, lParam);
1310               if (::GetKeyState(VK_CONTROL)&0x100?TRUE:FALSE)
1311                             return Default();
1312                 }
1313                         else
1314                                 return Default();
1315             break;
1316         }
1317         case WM_KEYUP:
1318         {
1319 /*
1320             if (wParam == VK_SHIFT)
1321               wxShiftDown = FALSE;
1322             else if (wParam == VK_CONTROL)
1323               wxControlDown = FALSE;
1324 */
1325             break;
1326         }
1327         case WM_CHAR: // Always an ASCII character
1328         {
1329           MSWOnChar((WORD)wParam, lParam, TRUE);
1330           break;
1331         }
1332         case WM_HSCROLL:
1333         {
1334 #ifdef __WIN32__
1335             WORD code = LOWORD(wParam);
1336             WORD pos = HIWORD(wParam);
1337             HWND control = (HWND)lParam;
1338 #else
1339             WORD code = (WORD)wParam;
1340             WORD pos = LOWORD(lParam);
1341             HWND control = (HWND)HIWORD(lParam);
1342 #endif
1343             MSWOnHScroll(code, pos, (WXHWND) control);
1344             break;
1345         }
1346         case WM_VSCROLL:
1347         {
1348 #ifdef __WIN32__
1349             WORD code = LOWORD(wParam);
1350             WORD pos = HIWORD(wParam);
1351             HWND control = (HWND)lParam;
1352 #else
1353             WORD code = (WORD)wParam;
1354             WORD pos = LOWORD(lParam);
1355             HWND control = (HWND)HIWORD(lParam);
1356 #endif
1357             MSWOnVScroll(code, pos, (WXHWND) control);
1358             break;
1359         }
1360 #ifdef __WIN32__
1361         case WM_CTLCOLORBTN:
1362         {
1363           int nCtlColor = CTLCOLOR_BTN;
1364           HWND control = (HWND)lParam;
1365           HDC pDC = (HDC)wParam;
1366           return (DWORD)MSWOnCtlColor((WXHDC) pDC, (WXHWND) control, nCtlColor,
1367                                         message, wParam, lParam);
1368           break;
1369         }
1370         case WM_CTLCOLORDLG:
1371         {
1372           int nCtlColor = CTLCOLOR_DLG;
1373           HWND control = (HWND)lParam;
1374           HDC pDC = (HDC)wParam;
1375           return (DWORD)MSWOnCtlColor((WXHDC) pDC, (WXHWND) control, nCtlColor,
1376                                         message, wParam, lParam);\
1377           break;
1378         }
1379         case WM_CTLCOLORLISTBOX:
1380         {
1381           int nCtlColor = CTLCOLOR_LISTBOX;
1382           HWND control = (HWND)lParam;
1383           HDC pDC = (HDC)wParam;
1384           return (DWORD)MSWOnCtlColor((WXHDC) pDC, (WXHWND) control, nCtlColor,
1385                                         message, wParam, lParam);
1386           break;
1387         }
1388         case WM_CTLCOLORMSGBOX:
1389         {
1390           int nCtlColor = CTLCOLOR_MSGBOX;
1391           HWND control = (HWND)lParam;
1392           HDC pDC = (HDC)wParam;
1393           return (DWORD)MSWOnCtlColor((WXHDC) pDC, (WXHWND) control, nCtlColor,
1394                                         message, wParam, lParam);
1395           break;
1396         }
1397         case WM_CTLCOLORSCROLLBAR:
1398         {
1399           int nCtlColor = CTLCOLOR_SCROLLBAR;
1400           HWND control = (HWND)lParam;
1401           HDC pDC = (HDC)wParam;
1402           return (DWORD)MSWOnCtlColor((WXHDC) pDC, (WXHWND) control, nCtlColor,
1403                                         message, wParam, lParam);
1404           break;
1405         }
1406         case WM_CTLCOLORSTATIC:
1407         {
1408           int nCtlColor = CTLCOLOR_STATIC;
1409           HWND control = (HWND)lParam;
1410           HDC pDC = (HDC)wParam;
1411           return (DWORD)MSWOnCtlColor((WXHDC) pDC, (WXHWND) control, nCtlColor,
1412                                         message, wParam, lParam);
1413           break;
1414         }
1415         case WM_CTLCOLOREDIT:
1416         {
1417           int nCtlColor = CTLCOLOR_EDIT;
1418           HWND control = (HWND)lParam;
1419           HDC pDC = (HDC)wParam;
1420           return (DWORD)MSWOnCtlColor((WXHDC) pDC, (WXHWND) control, nCtlColor,
1421                                         message, wParam, lParam);
1422           break;
1423         }
1424 #else
1425         case WM_CTLCOLOR:
1426         {
1427           HWND control = (HWND)LOWORD(lParam);
1428           int nCtlColor = (int)HIWORD(lParam);
1429           HDC pDC = (HDC)wParam;
1430           return (DWORD)MSWOnCtlColor((WXHDC) pDC, (WXHWND) control, nCtlColor,
1431                                         message, wParam, lParam);
1432           break;
1433         }
1434 #endif
1435         case WM_SYSCOLORCHANGE:
1436         {
1437           // Return value of 0 means, we processed it.
1438           if (MSWOnColorChange((WXHWND) hWnd, message, wParam, lParam) == 0)
1439             return 0;
1440           else
1441             return MSWDefWindowProc(message, wParam, lParam );
1442           break;
1443         }
1444         case WM_ERASEBKGND:
1445         {
1446           // Prevents flicker when dragging
1447           if (IsIconic(hWnd)) return 1;
1448
1449           // EXPERIMENTAL
1450 //          return 1;
1451           if (!MSWOnEraseBkgnd((WXHDC) (HDC)wParam))
1452             return 0; // Default(); MSWDefWindowProc(message, wParam, lParam );
1453           else return 1;
1454           break;
1455         }
1456         case WM_MDIACTIVATE:
1457         {
1458 #ifdef __WIN32__
1459             HWND hWndActivate = GET_WM_MDIACTIVATE_HWNDACTIVATE(wParam,lParam);
1460             HWND hWndDeactivate = GET_WM_MDIACTIVATE_HWNDDEACT(wParam,lParam);
1461             BOOL activate = GET_WM_MDIACTIVATE_FACTIVATE(hWnd,wParam,lParam);
1462             return MSWOnMDIActivate((long) activate, (WXHWND) hWndActivate, (WXHWND) hWndDeactivate);
1463 #else
1464             return MSWOnMDIActivate((BOOL)wParam, (HWND)LOWORD(lParam),
1465                                                (HWND)HIWORD(lParam));
1466 #endif
1467         }
1468         case WM_DROPFILES:
1469         {
1470             MSWOnDropFiles(wParam);
1471             break;
1472                 }
1473         case WM_INITDIALOG:
1474         {
1475             return 0; // MSWOnInitDialog((WXHWND)(HWND)wParam);
1476             break;
1477                 }
1478         case WM_QUERYENDSESSION:
1479         {
1480             // Same as WM_CLOSE, but inverted results. Thx Microsoft :-)
1481             return MSWOnClose();
1482             break;
1483         }
1484         case WM_CLOSE:
1485         {
1486             if (MSWOnClose())
1487               return 0L;
1488             else
1489               return 1L;
1490             break;
1491         }
1492
1493         case WM_GETMINMAXINFO:
1494         {
1495           MINMAXINFO *info = (MINMAXINFO *)lParam;
1496           if (m_minSizeX != -1)
1497            info->ptMinTrackSize.x = (int)m_minSizeX;
1498           if (m_minSizeY != -1)
1499            info->ptMinTrackSize.y = (int)m_minSizeY;
1500           if (m_maxSizeX != -1)
1501            info->ptMaxTrackSize.x = (int)m_maxSizeX;
1502           if (m_maxSizeY != -1)
1503            info->ptMaxTrackSize.y = (int)m_maxSizeY;
1504           return MSWDefWindowProc(message, wParam, lParam );
1505           break;
1506         }
1507
1508 /*
1509 #if HAVE_SOCKET
1510         case WM_TIMER:
1511         {
1512           __ddeUnblock(hWnd, wParam);
1513           break;
1514         }
1515
1516         case ASYNC_SELECT_MESSAGE:
1517             return ddeWindowProc(hWnd,message,wParam,lParam);
1518 #endif
1519 */
1520
1521         default:
1522             return MSWDefWindowProc(message, wParam, lParam );
1523     }
1524     return 0; // Success: we processed this command.
1525 }
1526
1527 // Dialog window proc
1528 LONG APIENTRY _EXPORT
1529   wxDlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
1530 {
1531   return 0;
1532 }
1533
1534 wxList *wxWinHandleList = NULL;
1535 wxWindow *wxFindWinFromHandle(WXHWND hWnd)
1536 {
1537   wxNode *node = wxWinHandleList->Find((long)hWnd);
1538   if (!node)
1539     return NULL;
1540   return (wxWindow *)node->Data();
1541 }
1542
1543 void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win)
1544 {
1545   // adding NULL hWnd is (first) surely a result of an error and
1546   // (secondly) breaks menu command processing
1547   wxCHECK( hWnd != NULL );
1548
1549   if ( !wxWinHandleList->Find((long)hWnd) )
1550     wxWinHandleList->Append((long)hWnd, win);
1551 }
1552
1553 void wxRemoveHandleAssociation(wxWindow *win)
1554 {
1555   wxWinHandleList->DeleteObject(win);
1556 }
1557
1558 // Default destroyer - override if you destroy it in some other way
1559 // (e.g. with MDI child windows)
1560 void wxWindow::MSWDestroyWindow(void)
1561 {
1562 #if 0
1563
1564 #if DEBUG > 1
1565   wxDebugMsg("wxWindow::MSWDestroyWindow %d\n", handle);
1566 #endif
1567   MSWDetachWindowMenu();
1568 //  SetWindowLong(handle, 0, (long)0);
1569   HWND oldHandle = handle;
1570   handle = NULL;
1571
1572   ::DestroyWindow(oldHandle);
1573
1574   // Menu is destroyed explicitly by wxMDIChild::DestroyWindow,
1575   // or when Windows HWND is deleted if MDI parent or
1576   // SDI frame.
1577 /*
1578   if (m_hMenu)
1579   {
1580     ::DestroyMenu(m_hMenu);
1581     m_hMenu = 0;
1582   }
1583  */
1584 #endif
1585 }
1586
1587 void wxWindow::MSWCreate(const int id, wxWindow *parent, const char *wclass, wxWindow *wx_win, const char *title,
1588                     const int x, const int y, const int width, const int height,
1589                     const WXDWORD style, const char *dialog_template, const WXDWORD extendedStyle)
1590 {
1591   bool is_dialog = (dialog_template != NULL);
1592   int x1 = CW_USEDEFAULT;
1593   int y1 = 0;
1594   int width1 = CW_USEDEFAULT;
1595   int height1 = 100;
1596
1597   // Find parent's size, if it exists, to set up a possible default
1598   // panel size the size of the parent window
1599   RECT parent_rect;
1600   if (parent)
1601   {
1602     // Was GetWindowRect: JACS 5/5/95
1603     ::GetClientRect((HWND) parent->GetHWND(), &parent_rect);
1604
1605     width1 = parent_rect.right - parent_rect.left;
1606     height1 = parent_rect.bottom - parent_rect.top;
1607   }
1608
1609   if (x > -1) x1 = x;
1610   if (y > -1) y1 = y;
1611   if (width > -1) width1 = width;
1612   if (height > -1) height1 = height;
1613
1614   HWND hParent = NULL;
1615   if (parent)
1616     hParent = (HWND) parent->GetHWND();
1617
1618   wxWndHook = this;
1619
1620   if (is_dialog)
1621   {
1622     // MakeProcInstance doesn't seem to be needed in C7. Is it needed for
1623     // other compilers???
1624     // VZ: it's always needed for Win16 and never for Win32
1625 #ifdef __WIN32__
1626     m_hWnd = (WXHWND) ::CreateDialog(wxGetInstance(), dialog_template, hParent,
1627                             (DLGPROC)wxDlgProc);
1628 #else
1629     DLGPROC dlgproc = (DLGPROC)MakeProcInstance((DLGPROC)wxWndProc, wxGetInstance());
1630
1631     m_hWnd = (WXHWND) ::CreateDialog(wxGetInstance(), dialog_template, hParent,
1632                             (DLGPROC)dlgproc);
1633 #endif
1634
1635     if (m_hWnd == 0)
1636        MessageBox(NULL, "Can't find dummy dialog template!\nCheck resource include path for finding wx.rc.",
1637                   "wxWindows Error", MB_ICONEXCLAMATION | MB_OK);
1638     else MoveWindow((HWND) m_hWnd, x1, y1, width1, height1, FALSE);
1639   }
1640   else
1641   {
1642     int controlId = 0;
1643     if (style & WS_CHILD)
1644       controlId = id;
1645     if (!title)
1646       title = "";
1647
1648     m_hWnd = (WXHWND) CreateWindowEx(extendedStyle, wclass,
1649                 title,
1650                 style,
1651                 x1, y1,
1652                 width1, height1,
1653 //                hParent, NULL, wxGetInstance(),
1654                 hParent, (HMENU)controlId, wxGetInstance(),
1655                 NULL);
1656
1657     if (m_hWnd == 0)
1658     {
1659        char buf[300];
1660        sprintf(buf, "Can't create window of class %s! Weird.\nPossible Windows 3.x compatibility problem?",
1661          wclass);
1662        wxFatalError(buf,
1663                   "Fatal wxWindows Error");
1664     }
1665   }
1666   wxWndHook = NULL;
1667   wxWinHandleList->Append((long)m_hWnd, this);
1668
1669 #if DEBUG > 1
1670   wxDebugMsg("wxWindow::MSWCreate %d\n", m_hWnd);
1671 #endif
1672 }
1673
1674 void wxWindow::MSWOnCreate(WXLPCREATESTRUCT WXUNUSED(cs))
1675 {
1676 }
1677
1678 bool wxWindow::MSWOnClose(void)
1679 {
1680 #if DEBUG > 1
1681   wxDebugMsg("wxWindow::MSWOnClose %d\n", handle);
1682 #endif
1683   return FALSE;
1684 }
1685
1686 bool wxWindow::MSWOnDestroy(void)
1687 {
1688 #if DEBUG > 1
1689   wxDebugMsg("wxWindow::MSWOnDestroy %d\n", handle);
1690 #endif
1691   // delete our drop target if we've got one
1692   #if USE_DRAG_AND_DROP
1693     if ( m_pDropTarget != NULL ) {
1694       m_pDropTarget->Revoke(m_hWnd);
1695
1696       delete m_pDropTarget;
1697       m_pDropTarget = NULL;
1698     }
1699   #endif
1700
1701   return TRUE;
1702 }
1703
1704 // Deal with child commands from buttons etc.
1705
1706 bool wxWindow::MSWOnNotify(const WXWPARAM wParam, const WXLPARAM lParam)
1707 {
1708 #if defined(__WIN95__)
1709     // Find a child window to send the notification to, e.g. a toolbar.
1710     // There's a problem here. NMHDR::hwndFrom doesn't give us the
1711     // handle of the toolbar; it's probably the handle of the tooltip
1712     // window (anyway, it's parent is also the toolbar's parent).
1713     // So, since we don't know which hWnd or wxWindow originated the
1714     // WM_NOTIFY, we'll need to go through all the children of this window
1715     // trying out MSWNotify.
1716         // This won't work now, though, because any number of controls
1717         // could respond to the same generic messages :-(
1718
1719 /* This doesn't work for toolbars, but try for other controls first.
1720  */
1721     NMHDR *hdr = (NMHDR *)lParam;
1722     HWND hWnd = (HWND)hdr->hwndFrom;
1723     wxWindow *win = wxFindWinFromHandle((WXHWND) hWnd);
1724
1725         if ( win )
1726                 return win->MSWNotify(wParam, lParam);
1727         else
1728         {
1729                     // Rely on MSWNotify to check whether the message
1730                         // belongs to the window or not
1731                 wxNode *node = GetChildren()->First();
1732                 while (node)
1733                 {
1734                         wxWindow *child = (wxWindow *)node->Data();
1735                                 if ( child->MSWNotify(wParam, lParam) )
1736                                         return TRUE;
1737                                 node = node->Next();
1738                 }
1739         }
1740
1741     return FALSE;
1742
1743 #endif
1744   return FALSE;
1745 }
1746
1747 void wxWindow::MSWOnMenuHighlight(const WXWORD WXUNUSED(item), const WXWORD WXUNUSED(flags), const WXHMENU WXUNUSED(sysmenu))
1748 {
1749 #if DEBUG > 1
1750   wxDebugMsg("wxWindow::MSWOnMenuHighlight %d\n", handle);
1751 #endif
1752 }
1753
1754 void wxWindow::MSWOnInitMenuPopup(const WXHMENU menu, const int pos, const bool isSystem)
1755 {
1756   if (!isSystem)
1757     OldOnInitMenuPopup(pos);
1758 }
1759
1760 bool wxWindow::MSWOnActivate(const int state, const bool WXUNUSED(minimized), const WXHWND WXUNUSED(activate))
1761 {
1762 #if DEBUG > 1
1763   wxDebugMsg("wxWindow::MSWOnActivate %d\n", handle);
1764 #endif
1765
1766 #if WXWIN_COMPATIBILITY
1767   GetEventHandler()->OldOnActivate(((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)));
1768 #else
1769   wxActivateEvent event(wxEVT_ACTIVATE, ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)),
1770           m_windowId);
1771   event.m_eventObject = this;
1772   GetEventHandler()->ProcessEvent(event);
1773 #endif
1774   return 0;
1775 }
1776
1777 bool wxWindow::MSWOnSetFocus(const WXHWND WXUNUSED(hwnd))
1778 {
1779 #if DEBUG > 1
1780   wxDebugMsg("wxWindow::MSWOnSetFocus %d\n", m_hWnd);
1781 #endif
1782     // Deal with caret
1783     if (m_caretEnabled && (m_caretWidth > 0) && (m_caretHeight > 0))
1784     {
1785       ::CreateCaret((HWND) GetHWND(), NULL, m_caretWidth, m_caretHeight);
1786       if (m_caretShown)
1787         ::ShowCaret((HWND) GetHWND());
1788     }
1789
1790 #if WXWIN_COMPATIBILITY
1791   GetEventHandler()->OldOnSetFocus();
1792 #else
1793   wxFocusEvent event(wxEVT_SET_FOCUS, m_windowId);
1794   event.m_eventObject = this;
1795   GetEventHandler()->ProcessEvent(event);
1796 #endif
1797     return TRUE;
1798 }
1799
1800 bool wxWindow::MSWOnKillFocus(const WXHWND WXUNUSED(hwnd))
1801 {
1802 #if DEBUG > 1
1803   wxDebugMsg("wxWindow::MSWOnKillFocus %d\n", m_hWnd);
1804 #endif
1805     // Deal with caret
1806     if (m_caretEnabled)
1807     {
1808       ::DestroyCaret();
1809     }
1810
1811 #if WXWIN_COMPATIBILITY
1812   GetEventHandler()->OldOnKillFocus();
1813 #else
1814   wxFocusEvent event(wxEVT_KILL_FOCUS, m_windowId);
1815   event.m_eventObject = this;
1816   GetEventHandler()->ProcessEvent(event);
1817 #endif
1818   return TRUE;
1819 }
1820
1821 void wxWindow::MSWOnDropFiles(const WXWPARAM wParam)
1822 {
1823 #if DEBUG > 1
1824   wxDebugMsg("wxWindow::MSWOnDropFiles %d\n", m_hWnd);
1825 #endif
1826
1827   HANDLE hFilesInfo = (HANDLE)wParam;
1828   POINT dropPoint;
1829   DragQueryPoint(hFilesInfo, (LPPOINT) &dropPoint);
1830
1831   // Get the total number of files dropped
1832   WORD gwFilesDropped = (WORD)DragQueryFile ((HDROP)hFilesInfo,
1833                                    (UINT)-1,
1834                                    (LPSTR)0,
1835                                    (UINT)0);
1836
1837   wxString *files = new wxString[gwFilesDropped];
1838   int wIndex;
1839   for (wIndex=0; wIndex < (int)gwFilesDropped; wIndex++)
1840   {
1841     DragQueryFile (hFilesInfo, wIndex, (LPSTR) wxBuffer, 1000);
1842     files[wIndex] = wxBuffer;
1843   }
1844   DragFinish (hFilesInfo);
1845
1846   wxDropFilesEvent event(wxEVT_DROP_FILES, gwFilesDropped, files);
1847   event.m_eventObject = this;
1848   event.m_pos.x = dropPoint.x; event.m_pos.x = dropPoint.y;
1849
1850   GetEventHandler()->ProcessEvent(event);
1851
1852   delete[] files;
1853 }
1854
1855 bool wxWindow::MSWOnDrawItem(const int id, WXDRAWITEMSTRUCT *itemStruct)
1856 {
1857 #if USE_OWNER_DRAWN
1858     if ( id == 0 ) {    // is it a menu item?
1859       DRAWITEMSTRUCT *pDrawStruct = (DRAWITEMSTRUCT *)itemStruct;
1860       wxMenuItem *pMenuItem = (wxMenuItem *)(pDrawStruct->itemData);
1861       wxCHECK_RET( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
1862
1863       // prepare to call OnDrawItem()
1864       wxDC dc;
1865       dc.SetHDC((WXHDC)pDrawStruct->hDC, FALSE);
1866       wxRect rect(pDrawStruct->rcItem.left, pDrawStruct->rcItem.top,
1867                   pDrawStruct->rcItem.right - pDrawStruct->rcItem.left,
1868                   pDrawStruct->rcItem.bottom - pDrawStruct->rcItem.top);
1869       return pMenuItem->OnDrawItem(
1870                dc, rect,
1871                (wxOwnerDrawn::wxODAction)pDrawStruct->itemAction,
1872                (wxOwnerDrawn::wxODStatus)pDrawStruct->itemState
1873              );
1874     }
1875 #endif  // owner-drawn menus
1876
1877   wxWindow *item = FindItem(id);
1878 #if USE_DYNAMIC_CLASSES
1879   if (item && item->IsKindOf(CLASSINFO(wxControl)))
1880   {
1881     return ((wxControl *)item)->MSWOnDraw(itemStruct);
1882   }
1883   else
1884 #endif
1885     return FALSE;
1886 }
1887
1888 bool wxWindow::MSWOnMeasureItem(const int id, WXMEASUREITEMSTRUCT *itemStruct)
1889 {
1890 #if USE_OWNER_DRAWN
1891     if ( id == 0 ) {    // is it a menu item?
1892       MEASUREITEMSTRUCT *pMeasureStruct = (MEASUREITEMSTRUCT *)itemStruct;
1893       wxMenuItem *pMenuItem = (wxMenuItem *)(pMeasureStruct->itemData);
1894       wxCHECK_RET( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
1895
1896       return pMenuItem->OnMeasureItem(&pMeasureStruct->itemWidth,
1897                                       &pMeasureStruct->itemHeight);
1898     }
1899 #endif  // owner-drawn menus
1900
1901   wxWindow *item = FindItem(id);
1902 #if USE_DYNAMIC_CLASSES
1903   if (item && item->IsKindOf(CLASSINFO(wxControl)))
1904   {
1905     return ((wxControl *)item)->MSWOnMeasure(itemStruct);
1906   }
1907   else
1908 #endif
1909     return FALSE;
1910 }
1911
1912 WXHBRUSH wxWindow::MSWOnCtlColor(const WXHDC pDC, const WXHWND pWnd, const WXUINT nCtlColor,
1913                          const WXUINT message, const WXWPARAM wParam, const WXLPARAM lParam)
1914 {
1915 #if DEBUG > 1
1916   wxDebugMsg("wxWindow::MSWOnCtlColour %d\n", m_hWnd);
1917 #endif
1918   if (nCtlColor == CTLCOLOR_DLG)
1919   {
1920         return OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
1921   }
1922
1923   wxControl *item = (wxControl *)FindItemByHWND(pWnd, TRUE);
1924
1925   WXHBRUSH hBrush = 0;
1926
1927   if ( item )
1928         hBrush = item->OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
1929
1930   // I think that even for dialogs, we may need to call DefWindowProc (?)
1931   // Or maybe just rely on the usual default behaviour.
1932   if ( !hBrush )
1933     hBrush = (WXHBRUSH) MSWDefWindowProc(message, wParam, lParam);
1934
1935   return hBrush ;
1936 }
1937
1938 // Define for each class of dialog and control
1939 WXHBRUSH wxWindow::OnCtlColor(const WXHDC pDC, const WXHWND pWnd, const WXUINT nCtlColor,
1940                         WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
1941 {
1942     return (WXHBRUSH) MSWDefWindowProc(message, wParam, lParam);
1943 }
1944
1945 bool wxWindow::MSWOnColorChange(const WXHWND hWnd, const WXUINT message, const WXWPARAM wParam, const WXLPARAM lParam)
1946 {
1947   wxSysColourChangedEvent event;
1948   event.m_eventObject = this;
1949
1950   // Check if app handles this.
1951   if (GetEventHandler()->ProcessEvent(event))
1952     return 0;
1953
1954 #if WXWIN_COMPATIBILITY
1955   if (GetEventHandler()->OldOnSysColourChange())
1956     return 0;
1957 #endif
1958
1959   // We didn't process it
1960   return 1;
1961 }
1962
1963 // Responds to colour changes: passes event on to children.
1964 void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
1965 {
1966     wxNode *node = GetChildren()->First();
1967     while ( node )
1968     {
1969         // Only propagate to non-top-level windows
1970         wxWindow *win = (wxWindow *)node->Data();
1971         if ( win->GetParent() )
1972         {
1973             wxSysColourChangedEvent event2;
1974             event.m_eventObject = win;
1975             win->GetEventHandler()->ProcessEvent(event2);
1976         }
1977
1978         node = node->Next();
1979     }
1980 }
1981
1982 long wxWindow::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
1983 {
1984   if ( m_oldWndProc )
1985         return ::CallWindowProc(CASTWNDPROC (FARPROC) m_oldWndProc, (HWND) GetHWND(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
1986   else
1987         return ::DefWindowProc((HWND) GetHWND(), nMsg, wParam, lParam);
1988 }
1989
1990 long wxWindow::Default()
1991 {
1992   return this->MSWDefWindowProc(m_lastMsg, m_lastWParam, m_lastLParam);
1993 }
1994
1995 bool wxWindow::MSWProcessMessage(WXMSG* pMsg)
1996 {
1997   if (!m_hWnd)
1998     return FALSE;
1999   else
2000   {
2001     // Suggestion by Andrew Davison to allow
2002     // a panel to accept character input in user edit mode
2003
2004     // OK, what we probably want to do here for wxWin 2.0
2005     // is have a window style to indicate whether the window
2006     // should process dialog-style input, since we can't
2007     // otherwise tell whether it's supposed to do tab traversal
2008     // or not.
2009     if (GetWindowStyleFlag() & wxTAB_TRAVERSAL)
2010       return (::IsDialogMessage((HWND) m_hWnd, (MSG *)pMsg) != 0);
2011     else
2012       return FALSE;
2013   }
2014 }
2015
2016 long wxWindow::MSWOnMDIActivate(const long WXUNUSED(flag), const WXHWND WXUNUSED(activate), const WXHWND WXUNUSED(deactivate))
2017 {
2018 #if DEBUG > 1
2019   wxDebugMsg("wxWindow::MSWOnMDIActivate %d\n", m_hWnd);
2020 #endif
2021   return 1;
2022 }
2023
2024 void wxWindow::MSWDetachWindowMenu(void)
2025 {
2026   if (m_hMenu)
2027   {
2028     int N = GetMenuItemCount((HMENU) m_hMenu);
2029     int i;
2030     for (i = 0; i < N; i++)
2031     {
2032       char buf[100];
2033       int chars = GetMenuString((HMENU) m_hMenu, i, buf, 100, MF_BYPOSITION);
2034       if ((chars > 0) && (strcmp(buf, "&Window") == 0))
2035       {
2036         RemoveMenu((HMENU) m_hMenu, i, MF_BYPOSITION);
2037         break;
2038       }
2039     }
2040   }
2041 }
2042
2043 bool wxWindow::MSWOnPaint(void)
2044 {
2045 #if WXWIN_COMPATIBILITY
2046   GetEventHandler()->OldOnPaint();
2047 #else
2048   wxPaintEvent event(m_windowId);
2049   event.m_eventObject = this;
2050   GetEventHandler()->ProcessEvent(event);
2051 #endif
2052   return TRUE;
2053
2054 #if 0
2055
2056 #if DEBUG > 1
2057   wxDebugMsg("wxWindow::MSWOnPaint %d\n", m_hWnd);
2058 #endif
2059 #ifdef __WIN32__
2060   HRGN  tRgn=CreateRectRgn(0,0,0,0);    //Dummy call to get a handle!
2061   if (GetUpdateRgn(m_hWnd, tRgn, FALSE))
2062 #else
2063   RECT tRect;
2064   if (GetUpdateRect((HWND) m_hWnd, &tRect, FALSE))
2065 #endif
2066   {
2067     PAINTSTRUCT ps;
2068     // Hold a pointer to the dc so long as the OnPaint() message
2069     // is being processed
2070     HDC dc = BeginPaint(m_hWnd, &ps);
2071     bool isPanel = IsKindOf(CLASSINFO(wxWindow));
2072     m_paintHDC = (WXHDC) dc;
2073     RECT updateRect1 = ps.rcPaint;
2074         m_updateRect.x = updateRect1.left;
2075         m_updateRect.y = updateRect1.top;
2076         m_updateRect.width = updateRect1.right - updateRect1.left;
2077         m_updateRect.height = updateRect1.bottom - updateRect1.top;
2078
2079     GetEventHandler()->OldOnPaint();
2080
2081     m_paintHDC = 0;
2082     EndPaint((HWND) m_hWnd, &ps);
2083 #ifdef __WIN32__
2084     DeleteObject(tRgn);
2085 #endif
2086
2087     if (isPanel)
2088       // Do default processing
2089       return FALSE;
2090     else
2091       return TRUE;
2092   }
2093 #ifdef __WIN32__
2094   DeleteObject(tRgn);
2095 #endif
2096   return FALSE;
2097 #endif
2098 }
2099
2100 void wxWindow::MSWOnSize(const int w, const int h, const WXUINT WXUNUSED(flag))
2101 {
2102   if (m_inOnSize)
2103     return;
2104
2105 #if DEBUG > 1
2106   wxDebugMsg("wxWindow::MSWOnSize %d\n", m_hWnd);
2107 #endif
2108   if (!m_hWnd)
2109     return;
2110
2111   m_inOnSize = TRUE;
2112
2113 #if WXWIN_COMPATIBILITY
2114   GetEventHandler()->OldOnSize(w, h);
2115 #else
2116   wxSizeEvent event(wxSize(w, h), m_windowId);
2117   event.m_eventObject = this;
2118   GetEventHandler()->ProcessEvent(event);
2119 #endif
2120
2121   m_inOnSize = FALSE;
2122 }
2123
2124 void wxWindow::MSWOnWindowPosChanging(void *WXUNUSED(lpPos))
2125 {
2126     Default();
2127 }
2128
2129 // Deal with child commands from buttons etc.
2130 bool wxWindow::MSWOnCommand(const WXWORD id, const WXWORD cmd, const WXHWND WXUNUSED(control))
2131 {
2132 #if DEBUG > 1
2133   wxDebugMsg("wxWindow::MSWOnCommand\n");
2134 #endif
2135   if (wxCurrentPopupMenu)
2136   {
2137     wxMenu *popupMenu = wxCurrentPopupMenu;
2138     wxCurrentPopupMenu = NULL;
2139     bool succ = popupMenu->MSWCommand(cmd, id);
2140     return succ;
2141   }
2142 #if DEBUG > 1
2143   char buf[80];
2144   sprintf(buf, "Looking for item %d...\n", id);
2145   wxDebugMsg(buf);
2146 #endif
2147
2148   wxWindow *item = FindItem(id);
2149   if (item)
2150   {
2151     bool value = item->MSWCommand(cmd, id);
2152 #if DEBUG > 1
2153     if (value)
2154       wxDebugMsg("MSWCommand succeeded\n");
2155     else
2156       wxDebugMsg("MSWCommand failed\n");
2157 #endif
2158     return value;
2159   }
2160   else
2161   {
2162 #if DEBUG > 1
2163     wxDebugMsg("Could not find item!\n");
2164     char buf[100];
2165     wxDebugMsg("Item ids for this panel:\n");
2166
2167     wxNode *current = GetChildren()->First();
2168     while (current)
2169     {
2170       wxObject *obj = (wxObject *)current->Data() ;
2171       if (obj->IsKindOf(CLASSINFO(wxControl)))
2172       {
2173         wxControl *item = (wxControl *)current->Data();
2174         sprintf(buf, "  %d\n", (int)item->m_windowId);
2175         wxDebugMsg(buf);
2176       }
2177       current = current->Next();
2178     }
2179     wxYield();
2180 #endif
2181     return FALSE;
2182   }
2183 }
2184
2185 long wxWindow::MSWOnSysCommand(WXWPARAM wParam, WXLPARAM lParam)
2186 {
2187     switch (wParam)
2188     {
2189         case SC_MAXIMIZE:
2190         {
2191             wxMaximizeEvent event(m_windowId);
2192             event.SetEventObject(this);
2193             if (!GetEventHandler()->ProcessEvent(event))
2194                 return Default();
2195             else
2196                 return 0;
2197             break;
2198         }
2199         case SC_MINIMIZE:
2200         {
2201             wxIconizeEvent event(m_windowId);
2202             event.SetEventObject(this);
2203             if (!GetEventHandler()->ProcessEvent(event))
2204                 return Default();
2205             else
2206                 return 0;
2207             break;
2208         }
2209         default:
2210             return Default();
2211     }
2212     return 0;
2213 }
2214
2215 void wxWindow::MSWOnLButtonDown(const int x, const int y, const WXUINT flags)
2216 {
2217 #if 0 // defined(__WIN32__) && !defined(WIN95)
2218   // DClick not clean supported on Win3.1, except if someone know
2219   // how to emulate Sleep()...
2220   // This means that your app will receive Down-Up-Dclick sequences
2221   // rather than Dclick
2222   if (m_doubleClickAllowed)
2223   {
2224     UINT time = GetDoubleClickTime() ;
2225     Sleep(time) ;
2226     MSG dummy ;
2227     if (PeekMessage(&dummy,m_hWnd,
2228                     WM_LBUTTONDBLCLK,WM_LBUTTONDBLCLK,
2229                     PM_NOREMOVE)
2230        )
2231     {
2232       PeekMessage(&dummy,m_hWnd,WM_LBUTTONUP,WM_LBUTTONUP,PM_REMOVE);
2233       return;
2234     }
2235   }
2236 #endif
2237
2238   wxMouseEvent event(wxEVENT_TYPE_LEFT_DOWN);
2239
2240   event.m_x = x; event.m_y = y;
2241   event.m_shiftDown = ((flags & MK_SHIFT) != 0);
2242   event.m_controlDown = ((flags & MK_CONTROL) != 0);
2243   event.m_leftDown = ((flags & MK_LBUTTON) != 0);
2244   event.m_middleDown = ((flags & MK_MBUTTON) != 0);
2245   event.m_rightDown = ((flags & MK_RBUTTON) != 0);
2246   event.SetTimestamp(wxApp::sm_lastMessageTime); /* MATTHEW: timeStamp */
2247   event.m_eventObject = this;
2248
2249   m_lastXPos = event.m_x; m_lastYPos = event.m_y; m_lastEvent = wxEVENT_TYPE_LEFT_DOWN;
2250   GetEventHandler()->OldOnMouseEvent(event);
2251 }
2252
2253 void wxWindow::MSWOnLButtonUp(const int x, const int y, const WXUINT flags)
2254 {
2255   wxMouseEvent event(wxEVENT_TYPE_LEFT_UP);
2256
2257   event.m_x = x; event.m_y = y;
2258   event.m_shiftDown = ((flags & MK_SHIFT) != 0);
2259   event.m_controlDown = ((flags & MK_CONTROL) != 0);
2260   event.m_leftDown = ((flags & MK_LBUTTON) != 0);
2261   event.m_middleDown = ((flags & MK_MBUTTON) != 0);
2262   event.m_rightDown = ((flags & MK_RBUTTON) != 0);
2263   event.SetTimestamp(wxApp::sm_lastMessageTime); /* MATTHEW: timeStamp */
2264   event.m_eventObject = this;
2265
2266   m_lastXPos = event.m_x; m_lastYPos = event.m_y; m_lastEvent = wxEVENT_TYPE_LEFT_UP;
2267
2268   GetEventHandler()->OldOnMouseEvent(event);
2269 }
2270
2271 void wxWindow::MSWOnLButtonDClick(const int x, const int y, const WXUINT flags)
2272 {
2273   /* MATTHEW: If dclick not allowed, generate another single-click */
2274   wxMouseEvent event(m_doubleClickAllowed ?
2275                      wxEVENT_TYPE_LEFT_DCLICK : wxEVENT_TYPE_LEFT_DOWN);
2276
2277   event.m_x = x; event.m_y = y;
2278   event.m_shiftDown = ((flags & MK_SHIFT) != 0);
2279   event.m_controlDown = ((flags & MK_CONTROL) != 0);
2280   event.m_leftDown = ((flags & MK_LBUTTON != 0));
2281   event.m_middleDown = ((flags & MK_MBUTTON) != 0);
2282   event.m_rightDown = ((flags & MK_RBUTTON) != 0);
2283   event.SetTimestamp(wxApp::sm_lastMessageTime); /* MATTHEW: timeStamp */
2284   event.m_eventObject = this;
2285
2286   m_lastXPos = event.m_x; m_lastYPos = event.m_y; m_lastEvent = wxEVENT_TYPE_LEFT_DCLICK;
2287
2288 //  if (m_doubleClickAllowed)
2289      GetEventHandler()->OldOnMouseEvent(event);
2290 }
2291
2292 void wxWindow::MSWOnMButtonDown(const int x, const int y, const WXUINT flags)
2293 {
2294 #if 0 // defined(__WIN32__) && !defined(__WIN95__)
2295   // DClick not clean supported on Win3.1, except if someone know
2296   // how to emulate Sleep()...
2297   // This means that your app will receive Down-Up-Dclick sequences
2298   // rather than Dclick
2299   if (m_doubleClickAllowed)
2300   {
2301     UINT time = GetDoubleClickTime() ;
2302     Sleep(time) ;
2303     MSG dummy ;
2304     if (PeekMessage(&dummy,m_hWnd,
2305                     WM_MBUTTONDBLCLK,WM_MBUTTONDBLCLK,
2306                     PM_NOREMOVE)
2307        )
2308     {
2309       PeekMessage(&dummy,m_hWnd,WM_MBUTTONUP,WM_MBUTTONUP,PM_REMOVE);
2310       return;
2311     }
2312   }
2313 #endif
2314
2315   wxMouseEvent event(wxEVENT_TYPE_MIDDLE_DOWN);
2316
2317   event.m_x = x; event.m_y = y;
2318   event.m_shiftDown = ((flags & MK_SHIFT) != 0);
2319   event.m_controlDown = ((flags & MK_CONTROL) != 0);
2320   event.m_leftDown = ((flags & MK_LBUTTON) != 0);
2321   event.m_middleDown = ((flags & MK_MBUTTON) != 0);
2322   event.m_rightDown = ((flags & MK_RBUTTON) != 0);
2323   event.SetTimestamp(wxApp::sm_lastMessageTime); /* MATTHEW: timeStamp */
2324   event.m_eventObject = this;
2325
2326   m_lastXPos = event.m_x; m_lastYPos = event.m_y; m_lastEvent = wxEVENT_TYPE_LEFT_DOWN;
2327   GetEventHandler()->OldOnMouseEvent(event);
2328 }
2329
2330 void wxWindow::MSWOnMButtonUp(const int x, const int y, const WXUINT flags)
2331 {
2332 //wxDebugMsg("MButtonUp\n") ;
2333   wxMouseEvent event(wxEVENT_TYPE_MIDDLE_UP);
2334
2335   event.m_x = x; event.m_y = y;
2336   event.m_shiftDown = ((flags & MK_SHIFT) != 0);
2337   event.m_controlDown = ((flags & MK_CONTROL) != 0);
2338   event.m_leftDown = ((flags & MK_LBUTTON) != 0);
2339   event.m_middleDown = ((flags & MK_MBUTTON) != 0);
2340   event.m_rightDown = ((flags & MK_RBUTTON) != 0);
2341   event.SetTimestamp(wxApp::sm_lastMessageTime); /* MATTHEW: timeStamp */
2342   event.m_eventObject = this;
2343
2344   m_lastXPos = event.m_x; m_lastYPos = event.m_y; m_lastEvent = wxEVENT_TYPE_LEFT_UP;
2345   GetEventHandler()->OldOnMouseEvent(event);
2346 }
2347
2348 void wxWindow::MSWOnMButtonDClick(const int x, const int y, const WXUINT flags)
2349 {
2350 //wxDebugMsg("MButtonDClick\n") ;
2351   /* MATTHEW: If dclick not allowed, generate another single-click */
2352   wxMouseEvent event((m_doubleClickAllowed) ?
2353                      wxEVENT_TYPE_MIDDLE_DCLICK : wxEVENT_TYPE_MIDDLE_DOWN);
2354
2355   event.m_x = x; event.m_y = y;
2356   event.m_shiftDown = ((flags & MK_SHIFT) != 0);
2357   event.m_controlDown = ((flags & MK_CONTROL) != 0);
2358   event.m_leftDown = ((flags & MK_LBUTTON) != 0);
2359   event.m_middleDown = ((flags & MK_MBUTTON) != 0);
2360   event.m_rightDown = ((flags & MK_RBUTTON) != 0);
2361   event.SetTimestamp(wxApp::sm_lastMessageTime); /* MATTHEW: timeStamp */
2362   event.m_eventObject = this;
2363
2364   m_lastXPos = event.m_x; m_lastYPos = event.m_y; m_lastEvent = wxEVENT_TYPE_LEFT_DCLICK;
2365 //  if (m_doubleClickAllowed)
2366      GetEventHandler()->OldOnMouseEvent(event);
2367 }
2368
2369 void wxWindow::MSWOnRButtonDown(const int x, const int y, const WXUINT flags)
2370 {
2371 #if 0 // defined(__WIN32__) && !defined(__WIN95__)
2372   // DClick not clean supported on Win3.1, except if someone know
2373   // how to emulate Sleep()...
2374   // This means that your app will receive Down-Up-Dclick sequences
2375   // rather than Dclick
2376   if (m_doubleClickAllowed)
2377   {
2378     UINT time = GetDoubleClickTime() ;
2379     Sleep(time) ;
2380     MSG dummy ;
2381     if (PeekMessage(&dummy,m_hWnd,
2382                     WM_RBUTTONDBLCLK,WM_RBUTTONDBLCLK,
2383                     PM_NOREMOVE)
2384        )
2385     {
2386       PeekMessage(&dummy,m_hWnd,WM_RBUTTONUP,WM_RBUTTONUP,PM_REMOVE);
2387       return;
2388     }
2389   }
2390 #endif
2391
2392   wxMouseEvent event(wxEVENT_TYPE_RIGHT_DOWN);
2393
2394   event.m_x = x; event.m_y = y;
2395   event.m_shiftDown = ((flags & MK_SHIFT) != 0);
2396   event.m_controlDown = ((flags & MK_CONTROL) != 0);
2397   event.m_leftDown = ((flags & MK_LBUTTON) != 0);
2398   event.m_middleDown = ((flags & MK_MBUTTON) != 0);
2399   event.m_rightDown = ((flags & MK_RBUTTON) != 0);
2400   event.SetTimestamp(wxApp::sm_lastMessageTime); /* MATTHEW: timeStamp */
2401   event.m_eventObject = this;
2402
2403   m_lastXPos = event.m_x; m_lastYPos = event.m_y; m_lastEvent = wxEVENT_TYPE_RIGHT_DOWN;
2404   GetEventHandler()->OldOnMouseEvent(event);
2405 }
2406
2407 void wxWindow::MSWOnRButtonUp(const int x, const int y, const WXUINT flags)
2408 {
2409   wxMouseEvent event(wxEVENT_TYPE_RIGHT_UP);
2410
2411   event.m_x = x; event.m_y = y;
2412   event.m_shiftDown = ((flags & MK_SHIFT) != 0);
2413   event.m_controlDown = ((flags & MK_CONTROL) != 0);
2414   event.m_leftDown = ((flags & MK_LBUTTON) != 0);
2415   event.m_middleDown = ((flags & MK_MBUTTON) != 0);
2416   event.m_rightDown = ((flags & MK_RBUTTON) != 0);
2417   event.m_eventObject = this;
2418   event.SetTimestamp(wxApp::sm_lastMessageTime); /* MATTHEW: timeStamp */
2419
2420   m_lastXPos = event.m_x; m_lastYPos = event.m_y; m_lastEvent = wxEVENT_TYPE_RIGHT_UP;
2421   GetEventHandler()->OldOnMouseEvent(event);
2422 }
2423
2424 void wxWindow::MSWOnRButtonDClick(const int x, const int y, const WXUINT flags)
2425 {
2426   /* MATTHEW: If dclick not allowed, generate another single-click */
2427   wxMouseEvent event((m_doubleClickAllowed) ?
2428                      wxEVENT_TYPE_RIGHT_DCLICK : wxEVENT_TYPE_RIGHT_DOWN);
2429
2430   event.m_x = x; event.m_y = y;
2431   event.m_shiftDown = ((flags & MK_SHIFT) != 0);
2432   event.m_controlDown = ((flags & MK_CONTROL) != 0);
2433   event.m_leftDown = ((flags & MK_LBUTTON) != 0);
2434   event.m_middleDown = ((flags & MK_MBUTTON) != 0);
2435   event.m_rightDown = ((flags & MK_RBUTTON) != 0);
2436   event.SetTimestamp(wxApp::sm_lastMessageTime); /* MATTHEW: timeStamp */
2437   event.m_eventObject = this;
2438
2439   m_lastXPos = event.m_x; m_lastYPos = event.m_y; m_lastEvent = wxEVENT_TYPE_RIGHT_DCLICK;
2440 //  if (m_doubleClickAllowed)
2441      GetEventHandler()->OldOnMouseEvent(event);
2442 }
2443
2444 void wxWindow::MSWOnMouseMove(const int x, const int y, const WXUINT flags)
2445 {
2446   // 'normal' move event...
2447   // Set cursor, but only if we're not in 'busy' mode
2448
2449   // Trouble with this is that it sets the cursor for controls too :-(
2450   if (m_windowCursor.Ok() && !wxIsBusy())
2451     ::SetCursor((HCURSOR) m_windowCursor.GetHCURSOR());
2452
2453   if (!m_mouseInWindow)
2454   {
2455     // Generate an ENTER event
2456     m_mouseInWindow = TRUE;
2457     MSWOnMouseEnter(x, y, flags);
2458   }
2459
2460   wxMouseEvent event(wxEVENT_TYPE_MOTION);
2461
2462   event.m_x = x; event.m_y = y;
2463   event.m_shiftDown = ((flags & MK_SHIFT) != 0);
2464   event.m_controlDown = ((flags & MK_CONTROL) != 0);
2465   event.m_leftDown = ((flags & MK_LBUTTON) != 0);
2466   event.m_middleDown = ((flags & MK_MBUTTON) != 0);
2467   event.m_rightDown = ((flags & MK_RBUTTON) != 0);
2468   event.SetTimestamp(wxApp::sm_lastMessageTime); /* MATTHEW: timeStamp */
2469   event.m_eventObject = this;
2470
2471   // Window gets a click down message followed by a mouse move
2472   // message even if position isn't changed!  We want to discard
2473   // the trailing move event if x and y are the same.
2474   if ((m_lastEvent == wxEVENT_TYPE_RIGHT_DOWN || m_lastEvent == wxEVENT_TYPE_LEFT_DOWN ||
2475        m_lastEvent == wxEVENT_TYPE_MIDDLE_DOWN) &&
2476       (m_lastXPos == event.m_x && m_lastYPos == event.m_y))
2477   {
2478     m_lastXPos = event.m_x; m_lastYPos = event.m_y;
2479     m_lastEvent = wxEVENT_TYPE_MOTION;
2480     return;
2481   }
2482
2483   m_lastEvent = wxEVENT_TYPE_MOTION;
2484   m_lastXPos = event.m_x; m_lastYPos = event.m_y;
2485   GetEventHandler()->OldOnMouseEvent(event);
2486 }
2487
2488 void wxWindow::MSWOnMouseEnter(const int x, const int y, const WXUINT flags)
2489 {
2490   wxMouseEvent event(wxEVT_ENTER_WINDOW);
2491
2492   event.m_x = x; event.m_y = y;
2493   event.m_shiftDown = ((flags & MK_SHIFT) != 0);
2494   event.m_controlDown = ((flags & MK_CONTROL) != 0);
2495   event.m_leftDown = ((flags & MK_LBUTTON) != 0);
2496   event.m_middleDown = ((flags & MK_MBUTTON) != 0);
2497   event.m_rightDown = ((flags & MK_RBUTTON) != 0);
2498   event.SetTimestamp(wxApp::sm_lastMessageTime); /* MATTHEW: timeStamp */
2499   event.m_eventObject = this;
2500
2501   m_lastEvent = wxEVT_ENTER_WINDOW;
2502   m_lastXPos = event.m_x; m_lastYPos = event.m_y;
2503   GetEventHandler()->OldOnMouseEvent(event);
2504 }
2505
2506 void wxWindow::MSWOnMouseLeave(const int x, const int y, const WXUINT flags)
2507 {
2508   wxMouseEvent event(wxEVT_LEAVE_WINDOW);
2509
2510   event.m_x = x; event.m_y = y;
2511   event.m_shiftDown = ((flags & MK_SHIFT) != 0);
2512   event.m_controlDown = ((flags & MK_CONTROL) != 0);
2513   event.m_leftDown = ((flags & MK_LBUTTON) != 0);
2514   event.m_middleDown = ((flags & MK_MBUTTON) != 0);
2515   event.m_rightDown = ((flags & MK_RBUTTON) != 0);
2516   event.SetTimestamp(wxApp::sm_lastMessageTime); /* MATTHEW: timeStamp */
2517   event.m_eventObject = this;
2518
2519   m_lastEvent = wxEVT_LEAVE_WINDOW;
2520   m_lastXPos = event.m_x; m_lastYPos = event.m_y;
2521   GetEventHandler()->OldOnMouseEvent(event);
2522 }
2523
2524 void wxWindow::MSWOnChar(const WXWORD wParam, const WXLPARAM lParam, const bool isASCII)
2525 {
2526   int id;
2527   bool tempControlDown = FALSE;
2528   if (isASCII)
2529   {
2530     // If 1 -> 26, translate to CTRL plus a letter.
2531     id = wParam;
2532     if ((id > 0) && (id < 27))
2533     {
2534       switch (id)
2535       {
2536         case 13:
2537         {
2538           id = WXK_RETURN;
2539           break;
2540         }
2541         case 8:
2542         {
2543           id = WXK_BACK;
2544           break;
2545         }
2546         case 9:
2547         {
2548           id = WXK_TAB;
2549           break;
2550         }
2551         default:
2552         {
2553           tempControlDown = TRUE;
2554           id = id + 96;
2555         }
2556       }
2557     }
2558   }
2559   else
2560     if ((id = wxCharCodeMSWToWX(wParam)) == 0)
2561       id = -1;
2562
2563   if (id > -1)
2564   {
2565     wxKeyEvent event(wxEVT_CHAR);
2566     event.m_shiftDown = (::GetKeyState(VK_SHIFT)&0x100?TRUE:FALSE);
2567     event.m_controlDown = (::GetKeyState(VK_CONTROL)&0x100?TRUE:FALSE);
2568     if ((HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN)
2569       event.m_altDown = TRUE;
2570
2571     event.m_eventObject = this;
2572     event.m_keyCode = id;
2573     event.SetTimestamp(wxApp::sm_lastMessageTime); /* MATTHEW: timeStamp */
2574
2575     POINT pt ;
2576     GetCursorPos(&pt) ;
2577     RECT rect ;
2578     GetWindowRect((HWND) GetHWND(),&rect) ;
2579     pt.x -= rect.left ;
2580     pt.y -= rect.top ;
2581
2582     event.m_x = pt.x; event.m_y = pt.y;
2583
2584 #if WXWIN_COMPATIBILITY
2585     GetEventHandler()->OldOnChar(event);
2586 #else
2587     if (!GetEventHandler()->ProcessEvent(event))
2588                 Default();
2589 #endif
2590   }
2591 }
2592
2593 void wxWindow::MSWOnJoyDown(const int joystick, const int x, const int y, const WXUINT flags)
2594 {
2595     int buttons = 0;
2596     int change = 0;
2597     if (flags & JOY_BUTTON1CHG)
2598         change = wxJOY_BUTTON1;
2599     if (flags & JOY_BUTTON2CHG)
2600         change = wxJOY_BUTTON2;
2601     if (flags & JOY_BUTTON3CHG)
2602         change = wxJOY_BUTTON3;
2603     if (flags & JOY_BUTTON4CHG)
2604         change = wxJOY_BUTTON4;
2605
2606     if (flags & JOY_BUTTON1)
2607         buttons |= wxJOY_BUTTON1;
2608     if (flags & JOY_BUTTON2)
2609         buttons |= wxJOY_BUTTON2;
2610     if (flags & JOY_BUTTON3)
2611         buttons |= wxJOY_BUTTON3;
2612     if (flags & JOY_BUTTON4)
2613         buttons |= wxJOY_BUTTON4;
2614
2615     wxJoystickEvent event(wxEVT_JOY_BUTTON_DOWN, buttons, joystick, change);
2616     event.SetPosition(wxPoint(x, y));
2617     event.SetEventObject(this);
2618
2619     GetEventHandler()->ProcessEvent(event);
2620 }
2621
2622 void wxWindow::MSWOnJoyUp(const int joystick, const int x, const int y, const WXUINT flags)
2623 {
2624     int buttons = 0;
2625     int change = 0;
2626     if (flags & JOY_BUTTON1CHG)
2627         change = wxJOY_BUTTON1;
2628     if (flags & JOY_BUTTON2CHG)
2629         change = wxJOY_BUTTON2;
2630     if (flags & JOY_BUTTON3CHG)
2631         change = wxJOY_BUTTON3;
2632     if (flags & JOY_BUTTON4CHG)
2633         change = wxJOY_BUTTON4;
2634
2635     if (flags & JOY_BUTTON1)
2636         buttons |= wxJOY_BUTTON1;
2637     if (flags & JOY_BUTTON2)
2638         buttons |= wxJOY_BUTTON2;
2639     if (flags & JOY_BUTTON3)
2640         buttons |= wxJOY_BUTTON3;
2641     if (flags & JOY_BUTTON4)
2642         buttons |= wxJOY_BUTTON4;
2643
2644     wxJoystickEvent event(wxEVT_JOY_BUTTON_UP, buttons, joystick, change);
2645     event.SetPosition(wxPoint(x, y));
2646     event.SetEventObject(this);
2647
2648     GetEventHandler()->ProcessEvent(event);
2649 }
2650
2651 void wxWindow::MSWOnJoyMove(const int joystick, const int x, const int y, const WXUINT flags)
2652 {
2653     int buttons = 0;
2654     if (flags & JOY_BUTTON1)
2655         buttons |= wxJOY_BUTTON1;
2656     if (flags & JOY_BUTTON2)
2657         buttons |= wxJOY_BUTTON2;
2658     if (flags & JOY_BUTTON3)
2659         buttons |= wxJOY_BUTTON3;
2660     if (flags & JOY_BUTTON4)
2661         buttons |= wxJOY_BUTTON4;
2662
2663     wxJoystickEvent event(wxEVT_JOY_MOVE, buttons, joystick, 0);
2664     event.SetPosition(wxPoint(x, y));
2665     event.SetEventObject(this);
2666
2667     GetEventHandler()->ProcessEvent(event);
2668 }
2669
2670 void wxWindow::MSWOnJoyZMove(const int joystick, const int z, const WXUINT flags)
2671 {
2672     int buttons = 0;
2673     if (flags & JOY_BUTTON1)
2674         buttons |= wxJOY_BUTTON1;
2675     if (flags & JOY_BUTTON2)
2676         buttons |= wxJOY_BUTTON2;
2677     if (flags & JOY_BUTTON3)
2678         buttons |= wxJOY_BUTTON3;
2679     if (flags & JOY_BUTTON4)
2680         buttons |= wxJOY_BUTTON4;
2681
2682     wxJoystickEvent event(wxEVT_JOY_ZMOVE, buttons, joystick, 0);
2683     event.SetZPosition(z);
2684     event.SetEventObject(this);
2685
2686     GetEventHandler()->ProcessEvent(event);
2687 }
2688
2689 void wxWindow::MSWOnVScroll(const WXWORD wParam, const WXWORD pos, const WXHWND control)
2690 {
2691   if (control)
2692   {
2693     wxWindow *child = wxFindWinFromHandle(control);
2694         if ( child )
2695         child->MSWOnVScroll(wParam, pos, control);
2696     return;
2697   }
2698
2699     wxScrollEvent event;
2700     event.SetPosition(pos);
2701     event.SetOrientation(wxVERTICAL);
2702     event.m_eventObject = this;
2703
2704         switch ( wParam )
2705         {
2706                 case SB_TOP:
2707                         event.m_eventType = wxEVENT_TYPE_SCROLL_TOP;
2708                         break;
2709
2710                 case SB_BOTTOM:
2711                         event.m_eventType = wxEVENT_TYPE_SCROLL_BOTTOM;
2712                         break;
2713
2714                 case SB_LINEUP:
2715                         event.m_eventType = wxEVENT_TYPE_SCROLL_LINEUP;
2716                         break;
2717
2718                 case SB_LINEDOWN:
2719                         event.m_eventType = wxEVENT_TYPE_SCROLL_LINEDOWN;
2720                         break;
2721
2722                 case SB_PAGEUP:
2723                         event.m_eventType = wxEVENT_TYPE_SCROLL_PAGEUP;
2724                         break;
2725
2726                 case SB_PAGEDOWN:
2727                         event.m_eventType = wxEVENT_TYPE_SCROLL_PAGEDOWN;
2728                         break;
2729
2730         case SB_THUMBTRACK:
2731         case SB_THUMBPOSITION:
2732                         event.m_eventType = wxEVENT_TYPE_SCROLL_THUMBTRACK;
2733                         break;
2734
2735                 default:
2736                         return;
2737                         break;
2738         }
2739
2740   if (!GetEventHandler()->ProcessEvent(event))
2741 #if WXWIN_COMPATIBILITY
2742     GetEventHandler()->OldOnScroll(event);
2743 #else
2744     Default();
2745 #endif
2746 }
2747
2748 void wxWindow::MSWOnHScroll( const WXWORD wParam, const WXWORD pos, const WXHWND control)
2749 {
2750   if (control)
2751   {
2752     wxWindow *child = wxFindWinFromHandle(control);
2753         if ( child )
2754         child->MSWOnHScroll(wParam, pos, control);
2755     return;
2756   }
2757
2758     wxScrollEvent event;
2759     event.SetPosition(pos);
2760     event.SetOrientation(wxHORIZONTAL);
2761     event.m_eventObject = this;
2762
2763         switch ( wParam )
2764         {
2765                 case SB_TOP:
2766                         event.m_eventType = wxEVENT_TYPE_SCROLL_TOP;
2767                         break;
2768
2769                 case SB_BOTTOM:
2770                         event.m_eventType = wxEVENT_TYPE_SCROLL_BOTTOM;
2771                         break;
2772
2773                 case SB_LINEUP:
2774                         event.m_eventType = wxEVENT_TYPE_SCROLL_LINEUP;
2775                         break;
2776
2777                 case SB_LINEDOWN:
2778                         event.m_eventType = wxEVENT_TYPE_SCROLL_LINEDOWN;
2779                         break;
2780
2781                 case SB_PAGEUP:
2782                         event.m_eventType = wxEVENT_TYPE_SCROLL_PAGEUP;
2783                         break;
2784
2785                 case SB_PAGEDOWN:
2786                         event.m_eventType = wxEVENT_TYPE_SCROLL_PAGEDOWN;
2787                         break;
2788
2789         case SB_THUMBTRACK:
2790         case SB_THUMBPOSITION:
2791                         event.m_eventType = wxEVENT_TYPE_SCROLL_THUMBTRACK;
2792                         break;
2793
2794                 default:
2795                         return;
2796                         break;
2797         }
2798   if (!GetEventHandler()->ProcessEvent(event))
2799 #if WXWIN_COMPATIBILITY
2800     GetEventHandler()->OldOnScroll(event);
2801 #else
2802     Default();
2803 #endif
2804 }
2805
2806 void wxWindow::MSWOnShow(bool show, int status)
2807 {
2808         wxShowEvent event(GetId(), show);
2809         event.m_eventObject = this;
2810         GetEventHandler()->ProcessEvent(event);
2811 }
2812
2813 bool wxWindow::MSWOnInitDialog(WXHWND WXUNUSED(hWndFocus))
2814 {
2815         wxInitDialogEvent event(GetId());
2816         event.m_eventObject = this;
2817         GetEventHandler()->ProcessEvent(event);
2818         return TRUE;
2819 }
2820
2821 void wxWindow::InitDialog(void)
2822 {
2823  wxInitDialogEvent event(GetId());
2824  event.SetEventObject( this );
2825  GetEventHandler()->ProcessEvent(event);
2826 }
2827
2828 // Default init dialog behaviour is to transfer data to window
2829 void wxWindow::OnInitDialog(wxInitDialogEvent& event)
2830 {
2831         TransferDataToWindow();
2832 }
2833
2834 void wxGetCharSize(WXHWND wnd, int *x, int *y,wxFont *the_font)
2835 {
2836   TEXTMETRIC tm;
2837   HDC dc = ::GetDC((HWND) wnd);
2838   HFONT fnt =0;
2839   HFONT was = 0;
2840   if (the_font)
2841   {
2842 #if DEBUG > 1
2843     wxDebugMsg("wxGetCharSize: Selecting HFONT %X\n", fnt);
2844 #endif
2845 //    the_font->UseResource();
2846 //    the_font->RealizeResource();
2847     if ((fnt=(HFONT) the_font->GetResourceHandle()))
2848       was = SelectObject(dc,fnt) ;
2849   }
2850   GetTextMetrics(dc, &tm);
2851   if (the_font && fnt && was)
2852   {
2853 #if DEBUG > 1
2854     wxDebugMsg("wxGetCharSize: Selecting old HFONT %X\n", was);
2855 #endif
2856     SelectObject(dc,was) ;
2857   }
2858   ReleaseDC((HWND)wnd, dc);
2859   *x = tm.tmAveCharWidth;
2860   *y = tm.tmHeight + tm.tmExternalLeading;
2861
2862 //  if (the_font)
2863 //    the_font->ReleaseResource();
2864 }
2865
2866 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
2867 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
2868 int wxCharCodeMSWToWX(int keySym)
2869 {
2870   int id = 0;
2871   switch (keySym)
2872   {
2873     case VK_CANCEL:             id = WXK_CANCEL; break;
2874     case VK_BACK:               id = WXK_BACK; break;
2875     case VK_TAB:                id = WXK_TAB; break;
2876     case VK_CLEAR:              id = WXK_CLEAR; break;
2877     case VK_RETURN:             id = WXK_RETURN; break;
2878     case VK_SHIFT:              id = WXK_SHIFT; break;
2879     case VK_CONTROL:            id = WXK_CONTROL; break;
2880     case VK_MENU :              id = WXK_MENU; break;
2881     case VK_PAUSE:              id = WXK_PAUSE; break;
2882     case VK_SPACE:              id = WXK_SPACE; break;
2883     case VK_ESCAPE:             id = WXK_ESCAPE; break;
2884     case VK_PRIOR:              id = WXK_PRIOR; break;
2885     case VK_NEXT :              id = WXK_NEXT; break;
2886     case VK_END:                id = WXK_END; break;
2887     case VK_HOME :              id = WXK_HOME; break;
2888     case VK_LEFT :              id = WXK_LEFT; break;
2889     case VK_UP:                 id = WXK_UP; break;
2890     case VK_RIGHT:              id = WXK_RIGHT; break;
2891     case VK_DOWN :              id = WXK_DOWN; break;
2892     case VK_SELECT:             id = WXK_SELECT; break;
2893     case VK_PRINT:              id = WXK_PRINT; break;
2894     case VK_EXECUTE:            id = WXK_EXECUTE; break;
2895     case VK_INSERT:             id = WXK_INSERT; break;
2896     case VK_DELETE:             id = WXK_DELETE; break;
2897     case VK_HELP :              id = WXK_HELP; break;
2898     case VK_NUMPAD0:            id = WXK_NUMPAD0; break;
2899     case VK_NUMPAD1:            id = WXK_NUMPAD1; break;
2900     case VK_NUMPAD2:            id = WXK_NUMPAD2; break;
2901     case VK_NUMPAD3:            id = WXK_NUMPAD3; break;
2902     case VK_NUMPAD4:            id = WXK_NUMPAD4; break;
2903     case VK_NUMPAD5:            id = WXK_NUMPAD5; break;
2904     case VK_NUMPAD6:            id = WXK_NUMPAD6; break;
2905     case VK_NUMPAD7:            id = WXK_NUMPAD7; break;
2906     case VK_NUMPAD8:            id = WXK_NUMPAD8; break;
2907     case VK_NUMPAD9:            id = WXK_NUMPAD9; break;
2908     case VK_MULTIPLY:           id = WXK_MULTIPLY; break;
2909     case VK_ADD:                id = WXK_ADD; break;
2910     case VK_SUBTRACT:           id = WXK_SUBTRACT; break;
2911     case VK_DECIMAL:            id = WXK_DECIMAL; break;
2912     case VK_DIVIDE:             id = WXK_DIVIDE; break;
2913     case VK_F1:         id = WXK_F1; break;
2914     case VK_F2:         id = WXK_F2; break;
2915     case VK_F3:         id = WXK_F3; break;
2916     case VK_F4:         id = WXK_F4; break;
2917     case VK_F5:         id = WXK_F5; break;
2918     case VK_F6:         id = WXK_F6; break;
2919     case VK_F7:         id = WXK_F7; break;
2920     case VK_F8:         id = WXK_F8; break;
2921     case VK_F9:         id = WXK_F9; break;
2922     case VK_F10:                id = WXK_F10; break;
2923     case VK_F11:                id = WXK_F11; break;
2924     case VK_F12:                id = WXK_F12; break;
2925     case VK_F13:                id = WXK_F13; break;
2926     case VK_F14:                id = WXK_F14; break;
2927     case VK_F15:                id = WXK_F15; break;
2928     case VK_F16:                id = WXK_F16; break;
2929     case VK_F17:                id = WXK_F17; break;
2930     case VK_F18:                id = WXK_F18; break;
2931     case VK_F19:                id = WXK_F19; break;
2932     case VK_F20:                id = WXK_F20; break;
2933     case VK_F21:                id = WXK_F21; break;
2934     case VK_F22:                id = WXK_F22; break;
2935     case VK_F23:                id = WXK_F23; break;
2936     case VK_F24:                id = WXK_F24; break;
2937     case VK_NUMLOCK:            id = WXK_NUMLOCK; break;
2938     case VK_SCROLL:             id = WXK_SCROLL; break;
2939     default:
2940     {
2941       return 0;
2942     }
2943   }
2944   return id;
2945 }
2946
2947 int wxCharCodeWXToMSW(int id, bool *isVirtual)
2948 {
2949   *isVirtual = TRUE;
2950   int keySym = 0;
2951   switch (id)
2952   {
2953     case WXK_CANCEL:            keySym = VK_CANCEL; break;
2954     case WXK_CLEAR:             keySym = VK_CLEAR; break;
2955     case WXK_SHIFT:             keySym = VK_SHIFT; break;
2956     case WXK_CONTROL:           keySym = VK_CONTROL; break;
2957     case WXK_MENU :             keySym = VK_MENU; break;
2958     case WXK_PAUSE:             keySym = VK_PAUSE; break;
2959     case WXK_PRIOR:             keySym = VK_PRIOR; break;
2960     case WXK_NEXT :             keySym = VK_NEXT; break;
2961     case WXK_END:               keySym = VK_END; break;
2962     case WXK_HOME :             keySym = VK_HOME; break;
2963     case WXK_LEFT :             keySym = VK_LEFT; break;
2964     case WXK_UP:                keySym = VK_UP; break;
2965     case WXK_RIGHT:             keySym = VK_RIGHT; break;
2966     case WXK_DOWN :             keySym = VK_DOWN; break;
2967     case WXK_SELECT:            keySym = VK_SELECT; break;
2968     case WXK_PRINT:             keySym = VK_PRINT; break;
2969     case WXK_EXECUTE:           keySym = VK_EXECUTE; break;
2970     case WXK_INSERT:            keySym = VK_INSERT; break;
2971     case WXK_DELETE:            keySym = VK_DELETE; break;
2972     case WXK_HELP :             keySym = VK_HELP; break;
2973     case WXK_NUMPAD0:           keySym = VK_NUMPAD0; break;
2974     case WXK_NUMPAD1:           keySym = VK_NUMPAD1; break;
2975     case WXK_NUMPAD2:           keySym = VK_NUMPAD2; break;
2976     case WXK_NUMPAD3:           keySym = VK_NUMPAD3; break;
2977     case WXK_NUMPAD4:           keySym = VK_NUMPAD4; break;
2978     case WXK_NUMPAD5:           keySym = VK_NUMPAD5; break;
2979     case WXK_NUMPAD6:           keySym = VK_NUMPAD6; break;
2980     case WXK_NUMPAD7:           keySym = VK_NUMPAD7; break;
2981     case WXK_NUMPAD8:           keySym = VK_NUMPAD8; break;
2982     case WXK_NUMPAD9:           keySym = VK_NUMPAD9; break;
2983     case WXK_MULTIPLY:          keySym = VK_MULTIPLY; break;
2984     case WXK_ADD:               keySym = VK_ADD; break;
2985     case WXK_SUBTRACT:          keySym = VK_SUBTRACT; break;
2986     case WXK_DECIMAL:           keySym = VK_DECIMAL; break;
2987     case WXK_DIVIDE:            keySym = VK_DIVIDE; break;
2988     case WXK_F1:                keySym = VK_F1; break;
2989     case WXK_F2:                keySym = VK_F2; break;
2990     case WXK_F3:                keySym = VK_F3; break;
2991     case WXK_F4:                keySym = VK_F4; break;
2992     case WXK_F5:                keySym = VK_F5; break;
2993     case WXK_F6:                keySym = VK_F6; break;
2994     case WXK_F7:                keySym = VK_F7; break;
2995     case WXK_F8:                keySym = VK_F8; break;
2996     case WXK_F9:                keySym = VK_F9; break;
2997     case WXK_F10:               keySym = VK_F10; break;
2998     case WXK_F11:               keySym = VK_F11; break;
2999     case WXK_F12:               keySym = VK_F12; break;
3000     case WXK_F13:               keySym = VK_F13; break;
3001     case WXK_F14:               keySym = VK_F14; break;
3002     case WXK_F15:               keySym = VK_F15; break;
3003     case WXK_F16:               keySym = VK_F16; break;
3004     case WXK_F17:               keySym = VK_F17; break;
3005     case WXK_F18:               keySym = VK_F18; break;
3006     case WXK_F19:               keySym = VK_F19; break;
3007     case WXK_F20:               keySym = VK_F20; break;
3008     case WXK_F21:               keySym = VK_F21; break;
3009     case WXK_F22:               keySym = VK_F22; break;
3010     case WXK_F23:               keySym = VK_F23; break;
3011     case WXK_F24:               keySym = VK_F24; break;
3012     case WXK_NUMLOCK:           keySym = VK_NUMLOCK; break;
3013     case WXK_SCROLL:            keySym = VK_SCROLL; break;
3014     default:
3015     {
3016       *isVirtual = FALSE;
3017       keySym = id;
3018       break;
3019     }
3020   }
3021   return keySym;
3022 }
3023
3024 // Caret manipulation
3025 void wxWindow::CreateCaret(const int w, const int h)
3026 {
3027   m_caretWidth = w;
3028   m_caretHeight = h;
3029   m_caretEnabled = TRUE;
3030 }
3031
3032 void wxWindow::CreateCaret(const wxBitmap *WXUNUSED(bitmap))
3033 {
3034   // Not implemented
3035 }
3036
3037 void wxWindow::ShowCaret(const bool show)
3038 {
3039   if (m_caretEnabled)
3040   {
3041     if (show)
3042       ::ShowCaret((HWND) GetHWND());
3043     else
3044       ::HideCaret((HWND) GetHWND());
3045     m_caretShown = show;
3046   }
3047 }
3048
3049 void wxWindow::DestroyCaret(void)
3050 {
3051   m_caretEnabled = FALSE;
3052 }
3053
3054 void wxWindow::SetCaretPos(const int x, const int y)
3055 {
3056   ::SetCaretPos(x, y);
3057 }
3058
3059 void wxWindow::GetCaretPos(int *x, int *y) const
3060 {
3061   POINT point;
3062   ::GetCaretPos(&point);
3063   *x = point.x;
3064   *y = point.y;
3065 }
3066
3067 /*
3068  * Update iterator. Use from within OnPaint.
3069  */
3070
3071 static RECT gs_UpdateRect;
3072
3073 wxUpdateIterator::wxUpdateIterator(wxWindow* wnd)
3074 {
3075   current = 0;                                  //start somewhere...
3076 #if defined(__WIN32__) && !defined(__win32s__)
3077   rlist = NULL;                                 //make sure I don't free randomly
3078   int len = GetRegionData((HRGN) wnd->m_updateRgn,0,NULL);      //Get buffer size
3079   if (len)
3080   {
3081     rlist = (WXRGNDATA *) (RGNDATA *)new char[len];
3082     GetRegionData((HRGN) wnd->m_updateRgn,len, (RGNDATA *)rlist);
3083     rp = (void *)(RECT*) ((RGNDATA *)rlist)->Buffer;
3084     rects = ((RGNDATA *)rlist)->rdh.nCount;
3085   }
3086   else
3087 #endif
3088   {
3089         gs_UpdateRect.left = wnd->m_updateRect.x;
3090         gs_UpdateRect.top = wnd->m_updateRect.y;
3091         gs_UpdateRect.right = wnd->m_updateRect.x + wnd->m_updateRect.width;
3092         gs_UpdateRect.bottom = wnd->m_updateRect.y + wnd->m_updateRect.height;
3093     rects = 1;
3094     rp = (void *)&gs_UpdateRect;                        //Only one available in Win16,32s
3095   }
3096 }
3097
3098 wxUpdateIterator::~wxUpdateIterator(void)
3099 {
3100 #ifdef __WIN32__
3101 #ifndef __win32s__
3102   if (rlist) delete (RGNDATA *) rlist;
3103 #endif
3104 #endif
3105 }
3106
3107 wxUpdateIterator::operator int (void)
3108 {
3109   if (current < rects)
3110   {
3111     return TRUE;
3112   }
3113   else
3114   {
3115     return FALSE;
3116   }
3117 }
3118
3119 wxUpdateIterator* wxUpdateIterator::operator ++(int)
3120 {
3121   current++;
3122   return this;
3123 }
3124
3125 void wxUpdateIterator::GetRect(wxRect *rect)
3126 {
3127   RECT *mswRect = ((RECT *)rp)+current; //ought to error check this...
3128   rect->x = mswRect->left;
3129   rect->y = mswRect->top;
3130   rect->width = mswRect->right - mswRect->left;
3131   rect->height = mswRect->bottom - mswRect->top;
3132 }
3133
3134 int wxUpdateIterator::GetX()
3135 {
3136   return ((RECT*)rp)[current].left;
3137 }
3138
3139 int wxUpdateIterator::GetY()
3140 {
3141   return ((RECT *)rp)[current].top;
3142 }
3143
3144 int wxUpdateIterator::GetW()
3145 {
3146  return ((RECT *)rp)[current].right-GetX();
3147 }
3148
3149 int wxUpdateIterator::GetH()
3150 {
3151   return ((RECT *)rp)[current].bottom-GetY();
3152 }
3153
3154 wxWindow *wxGetActiveWindow(void)
3155 {
3156   HWND hWnd = GetActiveWindow();
3157   if (hWnd != 0)
3158   {
3159     return wxFindWinFromHandle((WXHWND) hWnd);
3160   }
3161   return NULL;
3162 }
3163
3164 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
3165 // in active frames and dialogs, regardless of where the focus is.
3166 static HHOOK wxTheKeyboardHook = 0;
3167 static FARPROC wxTheKeyboardHookProc = 0;
3168 int APIENTRY _EXPORT
3169   wxKeyboardHook(int nCode, WORD wParam, DWORD lParam);
3170
3171 void wxSetKeyboardHook(bool doIt)
3172 {
3173   if (doIt)
3174   {
3175     wxTheKeyboardHookProc = MakeProcInstance((FARPROC) wxKeyboardHook, wxGetInstance());
3176     wxTheKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, (HOOKPROC) wxTheKeyboardHookProc, wxGetInstance(),
3177 #ifdef __WIN32__
3178       GetCurrentThreadId());
3179 //      (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
3180 #else
3181       GetCurrentTask());
3182 #endif
3183   }
3184   else
3185   {
3186     UnhookWindowsHookEx(wxTheKeyboardHook);
3187     FreeProcInstance(wxTheKeyboardHookProc);
3188   }
3189 }
3190
3191 int APIENTRY _EXPORT
3192   wxKeyboardHook(int nCode, WORD wParam, DWORD lParam)
3193 {
3194   DWORD hiWord = HIWORD(lParam);
3195   if (nCode != HC_NOREMOVE && ((hiWord & KF_UP) == 0))
3196   {
3197     int id;
3198     if ((id = wxCharCodeMSWToWX(wParam)) != 0)
3199     {
3200       wxKeyEvent event(wxEVT_CHAR_HOOK);
3201       if ((HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN)
3202         event.m_altDown = TRUE;
3203
3204       event.m_eventObject = NULL;
3205       event.m_keyCode = id;
3206 /* begin Albert's fix for control and shift key 26.5 */
3207       event.m_shiftDown = (::GetKeyState(VK_SHIFT)&0x100?TRUE:FALSE);
3208       event.m_controlDown = (::GetKeyState(VK_CONTROL)&0x100?TRUE:FALSE);
3209 /* end Albert's fix for control and shift key 26.5 */
3210       event.SetTimestamp(wxApp::sm_lastMessageTime); /* MATTHEW: timeStamp */
3211
3212 #if WXWIN_COMPATIBILITY
3213                 if ( wxTheApp && wxTheApp->OldOnCharHook(event) )
3214                         return 1;
3215 #endif
3216                 wxWindow *win = wxGetActiveWindow();
3217                 if (win)
3218                 {
3219             if (win->GetEventHandler()->ProcessEvent(event))
3220                                 return 1;
3221                 }
3222                 else
3223                 {
3224                         if ( wxTheApp && wxTheApp->ProcessEvent(event) )
3225                                 return 1;
3226                 }
3227     }
3228   }
3229   return (int)CallNextHookEx(wxTheKeyboardHook, nCode, wParam, lParam);
3230 }
3231
3232 void wxWindow::SetSizeHints(const int minW, const int minH, const int maxW, const int maxH, const int WXUNUSED(incW), const int WXUNUSED(incH))
3233 {
3234   m_minSizeX = minW;
3235   m_minSizeY = minH;
3236   m_maxSizeX = maxW;
3237   m_maxSizeY = maxH;
3238 }
3239
3240 void wxWindow::Centre(const int direction)
3241 {
3242   int x, y, width, height, panel_width, panel_height, new_x, new_y;
3243
3244   wxWindow *father = (wxWindow *)GetParent();
3245   if (!father)
3246     return;
3247
3248   father->GetClientSize(&panel_width, &panel_height);
3249   GetSize(&width, &height);
3250   GetPosition(&x, &y);
3251
3252   new_x = -1;
3253   new_y = -1;
3254
3255   if (direction & wxHORIZONTAL)
3256     new_x = (int)((panel_width - width)/2);
3257
3258   if (direction & wxVERTICAL)
3259     new_y = (int)((panel_height - height)/2);
3260
3261   SetSize(new_x, new_y, -1, -1);
3262
3263 }
3264
3265 /* TODO (maybe)
3266 void wxWindow::OnPaint(void)
3267 {
3268   PaintSelectionHandles();
3269 }
3270 */
3271
3272 void wxWindow::WarpPointer (const int x_pos, const int y_pos)
3273 {
3274   // Move the pointer to (x_pos,y_pos) coordinates. They are expressed in
3275   // pixel coordinates, relatives to the canvas -- So, we first need to
3276   // substract origin of the window, then convert to screen position
3277
3278   int x = x_pos; int y = y_pos;
3279 /* Leave this to the app to decide (and/or wxScrolledWindow)
3280       x -= m_xScrollPosition * m_xScrollPixelsPerLine;
3281       y -= m_yScrollPosition * m_yScrollPixelsPerLine;
3282 */
3283       RECT rect;
3284       GetWindowRect ((HWND) GetHWND(), &rect);
3285
3286       x += rect.left;
3287       y += rect.top;
3288
3289       SetCursorPos (x, y);
3290 }
3291
3292 void wxWindow::MSWDeviceToLogical (float *x, float *y) const
3293 {
3294     // TODO
3295     // Do we have a SetUserScale in wxWindow too, so we can
3296     // get mouse events scaled?
3297 /*
3298       if (m_windowDC)
3299       {
3300         *x = m_windowDC->DeviceToLogicalX ((int) *x);
3301         *y = m_windowDC->DeviceToLogicalY ((int) *y);
3302       }
3303 */
3304 }
3305
3306 bool wxWindow::MSWOnEraseBkgnd (const WXHDC pDC)
3307 {
3308     wxDC dc ;
3309
3310         dc.SetHDC(pDC);
3311         dc.SetWindow(this);
3312         dc.BeginDrawing();
3313
3314     wxEraseEvent event(m_windowId, &dc);
3315     event.m_eventObject = this;
3316     if (!GetEventHandler()->ProcessEvent(event))
3317     {
3318             dc.EndDrawing();
3319             dc.SelectOldObjects(pDC);
3320         return FALSE;
3321     }
3322     else
3323     {
3324             dc.EndDrawing();
3325             dc.SelectOldObjects(pDC);
3326     }
3327
3328     dc.SetHDC((WXHDC) NULL);
3329     return TRUE;
3330 }
3331
3332 void wxWindow::OnEraseBackground(wxEraseEvent& event)
3333 {
3334   RECT rect;
3335   ::GetClientRect((HWND) GetHWND(), &rect);
3336
3337   HBRUSH hBrush = ::CreateSolidBrush(PALETTERGB(GetBackgroundColour().Red(), GetBackgroundColour().Green(), GetBackgroundColour().Blue()));
3338   int mode = ::SetMapMode((HDC) event.GetDC()->GetHDC(), MM_TEXT);
3339
3340 //  ::GetClipBox((HDC) event.GetDC()->GetHDC(), &rect);
3341   ::FillRect ((HDC) event.GetDC()->GetHDC(), &rect, hBrush);
3342   ::DeleteObject(hBrush);
3343   ::SetMapMode((HDC) event.GetDC()->GetHDC(), mode);
3344 /*
3345   // Less efficient version (and doesn't account for scrolling)
3346   int w, h;
3347   GetClientSize(& w, & h);
3348   wxBrush *brush = wxTheBrushList->FindOrCreateBrush(& GetBackgroundColour(), wxSOLID);
3349   event.GetDC()->SetBrush(brush);
3350   event.GetDC()->SetPen(wxTRANSPARENT_PEN);
3351
3352   event.GetDC()->DrawRectangle(0, 0, w+1, h+1);
3353 */
3354 }
3355
3356 #if WXWIN_COMPATIBILITY
3357 void wxWindow::SetScrollRange(const int orient, const int range, const bool refresh)
3358 {
3359 #if defined(__WIN95__)
3360
3361   int range1 = range;
3362
3363   // Try to adjust the range to cope with page size > 1
3364   // - a Windows API quirk
3365   int pageSize = GetScrollPage(orient);
3366   if ( pageSize > 1 && range > 0)
3367   {
3368         range1 += (pageSize - 1);
3369   }
3370
3371   SCROLLINFO info;
3372   int dir;
3373
3374   if (orient == wxHORIZONTAL) {
3375         dir = SB_HORZ;
3376   } else {
3377         dir = SB_VERT;
3378   }
3379
3380   info.cbSize = sizeof(SCROLLINFO);
3381   info.nPage = pageSize; // Have to set this, or scrollbar goes awry
3382   info.nMin = 0;
3383   info.nMax = range1;
3384   info.nPos = 0;
3385   info.fMask = SIF_RANGE | SIF_PAGE;
3386
3387   HWND hWnd = (HWND) GetHWND();
3388   if (hWnd)
3389     ::SetScrollInfo(hWnd, dir, &info, refresh);
3390 #else
3391   int wOrient ;
3392   if (orient == wxHORIZONTAL)
3393     wOrient = SB_HORZ;
3394   else
3395     wOrient = SB_VERT;
3396
3397   HWND hWnd = (HWND) GetHWND();
3398   if (hWnd)
3399     ::SetScrollRange(hWnd, wOrient, 0, range, refresh);
3400 #endif
3401 }
3402
3403 void wxWindow::SetScrollPage(const int orient, const int page, const bool refresh)
3404 {
3405 #if defined(__WIN95__)
3406   SCROLLINFO info;
3407   int dir;
3408
3409   if (orient == wxHORIZONTAL) {
3410         dir = SB_HORZ;
3411     m_xThumbSize = page;
3412   } else {
3413         dir = SB_VERT;
3414     m_yThumbSize = page;
3415   }
3416
3417   info.cbSize = sizeof(SCROLLINFO);
3418   info.nPage = page;
3419   info.nMin = 0;
3420   info.fMask = SIF_PAGE ;
3421
3422   HWND hWnd = (HWND) GetHWND();
3423   if (hWnd)
3424     ::SetScrollInfo(hWnd, dir, &info, refresh);
3425 #else
3426   if (orient == wxHORIZONTAL)
3427     m_xThumbSize = page;
3428   else
3429     m_yThumbSize = page;
3430 #endif
3431 }
3432
3433 int wxWindow::OldGetScrollRange(const int orient) const
3434 {
3435   int wOrient ;
3436   if (orient == wxHORIZONTAL)
3437     wOrient = SB_HORZ;
3438   else
3439     wOrient = SB_VERT;
3440
3441 #if __WATCOMC__ && defined(__WINDOWS_386__)
3442   short minPos, maxPos;
3443 #else
3444   int minPos, maxPos;
3445 #endif
3446   HWND hWnd = (HWND) GetHWND();
3447   if (hWnd)
3448   {
3449     ::GetScrollRange(hWnd, wOrient, &minPos, &maxPos);
3450 #if defined(__WIN95__)
3451     // Try to adjust the range to cope with page size > 1
3452     // - a Windows API quirk
3453     int pageSize = GetScrollPage(orient);
3454     if ( pageSize > 1 )
3455     {
3456           maxPos -= (pageSize - 1);
3457     }
3458 #endif
3459     return maxPos;
3460   }
3461   else
3462     return 0;
3463 }
3464
3465 int wxWindow::GetScrollPage(const int orient) const
3466 {
3467   if (orient == wxHORIZONTAL)
3468     return m_xThumbSize;
3469   else
3470     return m_yThumbSize;
3471 }
3472 #endif
3473
3474 int wxWindow::GetScrollPos(const int orient) const
3475 {
3476   int wOrient ;
3477   if (orient == wxHORIZONTAL)
3478     wOrient = SB_HORZ;
3479   else
3480     wOrient = SB_VERT;
3481   HWND hWnd = (HWND) GetHWND();
3482   if (hWnd)
3483   {
3484     return ::GetScrollPos(hWnd, wOrient);
3485   }
3486   else
3487     return 0;
3488 }
3489
3490 // This now returns the whole range, not just the number
3491 // of positions that we can scroll.
3492 int wxWindow::GetScrollRange(const int orient) const
3493 {
3494   int wOrient ;
3495   if (orient == wxHORIZONTAL)
3496     wOrient = SB_HORZ;
3497   else
3498     wOrient = SB_VERT;
3499
3500 #if __WATCOMC__ && defined(__WINDOWS_386__)
3501   short minPos, maxPos;
3502 #else
3503   int minPos, maxPos;
3504 #endif
3505   HWND hWnd = (HWND) GetHWND();
3506   if (hWnd)
3507   {
3508     ::GetScrollRange(hWnd, wOrient, &minPos, &maxPos);
3509 #if defined(__WIN95__)
3510     // Try to adjust the range to cope with page size > 1
3511     // - a Windows API quirk
3512     int pageSize = GetScrollPage(orient);
3513     if ( pageSize > 1 )
3514     {
3515           maxPos -= (pageSize - 1);
3516     }
3517     // October 10th: new range concept.
3518     maxPos += pageSize;
3519 #endif
3520
3521     return maxPos;
3522   }
3523   else
3524     return 0;
3525 }
3526
3527 int wxWindow::GetScrollThumb(const int orient) const
3528 {
3529   if (orient == wxHORIZONTAL)
3530     return m_xThumbSize;
3531   else
3532     return m_yThumbSize;
3533 }
3534
3535 void wxWindow::SetScrollPos(const int orient, const int pos, const bool refresh)
3536 {
3537 #if defined(__WIN95__)
3538   SCROLLINFO info;
3539   int dir;
3540
3541   if (orient == wxHORIZONTAL) {
3542         dir = SB_HORZ;
3543   } else {
3544         dir = SB_VERT;
3545   }
3546
3547   info.cbSize = sizeof(SCROLLINFO);
3548   info.nPage = 0;
3549   info.nMin = 0;
3550   info.nPos = pos;
3551   info.fMask = SIF_POS ;
3552
3553   HWND hWnd = (HWND) GetHWND();
3554   if (hWnd)
3555     ::SetScrollInfo(hWnd, dir, &info, refresh);
3556 #else
3557   int wOrient ;
3558   if (orient == wxHORIZONTAL)
3559     wOrient = SB_HORZ;
3560   else
3561     wOrient = SB_VERT;
3562
3563   HWND hWnd = (HWND) GetHWND();
3564   if (hWnd)
3565     ::SetScrollPos(hWnd, wOrient, pos, refresh);
3566 #endif
3567 }
3568
3569 // New function that will replace some of the above.
3570 void wxWindow::SetScrollbar(const int orient, const int pos, const int thumbVisible,
3571     const int range, const bool refresh)
3572 {
3573 /*
3574     SetScrollPage(orient, thumbVisible, FALSE);
3575
3576     int oldRange = range - thumbVisible ;
3577     SetScrollRange(orient, oldRange, FALSE);
3578
3579     SetScrollPos(orient, pos, refresh);
3580 */
3581 #if defined(__WIN95__)
3582   int oldRange = range - thumbVisible ;
3583
3584   int range1 = oldRange;
3585
3586   // Try to adjust the range to cope with page size > 1
3587   // - a Windows API quirk
3588   int pageSize = thumbVisible;
3589   if ( pageSize > 1 && range > 0)
3590   {
3591         range1 += (pageSize - 1);
3592   }
3593
3594   SCROLLINFO info;
3595   int dir;
3596
3597   if (orient == wxHORIZONTAL) {
3598         dir = SB_HORZ;
3599   } else {
3600         dir = SB_VERT;
3601   }
3602
3603   info.cbSize = sizeof(SCROLLINFO);
3604   info.nPage = pageSize; // Have to set this, or scrollbar goes awry
3605   info.nMin = 0;
3606   info.nMax = range1;
3607   info.nPos = pos;
3608   info.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
3609
3610   HWND hWnd = (HWND) GetHWND();
3611   if (hWnd)
3612     ::SetScrollInfo(hWnd, dir, &info, refresh);
3613 #else
3614   int wOrient ;
3615   if (orient == wxHORIZONTAL)
3616     wOrient = SB_HORZ;
3617   else
3618     wOrient = SB_VERT;
3619
3620   HWND hWnd = (HWND) GetHWND();
3621   if (hWnd)
3622   {
3623     ::SetScrollRange(hWnd, wOrient, 0, range, FALSE);
3624     ::SetScrollPos(hWnd, wOrient, pos, refresh);
3625   }
3626 #endif
3627   if (orient == wxHORIZONTAL) {
3628     m_xThumbSize = thumbVisible;
3629   } else {
3630     m_yThumbSize = thumbVisible;
3631   }
3632 }
3633
3634 void wxWindow::ScrollWindow(const int dx, const int dy, const wxRectangle *rect)
3635 {
3636         RECT rect2;
3637         if ( rect )
3638         {
3639                 rect2.left = rect->x;
3640                 rect2.top = rect->y;
3641                 rect2.right = rect->x + rect->width;
3642                 rect2.bottom = rect->y + rect->height;
3643         }
3644
3645         if ( rect )
3646                 ::ScrollWindow((HWND) GetHWND(), dx, dy, &rect2, NULL);
3647         else
3648                 ::ScrollWindow((HWND) GetHWND(), dx, dy, NULL, NULL);
3649 }
3650
3651 void wxWindow::OnSize(wxSizeEvent& event)
3652 {
3653         Default();
3654 #if USE_CONSTRAINTS
3655   if (GetAutoLayout())
3656     Layout();
3657 #endif
3658 }
3659
3660 /*
3661 void wxWindow::CalcScrolledPosition(const int x, const int y, int *xx, int *yy) const
3662 {
3663   *xx = x;
3664   *yy = y;
3665 }
3666
3667 void wxWindow::CalcUnscrolledPosition(const int x, const int y, float *xx, float *yy) const
3668 {
3669   *xx = x;
3670   *yy = y;
3671 }
3672 */
3673
3674 void wxWindow::SetFont(const wxFont& font)
3675 {
3676   // Decrement the usage count of the old label font
3677   // (we may be able to free it up)
3678 //  if (GetFont()->Ok())
3679 //    GetFont()->ReleaseResource();
3680
3681   m_windowFont = font;
3682
3683   if (!m_windowFont.Ok())
3684         return;
3685
3686 //  m_windowFont.UseResource();
3687
3688   HWND hWnd = (HWND) GetHWND();
3689   if (hWnd != 0)
3690   {
3691 //      m_windowFont.RealizeResource();
3692
3693       if (m_windowFont.GetResourceHandle())
3694         SendMessage(hWnd, WM_SETFONT,
3695                   (WPARAM)m_windowFont.GetResourceHandle(),TRUE);
3696   }
3697 }
3698
3699 void wxWindow::SubclassWin(WXHWND hWnd)
3700 {
3701   wxAssociateWinWithHandle((HWND)hWnd, this);
3702
3703   m_oldWndProc = (WXFARPROC) GetWindowLong((HWND) hWnd, GWL_WNDPROC);
3704   SetWindowLong((HWND) hWnd, GWL_WNDPROC, (LONG) wxWndProc);
3705 }
3706
3707 void wxWindow::UnsubclassWin(void)
3708 {
3709         wxRemoveHandleAssociation(this);
3710
3711   // Restore old Window proc
3712   if ((HWND) GetHWND())
3713   {
3714     FARPROC farProc = (FARPROC) GetWindowLong((HWND) GetHWND(), GWL_WNDPROC);
3715     if ((m_oldWndProc != 0) && (farProc != (FARPROC) m_oldWndProc))
3716         {
3717       SetWindowLong((HWND) GetHWND(), GWL_WNDPROC, (LONG) m_oldWndProc);
3718           m_oldWndProc = 0;
3719         }
3720   }
3721 }
3722
3723 // Make a Windows extended style from the given wxWindows window style
3724 WXDWORD wxWindow::MakeExtendedStyle(long style, bool eliminateBorders)
3725 {
3726         WXDWORD exStyle = 0;
3727         if ( style & wxTRANSPARENT_WINDOW )
3728                 exStyle |= WS_EX_TRANSPARENT ;
3729
3730   if ( !eliminateBorders )
3731   {
3732         if ( style & wxSUNKEN_BORDER )
3733                 exStyle |= WS_EX_CLIENTEDGE ;
3734         if ( style & wxDOUBLE_BORDER )
3735                 exStyle |= WS_EX_DLGMODALFRAME ;
3736 #if defined(__WIN95__)
3737         if ( style & wxRAISED_BORDER )
3738                 exStyle |= WS_EX_WINDOWEDGE ;
3739         if ( style & wxSTATIC_BORDER )
3740                 exStyle |= WS_EX_STATICEDGE ;
3741 #endif
3742   }
3743   return exStyle;
3744 }
3745
3746 // Determines whether native 3D effects or CTL3D should be used,
3747 // applying a default border style if required, and returning an extended
3748 // style to pass to CreateWindowEx.
3749 WXDWORD wxWindow::Determine3DEffects(WXDWORD defaultBorderStyle, bool *want3D)
3750 {
3751   // If matches certain criteria, then assume no 3D effects
3752   // unless specifically requested (dealt with in MakeExtendedStyle)
3753   if ( !GetParent() || !IsKindOf(CLASSINFO(wxControl)) || (m_windowStyle & wxNO_BORDER) )
3754   {
3755         *want3D = FALSE;
3756         return MakeExtendedStyle(m_windowStyle, FALSE);
3757   }
3758
3759   // Determine whether we should be using 3D effects or not.
3760   bool nativeBorder = FALSE; // by default, we don't want a Win95 effect
3761
3762   // 1) App can specify global 3D effects
3763   *want3D = wxTheApp->GetAuto3D();
3764
3765   // 2) If the parent is being drawn with user colours, or simple border specified,
3766   // switch effects off. TODO: replace wxUSER_COLOURS with wxNO_3D
3767   if (GetParent() && (GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS) || (m_windowStyle & wxSIMPLE_BORDER))
3768         *want3D = FALSE;
3769
3770   // 3) Control can override this global setting by defining
3771   // a border style, e.g. wxSUNKEN_BORDER
3772   if (m_windowStyle & wxSUNKEN_BORDER )
3773         *want3D = TRUE;
3774
3775   // 4) If it's a special border, CTL3D can't cope so we want a native border
3776   if ( (m_windowStyle & wxDOUBLE_BORDER) || (m_windowStyle & wxRAISED_BORDER) ||
3777        (m_windowStyle & wxSTATIC_BORDER) )
3778   {
3779         *want3D = TRUE;
3780         nativeBorder = TRUE;
3781   }
3782
3783   // 5) If this isn't a Win95 app, and we are using CTL3D, remove border
3784   // effects from extended style
3785 #if CTL3D
3786   if ( *want3D )
3787         nativeBorder = FALSE;
3788 #endif
3789
3790   DWORD exStyle = MakeExtendedStyle(m_windowStyle, !nativeBorder);
3791
3792   // If we want 3D, but haven't specified a border here,
3793   // apply the default border style specified.
3794   // TODO what about non-Win95 WIN32? Does it have borders?
3795 #if defined(__WIN95__) && !CTL3D
3796   if (defaultBorderStyle && (*want3D) && ! ((m_windowStyle & wxDOUBLE_BORDER) || (m_windowStyle & wxRAISED_BORDER) ||
3797         (m_windowStyle & wxSTATIC_BORDER) || (m_windowStyle & wxSIMPLE_BORDER) ))
3798         exStyle |= defaultBorderStyle; // WS_EX_CLIENTEDGE ;
3799 #endif
3800
3801   return exStyle;
3802 }
3803
3804 #if WXWIN_COMPATIBILITY
3805 void wxWindow::OldOnPaint(void)
3806 {
3807   wxPaintEvent event(m_windowId);
3808   event.m_eventObject = this;
3809   if (!GetEventHandler()->ProcessEvent(event))
3810     Default();
3811 };
3812
3813 void wxWindow::OldOnSize(int w, int h)
3814 {
3815   wxSizeEvent event(wxSize(w, h), m_windowId);
3816   event.m_eventObject = this;
3817   if (!GetEventHandler()->ProcessEvent(event))
3818     Default();
3819 };
3820
3821 void wxWindow::OldOnMouseEvent(wxMouseEvent& event)
3822 {
3823   if (!GetEventHandler()->ProcessEvent(event))
3824     Default();
3825 };
3826
3827 void wxWindow::OldOnChar(wxKeyEvent& event)
3828 {
3829   if (!GetEventHandler()->ProcessEvent(event))
3830     Default();
3831 };
3832
3833 void wxWindow::OldOnSetFocus(void)
3834 {
3835   wxFocusEvent event(wxEVT_SET_FOCUS, m_windowId);
3836   event.m_eventObject = this;
3837   if (!GetEventHandler()->ProcessEvent(event))
3838     Default();
3839 };
3840
3841 void wxWindow::OldOnKillFocus(void)
3842 {
3843   wxFocusEvent event(wxEVT_KILL_FOCUS, m_windowId);
3844   event.m_eventObject = this;
3845   if (!GetEventHandler()->ProcessEvent(event))
3846     Default();
3847 };
3848 #endif
3849
3850 void wxWindow::OnChar(wxKeyEvent& event)
3851 {
3852         bool isVirtual;
3853         int id = wxCharCodeWXToMSW((int)event.KeyCode(), &isVirtual);
3854
3855         if ( id == -1 )
3856                 id= m_lastWParam;
3857
3858     if ( !event.ControlDown() )
3859             (void) MSWDefWindowProc(m_lastMsg, (WPARAM) id, m_lastLParam);
3860 }
3861
3862 void wxWindow::OnPaint(wxPaintEvent& event)
3863 {
3864         Default();
3865 }
3866
3867 bool wxWindow::IsEnabled(void) const
3868 {
3869         return (::IsWindowEnabled((HWND) GetHWND()) != 0);
3870 }
3871
3872 // Dialog support: override these and call
3873 // base class members to add functionality
3874 // that can't be done using validators.
3875 // NOTE: these functions assume that controls
3876 // are direct children of this window, not grandchildren
3877 // or other levels of descendant.
3878
3879 // Transfer values to controls. If returns FALSE,
3880 // it's an application error (pops up a dialog)
3881 bool wxWindow::TransferDataToWindow(void)
3882 {
3883         wxNode *node = GetChildren()->First();
3884         while ( node )
3885         {
3886                 wxWindow *child = (wxWindow *)node->Data();
3887                 if ( child->GetValidator() && /* child->GetValidator()->Ok() && */
3888                 !child->GetValidator()->TransferToWindow() )
3889                 {
3890                         wxMessageBox("Application Error", "Could not transfer data to window", wxOK|wxICON_EXCLAMATION);
3891                         return FALSE;
3892                 }
3893
3894                 node = node->Next();
3895         }
3896         return TRUE;
3897 }
3898
3899 // Transfer values from controls. If returns FALSE,
3900 // validation failed: don't quit
3901 bool wxWindow::TransferDataFromWindow(void)
3902 {
3903         wxNode *node = GetChildren()->First();
3904         while ( node )
3905         {
3906                 wxWindow *child = (wxWindow *)node->Data();
3907                 if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() )
3908                 {
3909                         return FALSE;
3910                 }
3911
3912                 node = node->Next();
3913         }
3914         return TRUE;
3915 }
3916
3917 bool wxWindow::Validate(void)
3918 {
3919         wxNode *node = GetChildren()->First();
3920         while ( node )
3921         {
3922                 wxWindow *child = (wxWindow *)node->Data();
3923                 if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this) )
3924                 {
3925                         return FALSE;
3926                 }
3927
3928                 node = node->Next();
3929         }
3930         return TRUE;
3931 }
3932
3933 // Get the window with the focus
3934 wxWindow *wxWindow::FindFocus(void)
3935 {
3936     HWND hWnd = ::GetFocus();
3937     if ( hWnd )
3938     {
3939         return wxFindWinFromHandle((WXHWND) hWnd);
3940     }
3941     return NULL;
3942 }
3943
3944 void wxWindow::AddChild(wxWindow *child)
3945 {
3946   GetChildren()->Append(child);
3947   child->m_windowParent = this;
3948 }
3949
3950 void wxWindow::RemoveChild(wxWindow *child)
3951 {
3952   if (GetChildren())
3953     GetChildren()->DeleteObject(child);
3954   child->m_windowParent = NULL;
3955 }
3956
3957 void wxWindow::DestroyChildren(void)
3958 {
3959   if (GetChildren()) {
3960     wxNode *node;
3961     while ((node = GetChildren()->First()) != (wxNode *)NULL) {
3962       wxWindow *child;
3963       if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) {
3964         delete child;
3965                 if ( GetChildren()->Member(child) )
3966                         delete node;
3967       }
3968     } /* while */
3969   }
3970 }
3971
3972 void wxWindow::MakeModal(const bool modal)
3973 {
3974   // Disable all other windows
3975   if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
3976   {
3977     wxNode *node = wxTopLevelWindows.First();
3978     while (node)
3979     {
3980       wxWindow *win = (wxWindow *)node->Data();
3981       if (win != this)
3982         win->Enable(!modal);
3983
3984       node = node->Next();
3985     }
3986   }
3987 }
3988
3989 // If nothing defined for this, try the parent.
3990 // E.g. we may be a button loaded from a resource, with no callback function
3991 // defined.
3992 void wxWindow::OnCommand(wxWindow& win, wxCommandEvent& event)
3993 {
3994   if (GetEventHandler()->ProcessEvent(event) )
3995         return;
3996   if (m_windowParent)
3997     m_windowParent->GetEventHandler()->OnCommand(win, event);
3998 }
3999
4000 void wxWindow::SetConstraints(wxLayoutConstraints *c)
4001 {
4002   if (m_constraints)
4003   {
4004     UnsetConstraints(m_constraints);
4005     delete m_constraints;
4006   }
4007   m_constraints = c;
4008   if (m_constraints)
4009   {
4010     // Make sure other windows know they're part of a 'meaningful relationship'
4011     if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this))
4012       m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
4013     if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this))
4014       m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
4015     if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this))
4016       m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
4017     if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this))
4018       m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
4019     if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this))
4020       m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
4021     if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this))
4022       m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
4023     if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this))
4024       m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
4025     if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this))
4026       m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
4027   }
4028 }
4029
4030 // This removes any dangling pointers to this window
4031 // in other windows' constraintsInvolvedIn lists.
4032 void wxWindow::UnsetConstraints(wxLayoutConstraints *c)
4033 {
4034   if (c)
4035   {
4036     if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this))
4037       c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
4038     if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this))
4039       c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
4040     if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this))
4041       c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
4042     if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this))
4043       c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
4044     if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this))
4045       c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
4046     if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this))
4047       c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
4048     if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this))
4049       c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
4050     if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this))
4051       c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
4052   }
4053 }
4054
4055 // Back-pointer to other windows we're involved with, so if we delete
4056 // this window, we must delete any constraints we're involved with.
4057 void wxWindow::AddConstraintReference(wxWindow *otherWin)
4058 {
4059   if (!m_constraintsInvolvedIn)
4060     m_constraintsInvolvedIn = new wxList;
4061   if (!m_constraintsInvolvedIn->Member(otherWin))
4062     m_constraintsInvolvedIn->Append(otherWin);
4063 }
4064
4065 // REMOVE back-pointer to other windows we're involved with.
4066 void wxWindow::RemoveConstraintReference(wxWindow *otherWin)
4067 {
4068   if (m_constraintsInvolvedIn)
4069     m_constraintsInvolvedIn->DeleteObject(otherWin);
4070 }
4071
4072 // Reset any constraints that mention this window
4073 void wxWindow::DeleteRelatedConstraints(void)
4074 {
4075   if (m_constraintsInvolvedIn)
4076   {
4077     wxNode *node = m_constraintsInvolvedIn->First();
4078     while (node)
4079     {
4080       wxWindow *win = (wxWindow *)node->Data();
4081       wxNode *next = node->Next();
4082       wxLayoutConstraints *constr = win->GetConstraints();
4083
4084       // Reset any constraints involving this window
4085       if (constr)
4086       {
4087         constr->left.ResetIfWin((wxWindow *)this);
4088         constr->top.ResetIfWin((wxWindow *)this);
4089         constr->right.ResetIfWin((wxWindow *)this);
4090         constr->bottom.ResetIfWin((wxWindow *)this);
4091         constr->width.ResetIfWin((wxWindow *)this);
4092         constr->height.ResetIfWin((wxWindow *)this);
4093         constr->centreX.ResetIfWin((wxWindow *)this);
4094         constr->centreY.ResetIfWin((wxWindow *)this);
4095       }
4096       delete node;
4097       node = next;
4098     }
4099     delete m_constraintsInvolvedIn;
4100     m_constraintsInvolvedIn = NULL;
4101   }
4102 }
4103
4104 void wxWindow::SetSizer(wxSizer *sizer)
4105 {
4106   m_windowSizer = sizer;
4107   if (sizer)
4108     sizer->SetSizerParent((wxWindow *)this);
4109 }
4110
4111 /*
4112  * New version
4113  */
4114
4115 bool wxWindow::Layout(void)
4116 {
4117   if (GetConstraints())
4118   {
4119     int w, h;
4120     GetClientSize(&w, &h);
4121     GetConstraints()->width.SetValue(w);
4122     GetConstraints()->height.SetValue(h);
4123   }
4124
4125   // If top level (one sizer), evaluate the sizer's constraints.
4126   if (GetSizer())
4127   {
4128     int noChanges;
4129     GetSizer()->ResetConstraints();   // Mark all constraints as unevaluated
4130     GetSizer()->LayoutPhase1(&noChanges);
4131     GetSizer()->LayoutPhase2(&noChanges);
4132     GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
4133     return TRUE;
4134   }
4135   else
4136   {
4137     // Otherwise, evaluate child constraints
4138     ResetConstraints();   // Mark all constraints as unevaluated
4139     DoPhase(1);           // Just one phase need if no sizers involved
4140     DoPhase(2);
4141     SetConstraintSizes(); // Recursively set the real window sizes
4142   }
4143   return TRUE;
4144 }
4145
4146
4147 // Do a phase of evaluating constraints:
4148 // the default behaviour. wxSizers may do a similar
4149 // thing, but also impose their own 'constraints'
4150 // and order the evaluation differently.
4151 bool wxWindow::LayoutPhase1(int *noChanges)
4152 {
4153   wxLayoutConstraints *constr = GetConstraints();
4154   if (constr)
4155   {
4156     return constr->SatisfyConstraints((wxWindow *)this, noChanges);
4157   }
4158   else
4159     return TRUE;
4160 }
4161
4162 bool wxWindow::LayoutPhase2(int *noChanges)
4163 {
4164   *noChanges = 0;
4165
4166   // Layout children
4167   DoPhase(1);
4168   DoPhase(2);
4169   return TRUE;
4170 }
4171
4172 // Do a phase of evaluating child constraints
4173 bool wxWindow::DoPhase(const int phase)
4174 {
4175   int noIterations = 0;
4176   int maxIterations = 500;
4177   int noChanges = 1;
4178   int noFailures = 0;
4179   wxList succeeded;
4180   while ((noChanges > 0) && (noIterations < maxIterations))
4181   {
4182     noChanges = 0;
4183     noFailures = 0;
4184     wxNode *node = GetChildren()->First();
4185     while (node)
4186     {
4187       wxWindow *child = (wxWindow *)node->Data();
4188       if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)))
4189       {
4190         wxLayoutConstraints *constr = child->GetConstraints();
4191         if (constr)
4192         {
4193           if (succeeded.Member(child))
4194           {
4195           }
4196           else
4197           {
4198             int tempNoChanges = 0;
4199             bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
4200             noChanges += tempNoChanges;
4201             if (success)
4202             {
4203               succeeded.Append(child);
4204             }
4205           }
4206         }
4207       }
4208       node = node->Next();
4209     }
4210     noIterations ++;
4211   }
4212   return TRUE;
4213 }
4214
4215 void wxWindow::ResetConstraints(void)
4216 {
4217   wxLayoutConstraints *constr = GetConstraints();
4218   if (constr)
4219   {
4220     constr->left.SetDone(FALSE);
4221     constr->top.SetDone(FALSE);
4222     constr->right.SetDone(FALSE);
4223     constr->bottom.SetDone(FALSE);
4224     constr->width.SetDone(FALSE);
4225     constr->height.SetDone(FALSE);
4226     constr->centreX.SetDone(FALSE);
4227     constr->centreY.SetDone(FALSE);
4228   }
4229   wxNode *node = GetChildren()->First();
4230   while (node)
4231   {
4232     wxWindow *win = (wxWindow *)node->Data();
4233     if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
4234       win->ResetConstraints();
4235     node = node->Next();
4236   }
4237 }
4238
4239 // Need to distinguish between setting the 'fake' size for
4240 // windows and sizers, and setting the real values.
4241 void wxWindow::SetConstraintSizes(const bool recurse)
4242 {
4243   wxLayoutConstraints *constr = GetConstraints();
4244   if (constr && constr->left.GetDone() && constr->right.GetDone() &&
4245                 constr->width.GetDone() && constr->height.GetDone())
4246   {
4247     int x = constr->left.GetValue();
4248     int y = constr->top.GetValue();
4249     int w = constr->width.GetValue();
4250     int h = constr->height.GetValue();
4251
4252     // If we don't want to resize this window, just move it...
4253     if ((constr->width.GetRelationship() != wxAsIs) ||
4254         (constr->height.GetRelationship() != wxAsIs))
4255     {
4256       // Calls Layout() recursively. AAAGH. How can we stop that.
4257       // Simply take Layout() out of non-top level OnSizes.
4258       SizerSetSize(x, y, w, h);
4259     }
4260     else
4261     {
4262       SizerMove(x, y);
4263     }
4264   }
4265   else if (constr)
4266   {
4267     char *windowClass = this->GetClassInfo()->GetClassName();
4268
4269     wxString winName;
4270         if (GetName() == "")
4271                 winName = "unnamed";
4272         else
4273                 winName = GetName();
4274     wxDebugMsg("Constraint(s) not satisfied for window of type %s, name %s:\n", (const char *)windowClass, (const char *)winName);
4275     if (!constr->left.GetDone())
4276       wxDebugMsg("  unsatisfied 'left' constraint.\n");
4277     if (!constr->right.GetDone())
4278       wxDebugMsg("  unsatisfied 'right' constraint.\n");
4279     if (!constr->width.GetDone())
4280       wxDebugMsg("  unsatisfied 'width' constraint.\n");
4281     if (!constr->height.GetDone())
4282       wxDebugMsg("  unsatisfied 'height' constraint.\n");
4283     wxDebugMsg("Please check constraints: try adding AsIs() constraints.\n");
4284   }
4285
4286   if (recurse)
4287   {
4288     wxNode *node = GetChildren()->First();
4289     while (node)
4290     {
4291       wxWindow *win = (wxWindow *)node->Data();
4292       if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
4293         win->SetConstraintSizes();
4294       node = node->Next();
4295     }
4296   }
4297 }
4298
4299 // This assumes that all sizers are 'on' the same
4300 // window, i.e. the parent of this window.
4301 void wxWindow::TransformSizerToActual(int *x, int *y) const
4302 {
4303   if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
4304                          m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
4305     return;
4306
4307   int xp, yp;
4308   m_sizerParent->GetPosition(&xp, &yp);
4309   m_sizerParent->TransformSizerToActual(&xp, &yp);
4310   *x += xp;
4311   *y += yp;
4312 }
4313
4314 void wxWindow::SizerSetSize(const int x, const int y, const int w, const int h)
4315 {
4316         int xx = x;
4317         int yy = y;
4318   TransformSizerToActual(&xx, &yy);
4319   SetSize(xx, yy, w, h);
4320 }
4321
4322 void wxWindow::SizerMove(const int x, const int y)
4323 {
4324         int xx = x;
4325         int yy = y;
4326   TransformSizerToActual(&xx, &yy);
4327   Move(xx, yy);
4328 }
4329
4330 // Only set the size/position of the constraint (if any)
4331 void wxWindow::SetSizeConstraint(const int x, const int y, const int w, const int h)
4332 {
4333   wxLayoutConstraints *constr = GetConstraints();
4334   if (constr)
4335   {
4336     if (x != -1)
4337     {
4338       constr->left.SetValue(x);
4339       constr->left.SetDone(TRUE);
4340     }
4341     if (y != -1)
4342     {
4343       constr->top.SetValue(y);
4344       constr->top.SetDone(TRUE);
4345     }
4346     if (w != -1)
4347     {
4348       constr->width.SetValue(w);
4349       constr->width.SetDone(TRUE);
4350     }
4351     if (h != -1)
4352     {
4353       constr->height.SetValue(h);
4354       constr->height.SetDone(TRUE);
4355     }
4356   }
4357 }
4358
4359 void wxWindow::MoveConstraint(const int x, const int y)
4360 {
4361   wxLayoutConstraints *constr = GetConstraints();
4362   if (constr)
4363   {
4364     if (x != -1)
4365     {
4366       constr->left.SetValue(x);
4367       constr->left.SetDone(TRUE);
4368     }
4369     if (y != -1)
4370     {
4371       constr->top.SetValue(y);
4372       constr->top.SetDone(TRUE);
4373     }
4374   }
4375 }
4376
4377 void wxWindow::GetSizeConstraint(int *w, int *h) const
4378 {
4379   wxLayoutConstraints *constr = GetConstraints();
4380   if (constr)
4381   {
4382     *w = constr->width.GetValue();
4383     *h = constr->height.GetValue();
4384   }
4385   else
4386     GetSize(w, h);
4387 }
4388
4389 void wxWindow::GetClientSizeConstraint(int *w, int *h) const
4390 {
4391   wxLayoutConstraints *constr = GetConstraints();
4392   if (constr)
4393   {
4394     *w = constr->width.GetValue();
4395     *h = constr->height.GetValue();
4396   }
4397   else
4398     GetClientSize(w, h);
4399 }
4400
4401 void wxWindow::GetPositionConstraint(int *x, int *y) const
4402 {
4403   wxLayoutConstraints *constr = GetConstraints();
4404   if (constr)
4405   {
4406     *x = constr->left.GetValue();
4407     *y = constr->top.GetValue();
4408   }
4409   else
4410     GetPosition(x, y);
4411 }
4412
4413 bool wxWindow::Close(const bool force)
4414 {
4415   // Let's generalise it to work the same for any window.
4416 /*
4417   if (!IsKindOf(CLASSINFO(wxDialog)) && !IsKindOf(CLASSINFO(wxFrame)))
4418   {
4419     this->Destroy();
4420     return TRUE;
4421   }
4422 */
4423
4424   wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
4425   event.SetEventObject(this);
4426   event.SetForce(force);
4427
4428   return GetEventHandler()->ProcessEvent(event);
4429
4430 /*
4431   if ( !force && event.GetVeto() )
4432     return FALSE;
4433
4434   Show(FALSE);
4435
4436   if (!wxPendingDelete.Member(this))
4437     wxPendingDelete.Append(this);
4438
4439   return TRUE;
4440 */
4441 }
4442
4443 wxObject* wxWindow::GetChild(const int number) const
4444 {
4445   // Return a pointer to the Nth object in the Panel
4446   if (!GetChildren())
4447     return(NULL) ;
4448   wxNode *node = GetChildren()->First();
4449   int n = number;
4450   while (node && n--)
4451     node = node->Next() ;
4452   if (node)
4453   {
4454     wxObject *obj = (wxObject *)node->Data();
4455     return(obj) ;
4456   }
4457   else
4458     return NULL ;
4459 }
4460
4461 void wxWindow::OnDefaultAction(wxControl *initiatingItem)
4462 {
4463   if (initiatingItem->IsKindOf(CLASSINFO(wxListBox)) && initiatingItem->GetCallback())
4464   {
4465     wxListBox *lbox = (wxListBox *)initiatingItem;
4466     wxCommandEvent event(wxEVENT_TYPE_LISTBOX_DCLICK_COMMAND);
4467     event.m_commandInt = -1;
4468     if ((lbox->GetWindowStyleFlag() & wxLB_MULTIPLE) == 0)
4469     {
4470       event.m_commandString = copystring(lbox->GetStringSelection());
4471       event.m_commandInt = lbox->GetSelection();
4472       event.m_clientData = lbox->wxListBox::GetClientData(event.m_commandInt);
4473     }
4474     event.m_eventObject = lbox;
4475
4476     lbox->ProcessCommand(event);
4477
4478     if (event.m_commandString)
4479       delete[] event.m_commandString;
4480     return;
4481   }
4482
4483   wxButton *but = GetDefaultItem();
4484   if (but)
4485   {
4486     wxCommandEvent event(wxEVENT_TYPE_BUTTON_COMMAND);
4487     but->Command(event);
4488   }
4489 }
4490
4491 void wxWindow::Clear(void)
4492 {
4493         wxClientDC dc(this);
4494     wxBrush brush(GetBackgroundColour(), wxSOLID);
4495     dc.SetBackground(brush);
4496     dc.Clear();
4497 }
4498
4499 // Fits the panel around the items
4500 void wxWindow::Fit(void)
4501 {
4502         int maxX = 0;
4503         int maxY = 0;
4504         wxNode *node = GetChildren()->First();
4505         while ( node )
4506         {
4507                 wxWindow *win = (wxWindow *)node->Data();
4508                 int wx, wy, ww, wh;
4509                 win->GetPosition(&wx, &wy);
4510                 win->GetSize(&ww, &wh);
4511                 if ( wx + ww > maxX )
4512                         maxX = wx + ww;
4513                 if ( wy + wh > maxY )
4514                         maxY = wy + wh;
4515
4516                 node = node->Next();
4517         }
4518         SetClientSize(maxX + 5, maxY + 5);
4519 }
4520
4521 void wxWindow::SetValidator(const wxValidator& validator)
4522 {
4523         if ( m_windowValidator )
4524                 delete m_windowValidator;
4525         m_windowValidator = validator.Clone();
4526
4527         if ( m_windowValidator )
4528                 m_windowValidator->SetWindow(this) ;
4529 }
4530
4531 // Find a window by id or name
4532 wxWindow *wxWindow::FindWindow(const long id)
4533 {
4534         if ( GetId() == id)
4535                 return this;
4536
4537         wxNode *node = GetChildren()->First();
4538         while ( node )
4539         {
4540                 wxWindow *child = (wxWindow *)node->Data();
4541                 wxWindow *found = child->FindWindow(id);
4542                 if ( found )
4543                         return found;
4544                 node = node->Next();
4545         }
4546         return NULL;
4547 }
4548
4549 wxWindow *wxWindow::FindWindow(const wxString& name)
4550 {
4551         if ( GetName() == name)
4552                 return this;
4553
4554         wxNode *node = GetChildren()->First();
4555         while ( node )
4556         {
4557                 wxWindow *child = (wxWindow *)node->Data();
4558                 wxWindow *found = child->FindWindow(name);
4559                 if ( found )
4560                         return found;
4561                 node = node->Next();
4562         }
4563         return NULL;
4564 }
4565
4566 /* TODO
4567 // Default input behaviour for a scrolling canvas should be to scroll
4568 // according to the cursor keys pressed
4569 void wxWindow::OnChar(wxKeyEvent& event)
4570 {
4571   int x_page = 0;
4572   int y_page = 0;
4573   int start_x = 0;
4574   int start_y = 0;
4575   // Bugfix Begin
4576   int v_width = 0;
4577   int v_height = 0;
4578   int y_pages = 0;
4579   // Bugfix End
4580
4581   GetScrollUnitsPerPage(&x_page, &y_page);
4582   // Bugfix Begin
4583   GetVirtualSize(&v_width,&v_height);
4584   // Bugfix End
4585   ViewStart(&start_x, &start_y);
4586   // Bugfix begin
4587   if (vert_units)
4588          y_pages = (int)(v_height/vert_units) - y_page;
4589
4590 #ifdef __WINDOWS__
4591   int y = 0;
4592 #else
4593   int y = y_page-1;
4594 #endif
4595  // Bugfix End
4596   switch (event.keyCode)
4597   {
4598          case WXK_PRIOR:
4599          {
4600          // BugFix Begin
4601                 if (y_page > 0)
4602                   {
4603                   if (start_y - y_page > 0)
4604                          Scroll(start_x, start_y - y_page);
4605                   else
4606                          Scroll(start_x, 0);
4607                   }
4608                   // Bugfix End
4609                 break;
4610          }
4611          case WXK_NEXT:
4612          {
4613          // Bugfix Begin
4614                 if ((y_page > 0)  && (start_y <= y_pages-y-1))
4615                                                  {
4616                         if (y_pages + y < start_y + y_page)
4617                           Scroll(start_x, y_pages + y);
4618                         else
4619                           Scroll(start_x, start_y + y_page);
4620                         }
4621          // Bugfix End
4622                 break;
4623          }
4624          case WXK_UP:
4625          {
4626                 if ((y_page > 0) && (start_y >= 1))
4627                   Scroll(start_x, start_y - 1);
4628                 break;
4629          }
4630          case WXK_DOWN:
4631          {
4632          // Bugfix Begin
4633                 if ((y_page > 0) && (start_y <= y_pages-y-1))
4634          // Bugfix End
4635                 {
4636                   Scroll(start_x, start_y + 1);
4637                 }
4638                 break;
4639          }
4640          case WXK_LEFT:
4641          {
4642                 if ((x_page > 0) && (start_x >= 1))
4643                   Scroll(start_x - 1, start_y);
4644                 break;
4645          }
4646          case WXK_RIGHT:
4647          {
4648                 if (x_page > 0)
4649                   Scroll(start_x + 1, start_y);
4650                 break;
4651          }
4652          case WXK_HOME:
4653          {
4654                 Scroll(0, 0);
4655                 break;
4656          }
4657          // This is new
4658          case WXK_END:
4659          {
4660                 Scroll(start_x, y_pages+y);
4661                 break;
4662          }
4663          // end
4664   }
4665 }
4666 */
4667
4668 // Setup background and foreground colours correctly
4669 void wxWindow::SetupColours(void)
4670 {
4671         if (GetParent())
4672                 SetBackgroundColour(GetParent()->GetBackgroundColour());
4673 }
4674
4675 // Do Update UI processing for child controls
4676
4677 // TODO: should this be implemented for the child window rather
4678 // than the parent? Then you can override it e.g. for wxCheckBox
4679 // to do the Right Thing rather than having to assume a fixed number
4680 // of control classes.
4681
4682 void wxWindow::UpdateWindowUI(void)
4683 {
4684                 wxWindowID id = GetId();
4685                 if (id > 0)
4686                 {
4687                         wxUpdateUIEvent event(id);
4688                         event.m_eventObject = this;
4689
4690                         if (this->GetEventHandler()->ProcessEvent(event))
4691                         {
4692                                 if (event.GetSetEnabled())
4693                                         this->Enable(event.GetEnabled());
4694
4695                                 if (event.GetSetText() && this->IsKindOf(CLASSINFO(wxControl)))
4696                                         ((wxControl*)this)->SetLabel(event.GetText());
4697
4698                                 if (this->IsKindOf(CLASSINFO(wxCheckBox)))
4699                                 {
4700                                         if (event.GetSetChecked())
4701                                                 ((wxCheckBox *) this)->SetValue(event.GetChecked());
4702                                 }
4703                                 else if (this->IsKindOf(CLASSINFO(wxRadioButton)))
4704                                 {
4705                                         if (event.GetSetChecked())
4706                                                 ((wxRadioButton *) this)->SetValue(event.GetChecked());
4707                                 }
4708                         }
4709                 }
4710
4711 }
4712
4713 void wxWindow::OnIdle(wxIdleEvent& event)
4714 {
4715     // Check if we need to send a LEAVE event
4716     if (m_mouseInWindow)
4717     {
4718         POINT pt;
4719         ::GetCursorPos(&pt);
4720         if (::WindowFromPoint(pt) != (HWND) GetHWND())
4721         {
4722             // Generate a LEAVE event
4723             m_mouseInWindow = FALSE;
4724             MSWOnMouseLeave(pt.x, pt.y, 0);
4725         }
4726     }
4727
4728         UpdateWindowUI();
4729 }
4730
4731 // Raise the window to the top of the Z order
4732 void wxWindow::Raise(void)
4733 {
4734     ::BringWindowToTop((HWND) GetHWND());
4735 }
4736
4737 // Lower the window to the bottom of the Z order
4738 void wxWindow::Lower(void)
4739 {
4740     ::SetWindowPos((HWND) GetHWND(), HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
4741 }
4742