src/common/wincmn.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        common/window.cpp
   3 // Purpose:     common (to all ports) wxWindow functions
   4 // Author:      Julian Smart, Vadim Zeitlin
   5 // Modified by:
   6 // Created:     13/07/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) wxWindows team
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "windowbase.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/string.h"
  33     #include "wx/log.h"
  34     #include "wx/intl.h"
  35     #include "wx/frame.h"
  36     #include "wx/defs.h"
  37     #include "wx/window.h"
  38     #include "wx/control.h"
  39     #include "wx/checkbox.h"
  40     #include "wx/radiobut.h"
  41     #include "wx/textctrl.h"
  42     #include "wx/settings.h"
  43     #include "wx/dialog.h"
  44     #include "wx/msgdlg.h"
  45     #include "wx/statusbr.h"
  46 #endif //WX_PRECOMP
  47
  48 #if wxUSE_CONSTRAINTS
  49     #include "wx/layout.h"
  50     #include "wx/sizer.h"
  51 #endif // wxUSE_CONSTRAINTS
  52
  53 #if wxUSE_DRAG_AND_DROP
  54     #include "wx/dnd.h"
  55 #endif // wxUSE_DRAG_AND_DROP
  56
  57 #if wxUSE_HELP
  58     #include "wx/cshelp.h"
  59 #endif // wxUSE_HELP
  60
  61 #if wxUSE_TOOLTIPS
  62     #include "wx/tooltip.h"
  63 #endif // wxUSE_TOOLTIPS
  64
  65 #if wxUSE_CARET
  66     #include "wx/caret.h"
  67 #endif // wxUSE_CARET
  68
  69 // ----------------------------------------------------------------------------
  70 // static data
  71 // ----------------------------------------------------------------------------
  72
  73 int wxWindowBase::ms_lastControlId = -200;
  74
  75 IMPLEMENT_ABSTRACT_CLASS(wxWindowBase, wxEvtHandler)
  76
  77 // ----------------------------------------------------------------------------
  78 // event table
  79 // ----------------------------------------------------------------------------
  80
  81 BEGIN_EVENT_TABLE(wxWindowBase, wxEvtHandler)
  82     EVT_SYS_COLOUR_CHANGED(wxWindowBase::OnSysColourChanged)
  83     EVT_INIT_DIALOG(wxWindowBase::OnInitDialog)
  84     EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick)
  85
  86 #if wxUSE_HELP
  87     EVT_HELP(-1, wxWindowBase::OnHelp)
  88 #endif // wxUSE_HELP
  89
  90 END_EVENT_TABLE()
  91
  92 // ============================================================================
  93 // implementation of the common functionality of the wxWindow class
  94 // ============================================================================
  95
  96 // ----------------------------------------------------------------------------
  97 // initialization
  98 // ----------------------------------------------------------------------------
  99
 100 // the default initialization
 101 void wxWindowBase::InitBase()
 102 {
 103     // no window yet, no parent nor children
 104     m_parent = (wxWindow *)NULL;
 105     m_windowId = -1;
 106     m_children.DeleteContents( FALSE ); // don't auto delete node data
 107
 108     // no constraints on the minimal window size
 109     m_minWidth =
 110     m_minHeight =
 111     m_maxWidth =
 112     m_maxHeight = -1;
 113
 114     // window is created enabled but it's not visible yet
 115     m_isShown = FALSE;
 116     m_isEnabled = TRUE;
 117
 118     // the default event handler is just this window
 119     m_eventHandler = this;
 120
 121 #if wxUSE_VALIDATORS
 122     // no validator
 123     m_windowValidator = (wxValidator *) NULL;
 124 #endif // wxUSE_VALIDATORS
 125
 126     // use the system default colours
 127     m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
 128     m_foregroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
 129
 130     // don't set the font here for wxMSW as we don't call WM_SETFONT here and
 131     // so the font is *not* really set - but calls to SetFont() later won't do
 132     // anything because m_font appears to be already set!
 133 #ifndef __WXMSW__
 134     m_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
 135 #endif // __WXMSW__
 136
 137     // the colours/fonts are default for now
 138     m_hasBgCol =
 139     m_hasFgCol =
 140     m_hasFont = FALSE;
 141
 142     // no style bits
 143     m_exStyle =
 144     m_windowStyle = 0;
 145
 146     // an optimization for the event processing: checking this flag is much
 147     // faster than using IsKindOf(CLASSINFO(wxWindow))
 148     m_isWindow = TRUE;
 149
 150 #if wxUSE_CONSTRAINTS
 151     // no constraints whatsoever
 152     m_constraints = (wxLayoutConstraints *) NULL;
 153     m_constraintsInvolvedIn = (wxWindowList *) NULL;
 154     m_windowSizer = (wxSizer *) NULL;
 155     m_autoLayout = FALSE;
 156 #endif // wxUSE_CONSTRAINTS
 157
 158 #if wxUSE_DRAG_AND_DROP
 159     m_dropTarget = (wxDropTarget *)NULL;
 160 #endif // wxUSE_DRAG_AND_DROP
 161
 162 #if wxUSE_TOOLTIPS
 163     m_tooltip = (wxToolTip *)NULL;
 164 #endif // wxUSE_TOOLTIPS
 165
 166 #if wxUSE_CARET
 167     m_caret = (wxCaret *)NULL;
 168 #endif // wxUSE_CARET
 169
 170     // Whether we're using the current theme for this window (wxGTK only for now)
 171     m_themeEnabled = FALSE;
 172 }
 173
 174 // common part of window creation process
 175 bool wxWindowBase::CreateBase(wxWindowBase *parent,
 176                               wxWindowID id,
 177                               const wxPoint& WXUNUSED(pos),
 178                               const wxSize& WXUNUSED(size),
 179                               long style,
 180                               const wxValidator& validator,
 181                               const wxString& name)
 182 {
 183     // m_isWindow is set to TRUE in wxWindowBase::Init() as well as many other
 184     // member variables - check that it has been called (will catch the case
 185     // when a new ctor is added which doesn't call InitWindow)
 186     wxASSERT_MSG( m_isWindow, wxT("Init() must have been called before!") );
 187
 188     // generate a new id if the user doesn't care about it
 189     m_windowId = id == -1 ? NewControlId() : id;
 190
 191     SetName(name);
 192     SetWindowStyleFlag(style);
 193     SetParent(parent);
 194
 195 #if wxUSE_VALIDATORS
 196     SetValidator(validator);
 197 #endif // wxUSE_VALIDATORS
 198
 199     // if the parent window has wxWS_EX_VALIDATE_RECURSIVELY set, we want to
 200     // have it too - like this it's possible to set it only in the top level
 201     // dialog/frame and all children will inherit it by defult
 202     if ( parent && (parent->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) )
 203     {
 204         SetExtraStyle(wxWS_EX_VALIDATE_RECURSIVELY);
 205     }
 206
 207     return TRUE;
 208 }
 209
 210 // ----------------------------------------------------------------------------
 211 // destruction
 212 // ----------------------------------------------------------------------------
 213
 214 // common clean up
 215 wxWindowBase::~wxWindowBase()
 216 {
 217     wxASSERT_MSG( GetCapture() != this, wxT("attempt to destroy window with mouse capture") );
 218
 219     // FIXME if these 2 cases result from programming errors in the user code
 220     //       we should probably assert here instead of silently fixing them
 221
 222     // Just in case the window has been Closed, but we're then deleting
 223     // immediately: don't leave dangling pointers.
 224     wxPendingDelete.DeleteObject(this);
 225
 226     // Just in case we've loaded a top-level window via LoadNativeDialog but
 227     // we weren't a dialog class
 228     wxTopLevelWindows.DeleteObject(this);
 229
 230     wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
 231
 232 #if wxUSE_CARET
 233     if ( m_caret )
 234         delete m_caret;
 235 #endif // wxUSE_CARET
 236
 237 #if wxUSE_VALIDATORS
 238     if ( m_windowValidator )
 239         delete m_windowValidator;
 240 #endif // wxUSE_VALIDATORS
 241
 242 #if wxUSE_CONSTRAINTS
 243     // Have to delete constraints/sizer FIRST otherwise sizers may try to look
 244     // at deleted windows as they delete themselves.
 245     DeleteRelatedConstraints();
 246
 247     if ( m_constraints )
 248     {
 249         // This removes any dangling pointers to this window in other windows'
 250         // constraintsInvolvedIn lists.
 251         UnsetConstraints(m_constraints);
 252         delete m_constraints;
 253         m_constraints = NULL;
 254     }
 255
 256     if ( m_windowSizer )
 257         delete m_windowSizer;
 258
 259 #endif // wxUSE_CONSTRAINTS
 260
 261 #if wxUSE_DRAG_AND_DROP
 262     if ( m_dropTarget )
 263         delete m_dropTarget;
 264 #endif // wxUSE_DRAG_AND_DROP
 265
 266 #if wxUSE_TOOLTIPS
 267     if ( m_tooltip )
 268         delete m_tooltip;
 269 #endif // wxUSE_TOOLTIPS
 270
 271     // reset the dangling pointer our parent window may keep to us
 272     if ( m_parent && m_parent->GetDefaultItem() == this )
 273     {
 274         m_parent->SetDefaultItem(NULL);
 275     }
 276 }
 277
 278 bool wxWindowBase::Destroy()
 279 {
 280     delete this;
 281
 282     return TRUE;
 283 }
 284
 285 bool wxWindowBase::Close(bool force)
 286 {
 287     wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
 288     event.SetEventObject(this);
 289 #if WXWIN_COMPATIBILITY
 290     event.SetForce(force);
 291 #endif // WXWIN_COMPATIBILITY
 292     event.SetCanVeto(!force);
 293
 294     // return FALSE if window wasn't closed because the application vetoed the
 295     // close event
 296     return GetEventHandler()->ProcessEvent(event) && !event.GetVeto();
 297 }
 298
 299 bool wxWindowBase::DestroyChildren()
 300 {
 301     wxWindowList::Node *node;
 302     for ( ;; )
 303     {
 304         // we iterate until the list becomes empty
 305         node = GetChildren().GetFirst();
 306         if ( !node )
 307             break;
 308
 309         wxWindow *child = node->GetData();
 310
 311         wxASSERT_MSG( child, wxT("children list contains empty nodes") );
 312
 313         child->Show(FALSE);
 314         delete child;
 315
 316         wxASSERT_MSG( !GetChildren().Find(child),
 317                       wxT("child didn't remove itself using RemoveChild()") );
 318     }
 319
 320     return TRUE;
 321 }
 322
 323 // ----------------------------------------------------------------------------
 324 // size/position related methods
 325 // ----------------------------------------------------------------------------
 326
 327 // centre the window with respect to its parent in either (or both) directions
 328 void wxWindowBase::Centre(int direction)
 329 {
 330     // the position/size of the parent window or of the entire screen
 331     wxPoint posParent;
 332     int widthParent, heightParent;
 333
 334     wxWindow *parent = NULL;
 335
 336     if ( !(direction & wxCENTRE_ON_SCREEN) )
 337     {
 338         // find the parent to centre this window on: it should be the
 339         // immediate parent for the controls but the top level parent for the
 340         // top level windows (like dialogs)
 341         parent = GetParent();
 342         if ( IsTopLevel() )
 343         {
 344             while ( parent && !parent->IsTopLevel() )
 345             {
 346                 parent = parent->GetParent();
 347             }
 348         }
 349
 350         // did we find the parent?
 351         if ( !parent )
 352         {
 353             // no other choice
 354             direction |= wxCENTRE_ON_SCREEN;
 355         }
 356     }
 357
 358     if ( direction & wxCENTRE_ON_SCREEN )
 359     {
 360         // centre with respect to the whole screen
 361         wxDisplaySize(&widthParent, &heightParent);
 362     }
 363     else
 364     {
 365         if ( IsTopLevel() )
 366         {
 367             // centre on the parent
 368             parent->GetSize(&widthParent, &heightParent);
 369
 370             // adjust to the parents position
 371             posParent = parent->GetPosition();
 372         }
 373         else
 374         {
 375             // centre inside the parents client rectangle
 376             parent->GetClientSize(&widthParent, &heightParent);
 377         }
 378     }
 379
 380     int width, height;
 381     GetSize(&width, &height);
 382
 383     int xNew = -1,
 384         yNew = -1;
 385
 386     if ( direction & wxHORIZONTAL )
 387         xNew = (widthParent - width)/2;
 388
 389     if ( direction & wxVERTICAL )
 390         yNew = (heightParent - height)/2;
 391
 392     xNew += posParent.x;
 393     yNew += posParent.y;
 394
 395     // Base size of the visible dimensions of the display
 396     // to take into account the taskbar
 397     wxRect rect = wxGetClientDisplayRect();
 398     wxSize size (rect.width,rect.height);
 399
 400     if (posParent.x >= 0)  // if parent is on the main display
 401     {
 402         if (xNew < 0)
 403             xNew = 0;
 404         else if (xNew+width > size.x)
 405             xNew = size.x-width-1;
 406     }
 407     if (posParent.y >= 0)  // if parent is on the main display
 408     {
 409         if (yNew+height > size.y)
 410             yNew = size.y-height-1;
 411
 412         // Make certain that the title bar is initially visible
 413         // always, even if this would push the bottom of the
 414         // dialog of the visible area of the display
 415         if (yNew < 0)
 416             yNew = 0;
 417     }
 418
 419     // move the window to this position (keeping the old size but using
 420     // SetSize() and not Move() to allow xNew and/or yNew to be -1)
 421     SetSize(xNew, yNew, width, height, wxSIZE_ALLOW_MINUS_ONE);
 422 }
 423
 424 // fits the window around the children
 425 void wxWindowBase::Fit()
 426 {
 427     if ( GetChildren().GetCount() > 0 )
 428     {
 429         wxSize size = DoGetBestSize();
 430
 431         // for compatibility with the old versions and because it really looks
 432         // slightly more pretty like this, add a pad
 433         size.x += 7;
 434         size.y += 14;
 435
 436         SetClientSize(size);
 437     }
 438     //else: do nothing if we have no children
 439 }
 440
 441 // return the size best suited for the current window
 442 wxSize wxWindowBase::DoGetBestSize() const
 443 {
 444     if ( GetChildren().GetCount() > 0 )
 445     {
 446         // our minimal acceptable size is such that all our windows fit inside
 447         int maxX = 0,
 448             maxY = 0;
 449
 450         for ( wxWindowList::Node *node = GetChildren().GetFirst();
 451               node;
 452               node = node->GetNext() )
 453         {
 454             wxWindow *win = node->GetData();
 455             if ( win->IsTopLevel()
 456 #if wxUSE_STATUSBAR
 457                     || wxDynamicCast(win, wxStatusBar)
 458 #endif // wxUSE_STATUSBAR
 459                )
 460             {
 461                 // dialogs and frames lie in different top level windows -
 462                 // don't deal with them here; as for the status bars, they
 463                 // don't lie in the client area at all
 464                 continue;
 465             }
 466
 467             int wx, wy, ww, wh;
 468             win->GetPosition(&wx, &wy);
 469
 470             // if the window hadn't been positioned yet, assume that it is in
 471             // the origin
 472             if ( wx == -1 )
 473                 wx = 0;
 474             if ( wy == -1 )
 475                 wy = 0;
 476
 477             win->GetSize(&ww, &wh);
 478             if ( wx + ww > maxX )
 479                 maxX = wx + ww;
 480             if ( wy + wh > maxY )
 481                 maxY = wy + wh;
 482         }
 483
 484         return wxSize(maxX, maxY);
 485     }
 486     else
 487     {
 488         // for a generic window there is no natural best size - just use the
 489         // current one
 490         return GetSize();
 491     }
 492 }
 493
 494 // by default the origin is not shifted
 495 wxPoint wxWindowBase::GetClientAreaOrigin() const
 496 {
 497     return wxPoint(0, 0);
 498 }
 499
 500 // set the min/max size of the window
 501 void wxWindowBase::SetSizeHints(int minW, int minH,
 502                                 int maxW, int maxH,
 503                                 int WXUNUSED(incW), int WXUNUSED(incH))
 504 {
 505     m_minWidth = minW;
 506     m_maxWidth = maxW;
 507     m_minHeight = minH;
 508     m_maxHeight = maxH;
 509 }
 510
 511 // ----------------------------------------------------------------------------
 512 // show/hide/enable/disable the window
 513 // ----------------------------------------------------------------------------
 514
 515 bool wxWindowBase::Show(bool show)
 516 {
 517     if ( show != m_isShown )
 518     {
 519         m_isShown = show;
 520
 521         return TRUE;
 522     }
 523     else
 524     {
 525         return FALSE;
 526     }
 527 }
 528
 529 bool wxWindowBase::Enable(bool enable)
 530 {
 531     if ( enable != m_isEnabled )
 532     {
 533         m_isEnabled = enable;
 534
 535         return TRUE;
 536     }
 537     else
 538     {
 539         return FALSE;
 540     }
 541 }
 542 // ----------------------------------------------------------------------------
 543 // RTTI
 544 // ----------------------------------------------------------------------------
 545
 546 bool wxWindowBase::IsTopLevel() const
 547 {
 548     return FALSE;
 549 }
 550
 551 // ----------------------------------------------------------------------------
 552 // reparenting the window
 553 // ----------------------------------------------------------------------------
 554
 555 void wxWindowBase::AddChild(wxWindowBase *child)
 556 {
 557     wxCHECK_RET( child, wxT("can't add a NULL child") );
 558
 559     // this should never happen and it will lead to a crash later if it does
 560     // because RemoveChild() will remove only one node from the children list
 561     // and the other(s) one(s) will be left with dangling pointers in them
 562     wxASSERT_MSG( !GetChildren().Find(child), _T("AddChild() called twice") );
 563
 564     GetChildren().Append(child);
 565     child->SetParent(this);
 566 }
 567
 568 void wxWindowBase::RemoveChild(wxWindowBase *child)
 569 {
 570     wxCHECK_RET( child, wxT("can't remove a NULL child") );
 571
 572     GetChildren().DeleteObject(child);
 573     child->SetParent((wxWindow *)NULL);
 574 }
 575
 576 bool wxWindowBase::Reparent(wxWindowBase *newParent)
 577 {
 578     wxWindow *oldParent = GetParent();
 579     if ( newParent == oldParent )
 580     {
 581         // nothing done
 582         return FALSE;
 583     }
 584
 585     // unlink this window from the existing parent.
 586     if ( oldParent )
 587     {
 588         oldParent->RemoveChild(this);
 589     }
 590     else
 591     {
 592         wxTopLevelWindows.DeleteObject(this);
 593     }
 594
 595     // add it to the new one
 596     if ( newParent )
 597     {
 598         newParent->AddChild(this);
 599     }
 600     else
 601     {
 602         wxTopLevelWindows.Append(this);
 603     }
 604
 605     return TRUE;
 606 }
 607
 608 // ----------------------------------------------------------------------------
 609 // event handler stuff
 610 // ----------------------------------------------------------------------------
 611
 612 void wxWindowBase::PushEventHandler(wxEvtHandler *handler)
 613 {
 614     handler->SetNextHandler(GetEventHandler());
 615     SetEventHandler(handler);
 616 }
 617
 618 wxEvtHandler *wxWindowBase::PopEventHandler(bool deleteHandler)
 619 {
 620     wxEvtHandler *handlerA = GetEventHandler();
 621     if ( handlerA )
 622     {
 623         wxEvtHandler *handlerB = handlerA->GetNextHandler();
 624         handlerA->SetNextHandler((wxEvtHandler *)NULL);
 625         SetEventHandler(handlerB);
 626         if ( deleteHandler )
 627         {
 628             delete handlerA;
 629             handlerA = (wxEvtHandler *)NULL;
 630         }
 631     }
 632
 633     return handlerA;
 634 }
 635
 636 bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler)
 637 {
 638     wxCHECK_MSG( handler, FALSE, _T("RemoveEventHandler(NULL) called") );
 639
 640     wxEvtHandler *handlerPrev = NULL,
 641                  *handlerCur = GetEventHandler();
 642     while ( handlerCur )
 643     {
 644         wxEvtHandler *handlerNext = handlerCur->GetNextHandler();
 645
 646         if ( handlerCur == handler )
 647         {
 648             if ( handlerPrev )
 649             {
 650                 handlerPrev->SetNextHandler(handlerNext);
 651             }
 652             else
 653             {
 654                 SetEventHandler(handlerNext);
 655             }
 656
 657             handler->SetNextHandler(NULL);
 658
 659             return TRUE;
 660         }
 661
 662         handlerPrev = handlerCur;
 663         handlerCur = handlerNext;
 664     }
 665
 666     wxFAIL_MSG( _T("where has the event handler gone?") );
 667
 668     return FALSE;
 669 }
 670
 671 // ----------------------------------------------------------------------------
 672 // cursors, fonts &c
 673 // ----------------------------------------------------------------------------
 674
 675 bool wxWindowBase::SetBackgroundColour( const wxColour &colour )
 676 {
 677     if ( !colour.Ok() || (colour == m_backgroundColour) )
 678         return FALSE;
 679
 680     m_backgroundColour = colour;
 681
 682     m_hasBgCol = TRUE;
 683
 684     return TRUE;
 685 }
 686
 687 bool wxWindowBase::SetForegroundColour( const wxColour &colour )
 688 {
 689     if ( !colour.Ok() || (colour == m_foregroundColour) )
 690         return FALSE;
 691
 692     m_foregroundColour = colour;
 693
 694     m_hasFgCol = TRUE;
 695
 696     return TRUE;
 697 }
 698
 699 bool wxWindowBase::SetCursor(const wxCursor& cursor)
 700 {
 701     // setting an invalid cursor is ok, it means that we don't have any special
 702     // cursor
 703     if ( m_cursor == cursor )
 704     {
 705         // no change
 706         return FALSE;
 707     }
 708
 709     m_cursor = cursor;
 710
 711     return TRUE;
 712 }
 713
 714 bool wxWindowBase::SetFont(const wxFont& font)
 715 {
 716     // don't try to set invalid font, always fall back to the default
 717     const wxFont& fontOk = font.Ok() ? font : *wxSWISS_FONT;
 718
 719     if ( fontOk == m_font )
 720     {
 721         // no change
 722         return FALSE;
 723     }
 724
 725     m_font = fontOk;
 726
 727     m_hasFont = TRUE;
 728
 729     return TRUE;
 730 }
 731
 732 #if wxUSE_CARET
 733 void wxWindowBase::SetCaret(wxCaret *caret)
 734 {
 735     if ( m_caret )
 736     {
 737         delete m_caret;
 738     }
 739
 740     m_caret = caret;
 741
 742     if ( m_caret )
 743     {
 744         wxASSERT_MSG( m_caret->GetWindow() == this,
 745                       wxT("caret should be created associated to this window") );
 746     }
 747 }
 748 #endif // wxUSE_CARET
 749
 750 #if wxUSE_VALIDATORS
 751 // ----------------------------------------------------------------------------
 752 // validators
 753 // ----------------------------------------------------------------------------
 754
 755 void wxWindowBase::SetValidator(const wxValidator& validator)
 756 {
 757     if ( m_windowValidator )
 758         delete m_windowValidator;
 759
 760     m_windowValidator = (wxValidator *)validator.Clone();
 761
 762     if ( m_windowValidator )
 763         m_windowValidator->SetWindow(this) ;
 764 }
 765 #endif // wxUSE_VALIDATORS
 766
 767 // ----------------------------------------------------------------------------
 768 // update region stuff
 769 // ----------------------------------------------------------------------------
 770
 771 wxRect wxWindowBase::GetUpdateClientRect() const
 772 {
 773     wxRegion rgnUpdate = GetUpdateRegion();
 774     rgnUpdate.Intersect(GetClientRect());
 775     wxRect rectUpdate = rgnUpdate.GetBox();
 776     wxPoint ptOrigin = GetClientAreaOrigin();
 777     rectUpdate.x -= ptOrigin.x;
 778     rectUpdate.y -= ptOrigin.y;
 779
 780     return rectUpdate;
 781 }
 782
 783 bool wxWindowBase::IsExposed(int x, int y) const
 784 {
 785     return m_updateRegion.Contains(x, y) != wxOutRegion;
 786 }
 787
 788 bool wxWindowBase::IsExposed(int x, int y, int w, int h) const
 789 {
 790     return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
 791 }
 792
 793 // ----------------------------------------------------------------------------
 794 // find window by id or name
 795 // ----------------------------------------------------------------------------
 796
 797 wxWindow *wxWindowBase::FindWindow( long id )
 798 {
 799     if ( id == m_windowId )
 800         return (wxWindow *)this;
 801
 802     wxWindowBase *res = (wxWindow *)NULL;
 803     wxWindowList::Node *node;
 804     for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
 805     {
 806         wxWindowBase *child = node->GetData();
 807         res = child->FindWindow( id );
 808     }
 809
 810     return (wxWindow *)res;
 811 }
 812
 813 wxWindow *wxWindowBase::FindWindow( const wxString& name )
 814 {
 815     if ( name == m_windowName )
 816         return (wxWindow *)this;
 817
 818     wxWindowBase *res = (wxWindow *)NULL;
 819     wxWindowList::Node *node;
 820     for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
 821     {
 822         wxWindow *child = node->GetData();
 823         res = child->FindWindow(name);
 824     }
 825
 826     return (wxWindow *)res;
 827 }
 828
 829 // ----------------------------------------------------------------------------
 830 // dialog oriented functions
 831 // ----------------------------------------------------------------------------
 832
 833 void wxWindowBase::MakeModal(bool modal)
 834 {
 835     // Disable all other windows
 836     if ( IsTopLevel() )
 837     {
 838         wxWindowList::Node *node = wxTopLevelWindows.GetFirst();
 839         while (node)
 840         {
 841             wxWindow *win = node->GetData();
 842             if (win != this)
 843                 win->Enable(!modal);
 844
 845             node = node->GetNext();
 846         }
 847     }
 848 }
 849
 850 bool wxWindowBase::Validate()
 851 {
 852 #if wxUSE_VALIDATORS
 853     bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
 854
 855     wxWindowList::Node *node;
 856     for ( node = m_children.GetFirst(); node; node = node->GetNext() )
 857     {
 858         wxWindowBase *child = node->GetData();
 859         wxValidator *validator = child->GetValidator();
 860         if ( validator && !validator->Validate((wxWindow *)this) )
 861         {
 862             return FALSE;
 863         }
 864
 865         if ( recurse && !child->Validate() )
 866         {
 867             return FALSE;
 868         }
 869     }
 870 #endif // wxUSE_VALIDATORS
 871
 872     return TRUE;
 873 }
 874
 875 bool wxWindowBase::TransferDataToWindow()
 876 {
 877 #if wxUSE_VALIDATORS
 878     bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
 879
 880     wxWindowList::Node *node;
 881     for ( node = m_children.GetFirst(); node; node = node->GetNext() )
 882     {
 883         wxWindowBase *child = node->GetData();
 884         wxValidator *validator = child->GetValidator();
 885         if ( validator && !validator->TransferToWindow() )
 886         {
 887             wxLogWarning(_("Could not transfer data to window"));
 888             wxLog::FlushActive();
 889
 890             return FALSE;
 891         }
 892
 893         if ( recurse )
 894         {
 895             if ( !child->TransferDataToWindow() )
 896             {
 897                 // warning already given
 898                 return FALSE;
 899             }
 900         }
 901     }
 902 #endif // wxUSE_VALIDATORS
 903
 904     return TRUE;
 905 }
 906
 907 bool wxWindowBase::TransferDataFromWindow()
 908 {
 909 #if wxUSE_VALIDATORS
 910     bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
 911
 912     wxWindowList::Node *node;
 913     for ( node = m_children.GetFirst(); node; node = node->GetNext() )
 914     {
 915         wxWindow *child = node->GetData();
 916         wxValidator *validator = child->GetValidator();
 917         if ( validator && !validator->TransferFromWindow() )
 918         {
 919             // nop warning here because the application is supposed to give
 920             // one itself - we don't know here what might have gone wrongly
 921
 922             return FALSE;
 923         }
 924
 925         if ( recurse )
 926         {
 927             if ( !child->TransferDataFromWindow() )
 928             {
 929                 // warning already given
 930                 return FALSE;
 931             }
 932         }
 933     }
 934 #endif // wxUSE_VALIDATORS
 935
 936     return TRUE;
 937 }
 938
 939 void wxWindowBase::InitDialog()
 940 {
 941     wxInitDialogEvent event(GetId());
 942     event.SetEventObject( this );
 943     GetEventHandler()->ProcessEvent(event);
 944 }
 945
 946 // ----------------------------------------------------------------------------
 947 // context-sensitive help support
 948 // ----------------------------------------------------------------------------
 949
 950 #if wxUSE_HELP
 951
 952 // associate this help text with this window
 953 void wxWindowBase::SetHelpText(const wxString& text)
 954 {
 955     wxHelpProvider *helpProvider = wxHelpProvider::Get();
 956     if ( helpProvider )
 957     {
 958         helpProvider->AddHelp(this, text);
 959     }
 960 }
 961
 962 // associate this help text with all windows with the same id as this
 963 // one
 964 void wxWindowBase::SetHelpTextForId(const wxString& text)
 965 {
 966     wxHelpProvider *helpProvider = wxHelpProvider::Get();
 967     if ( helpProvider )
 968     {
 969         helpProvider->AddHelp(GetId(), text);
 970     }
 971 }
 972
 973 // get the help string associated with this window (may be empty)
 974 wxString wxWindowBase::GetHelpText() const
 975 {
 976     wxString text;
 977     wxHelpProvider *helpProvider = wxHelpProvider::Get();
 978     if ( helpProvider )
 979     {
 980         text = helpProvider->GetHelp(this);
 981     }
 982
 983     return text;
 984 }
 985
 986 // show help for this window
 987 void wxWindowBase::OnHelp(wxHelpEvent& event)
 988 {
 989     wxHelpProvider *helpProvider = wxHelpProvider::Get();
 990     if ( helpProvider )
 991     {
 992         if ( helpProvider->ShowHelp(this) )
 993         {
 994             // skip the event.Skip() below
 995             return;
 996         }
 997     }
 998
 999     event.Skip();
1000 }
1001
1002 #endif // wxUSE_HELP
1003
1004 // ----------------------------------------------------------------------------
1005 // tooltips
1006 // ----------------------------------------------------------------------------
1007
1008 #if wxUSE_TOOLTIPS
1009
1010 void wxWindowBase::SetToolTip( const wxString &tip )
1011 {
1012     // don't create the new tooltip if we already have one
1013     if ( m_tooltip )
1014     {
1015         m_tooltip->SetTip( tip );
1016     }
1017     else
1018     {
1019         SetToolTip( new wxToolTip( tip ) );
1020     }
1021
1022     // setting empty tooltip text does not remove the tooltip any more - use
1023     // SetToolTip((wxToolTip *)NULL) for this
1024 }
1025
1026 void wxWindowBase::DoSetToolTip(wxToolTip *tooltip)
1027 {
1028     if ( m_tooltip )
1029         delete m_tooltip;
1030
1031     m_tooltip = tooltip;
1032 }
1033
1034 #endif // wxUSE_TOOLTIPS
1035
1036 // ----------------------------------------------------------------------------
1037 // constraints and sizers
1038 // ----------------------------------------------------------------------------
1039
1040 #if wxUSE_CONSTRAINTS
1041
1042 void wxWindowBase::SetConstraints( wxLayoutConstraints *constraints )
1043 {
1044     if ( m_constraints )
1045     {
1046         UnsetConstraints(m_constraints);
1047         delete m_constraints;
1048     }
1049     m_constraints = constraints;
1050     if ( m_constraints )
1051     {
1052         // Make sure other windows know they're part of a 'meaningful relationship'
1053         if ( m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this) )
1054             m_constraints->left.GetOtherWindow()->AddConstraintReference(this);
1055         if ( m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this) )
1056             m_constraints->top.GetOtherWindow()->AddConstraintReference(this);
1057         if ( m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this) )
1058             m_constraints->right.GetOtherWindow()->AddConstraintReference(this);
1059         if ( m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this) )
1060             m_constraints->bottom.GetOtherWindow()->AddConstraintReference(this);
1061         if ( m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this) )
1062             m_constraints->width.GetOtherWindow()->AddConstraintReference(this);
1063         if ( m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this) )
1064             m_constraints->height.GetOtherWindow()->AddConstraintReference(this);
1065         if ( m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this) )
1066             m_constraints->centreX.GetOtherWindow()->AddConstraintReference(this);
1067         if ( m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this) )
1068             m_constraints->centreY.GetOtherWindow()->AddConstraintReference(this);
1069     }
1070 }
1071
1072 // This removes any dangling pointers to this window in other windows'
1073 // constraintsInvolvedIn lists.
1074 void wxWindowBase::UnsetConstraints(wxLayoutConstraints *c)
1075 {
1076     if ( c )
1077     {
1078         if ( c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
1079             c->left.GetOtherWindow()->RemoveConstraintReference(this);
1080         if ( c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
1081             c->top.GetOtherWindow()->RemoveConstraintReference(this);
1082         if ( c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this) )
1083             c->right.GetOtherWindow()->RemoveConstraintReference(this);
1084         if ( c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this) )
1085             c->bottom.GetOtherWindow()->RemoveConstraintReference(this);
1086         if ( c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this) )
1087             c->width.GetOtherWindow()->RemoveConstraintReference(this);
1088         if ( c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this) )
1089             c->height.GetOtherWindow()->RemoveConstraintReference(this);
1090         if ( c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this) )
1091             c->centreX.GetOtherWindow()->RemoveConstraintReference(this);
1092         if ( c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this) )
1093             c->centreY.GetOtherWindow()->RemoveConstraintReference(this);
1094     }
1095 }
1096
1097 // Back-pointer to other windows we're involved with, so if we delete this
1098 // window, we must delete any constraints we're involved with.
1099 void wxWindowBase::AddConstraintReference(wxWindowBase *otherWin)
1100 {
1101     if ( !m_constraintsInvolvedIn )
1102         m_constraintsInvolvedIn = new wxWindowList;
1103     if ( !m_constraintsInvolvedIn->Find(otherWin) )
1104         m_constraintsInvolvedIn->Append(otherWin);
1105 }
1106
1107 // REMOVE back-pointer to other windows we're involved with.
1108 void wxWindowBase::RemoveConstraintReference(wxWindowBase *otherWin)
1109 {
1110     if ( m_constraintsInvolvedIn )
1111         m_constraintsInvolvedIn->DeleteObject(otherWin);
1112 }
1113
1114 // Reset any constraints that mention this window
1115 void wxWindowBase::DeleteRelatedConstraints()
1116 {
1117     if ( m_constraintsInvolvedIn )
1118     {
1119         wxWindowList::Node *node = m_constraintsInvolvedIn->GetFirst();
1120         while (node)
1121         {
1122             wxWindow *win = node->GetData();
1123             wxLayoutConstraints *constr = win->GetConstraints();
1124
1125             // Reset any constraints involving this window
1126             if ( constr )
1127             {
1128                 constr->left.ResetIfWin(this);
1129                 constr->top.ResetIfWin(this);
1130                 constr->right.ResetIfWin(this);
1131                 constr->bottom.ResetIfWin(this);
1132                 constr->width.ResetIfWin(this);
1133                 constr->height.ResetIfWin(this);
1134                 constr->centreX.ResetIfWin(this);
1135                 constr->centreY.ResetIfWin(this);
1136             }
1137
1138             wxWindowList::Node *next = node->GetNext();
1139             delete node;
1140             node = next;
1141         }
1142
1143         delete m_constraintsInvolvedIn;
1144         m_constraintsInvolvedIn = (wxWindowList *) NULL;
1145     }
1146 }
1147
1148 void wxWindowBase::SetSizer(wxSizer *sizer)
1149 {
1150     if (m_windowSizer) delete m_windowSizer;
1151
1152     m_windowSizer = sizer;
1153 }
1154
1155 bool wxWindowBase::Layout()
1156 {
1157     // If there is a sizer, use it instead of the constraints
1158     if ( GetSizer() )
1159     {
1160         int w, h;
1161         GetClientSize(&w, &h);
1162
1163         GetSizer()->SetDimension( 0, 0, w, h );
1164 #if defined __WXPM__
1165         OS2Layout(w, h);
1166 #endif
1167     }
1168     else
1169     {
1170         wxLayoutConstraints *constr = GetConstraints();
1171         bool wasOk = constr && constr->AreSatisfied();
1172
1173         ResetConstraints();   // Mark all constraints as unevaluated
1174
1175         // if we're a top level panel (i.e. our parent is frame/dialog), our
1176         // own constraints will never be satisfied any more unless we do it
1177         // here
1178         if ( wasOk )
1179         {
1180             int noChanges = 1;
1181             while ( noChanges > 0 )
1182             {
1183                 constr->SatisfyConstraints(this, &noChanges);
1184             }
1185         }
1186
1187         DoPhase(1);           // Layout children
1188         DoPhase(2);           // Layout grand children
1189         SetConstraintSizes(); // Recursively set the real window sizes
1190     }
1191
1192     return TRUE;
1193 }
1194
1195
1196 // Do a phase of evaluating constraints: the default behaviour. wxSizers may
1197 // do a similar thing, but also impose their own 'constraints' and order the
1198 // evaluation differently.
1199 bool wxWindowBase::LayoutPhase1(int *noChanges)
1200 {
1201     wxLayoutConstraints *constr = GetConstraints();
1202     if ( constr )
1203     {
1204         return constr->SatisfyConstraints(this, noChanges);
1205     }
1206     else
1207         return TRUE;
1208 }
1209
1210 bool wxWindowBase::LayoutPhase2(int *noChanges)
1211 {
1212     *noChanges = 0;
1213
1214     // Layout children
1215     DoPhase(1);
1216     DoPhase(2);
1217     return TRUE;
1218 }
1219
1220 // Do a phase of evaluating child constraints
1221 bool wxWindowBase::DoPhase(int phase)
1222 {
1223     int noIterations = 0;
1224     int maxIterations = 500;
1225     int noChanges = 1;
1226     int noFailures = 0;
1227     wxWindowList succeeded;
1228     while ((noChanges > 0) && (noIterations < maxIterations))
1229     {
1230         noChanges = 0;
1231         noFailures = 0;
1232         wxWindowList::Node *node = GetChildren().GetFirst();
1233         while (node)
1234         {
1235             wxWindow *child = node->GetData();
1236             if ( !child->IsTopLevel() )
1237             {
1238                 wxLayoutConstraints *constr = child->GetConstraints();
1239                 if ( constr )
1240                 {
1241                     if ( !succeeded.Find(child) )
1242                     {
1243                         int tempNoChanges = 0;
1244                         bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
1245                         noChanges += tempNoChanges;
1246                         if ( success )
1247                         {
1248                             succeeded.Append(child);
1249                         }
1250                     }
1251                 }
1252             }
1253             node = node->GetNext();
1254         }
1255
1256         noIterations++;
1257     }
1258
1259     return TRUE;
1260 }
1261
1262 void wxWindowBase::ResetConstraints()
1263 {
1264     wxLayoutConstraints *constr = GetConstraints();
1265     if ( constr )
1266     {
1267         constr->left.SetDone(FALSE);
1268         constr->top.SetDone(FALSE);
1269         constr->right.SetDone(FALSE);
1270         constr->bottom.SetDone(FALSE);
1271         constr->width.SetDone(FALSE);
1272         constr->height.SetDone(FALSE);
1273         constr->centreX.SetDone(FALSE);
1274         constr->centreY.SetDone(FALSE);
1275     }
1276
1277     wxWindowList::Node *node = GetChildren().GetFirst();
1278     while (node)
1279     {
1280         wxWindow *win = node->GetData();
1281         if ( !win->IsTopLevel() )
1282             win->ResetConstraints();
1283         node = node->GetNext();
1284     }
1285 }
1286
1287 // Need to distinguish between setting the 'fake' size for windows and sizers,
1288 // and setting the real values.
1289 void wxWindowBase::SetConstraintSizes(bool recurse)
1290 {
1291     wxLayoutConstraints *constr = GetConstraints();
1292     if ( constr && constr->AreSatisfied() )
1293     {
1294         int x = constr->left.GetValue();
1295         int y = constr->top.GetValue();
1296         int w = constr->width.GetValue();
1297         int h = constr->height.GetValue();
1298
1299         if ( (constr->width.GetRelationship() != wxAsIs ) ||
1300              (constr->height.GetRelationship() != wxAsIs) )
1301         {
1302             SetSize(x, y, w, h);
1303         }
1304         else
1305         {
1306             // If we don't want to resize this window, just move it...
1307             Move(x, y);
1308         }
1309     }
1310     else if ( constr )
1311     {
1312         wxLogDebug(wxT("Constraints not satisfied for %s named '%s'."),
1313                    GetClassInfo()->GetClassName(),
1314                    GetName().c_str());
1315     }
1316
1317     if ( recurse )
1318     {
1319         wxWindowList::Node *node = GetChildren().GetFirst();
1320         while (node)
1321         {
1322             wxWindow *win = node->GetData();
1323             if ( !win->IsTopLevel() && win->GetConstraints() )
1324                 win->SetConstraintSizes();
1325             node = node->GetNext();
1326         }
1327     }
1328 }
1329
1330 // Only set the size/position of the constraint (if any)
1331 void wxWindowBase::SetSizeConstraint(int x, int y, int w, int h)
1332 {
1333     wxLayoutConstraints *constr = GetConstraints();
1334     if ( constr )
1335     {
1336         if ( x != -1 )
1337         {
1338             constr->left.SetValue(x);
1339             constr->left.SetDone(TRUE);
1340         }
1341         if ( y != -1 )
1342         {
1343             constr->top.SetValue(y);
1344             constr->top.SetDone(TRUE);
1345         }
1346         if ( w != -1 )
1347         {
1348             constr->width.SetValue(w);
1349             constr->width.SetDone(TRUE);
1350         }
1351         if ( h != -1 )
1352         {
1353             constr->height.SetValue(h);
1354             constr->height.SetDone(TRUE);
1355         }
1356     }
1357 }
1358
1359 void wxWindowBase::MoveConstraint(int x, int y)
1360 {
1361     wxLayoutConstraints *constr = GetConstraints();
1362     if ( constr )
1363     {
1364         if ( x != -1 )
1365         {
1366             constr->left.SetValue(x);
1367             constr->left.SetDone(TRUE);
1368         }
1369         if ( y != -1 )
1370         {
1371             constr->top.SetValue(y);
1372             constr->top.SetDone(TRUE);
1373         }
1374     }
1375 }
1376
1377 void wxWindowBase::GetSizeConstraint(int *w, int *h) const
1378 {
1379     wxLayoutConstraints *constr = GetConstraints();
1380     if ( constr )
1381     {
1382         *w = constr->width.GetValue();
1383         *h = constr->height.GetValue();
1384     }
1385     else
1386         GetSize(w, h);
1387 }
1388
1389 void wxWindowBase::GetClientSizeConstraint(int *w, int *h) const
1390 {
1391     wxLayoutConstraints *constr = GetConstraints();
1392     if ( constr )
1393     {
1394         *w = constr->width.GetValue();
1395         *h = constr->height.GetValue();
1396     }
1397     else
1398         GetClientSize(w, h);
1399 }
1400
1401 void wxWindowBase::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
1402 {
1403     // don't do it for the dialogs/frames - they float independently of their
1404     // parent
1405     if ( !IsTopLevel() )
1406     {
1407         wxWindow *parent = GetParent();
1408         if ( !(sizeFlags & wxSIZE_NO_ADJUSTMENTS) && parent )
1409         {
1410             wxPoint pt(parent->GetClientAreaOrigin());
1411             x += pt.x;
1412             y += pt.y;
1413         }
1414     }
1415 }
1416
1417
1418 void wxWindowBase::GetPositionConstraint(int *x, int *y) const
1419 {
1420     wxLayoutConstraints *constr = GetConstraints();
1421     if ( constr )
1422     {
1423         *x = constr->left.GetValue();
1424         *y = constr->top.GetValue();
1425     }
1426     else
1427         GetPosition(x, y);
1428 }
1429
1430 #endif // wxUSE_CONSTRAINTS
1431
1432 // ----------------------------------------------------------------------------
1433 // do Update UI processing for child controls
1434 // ----------------------------------------------------------------------------
1435
1436 // TODO: should this be implemented for the child window rather
1437 // than the parent? Then you can override it e.g. for wxCheckBox
1438 // to do the Right Thing rather than having to assume a fixed number
1439 // of control classes.
1440 void wxWindowBase::UpdateWindowUI()
1441 {
1442 #if wxUSE_CONTROLS
1443     wxUpdateUIEvent event(GetId());
1444     event.m_eventObject = this;
1445
1446     if ( GetEventHandler()->ProcessEvent(event) )
1447     {
1448         if ( event.GetSetEnabled() )
1449             Enable(event.GetEnabled());
1450
1451         if ( event.GetSetText() )
1452         {
1453             wxControl *control = wxDynamicCastThis(wxControl);
1454             if ( control )
1455             {
1456 #if wxUSE_TEXTCTRL
1457                 wxTextCtrl *text = wxDynamicCast(control, wxTextCtrl);
1458                 if ( text )
1459                     text->SetValue(event.GetText());
1460                 else
1461 #endif // wxUSE_TEXTCTRL
1462                     control->SetLabel(event.GetText());
1463             }
1464         }
1465
1466 #if wxUSE_CHECKBOX
1467         wxCheckBox *checkbox = wxDynamicCastThis(wxCheckBox);
1468         if ( checkbox )
1469         {
1470             if ( event.GetSetChecked() )
1471                 checkbox->SetValue(event.GetChecked());
1472         }
1473 #endif // wxUSE_CHECKBOX
1474
1475 #if wxUSE_RADIOBTN
1476         wxRadioButton *radiobtn = wxDynamicCastThis(wxRadioButton);
1477         if ( radiobtn )
1478         {
1479             if ( event.GetSetChecked() )
1480                 radiobtn->SetValue(event.GetChecked());
1481         }
1482 #endif // wxUSE_RADIOBTN
1483     }
1484 #endif // wxUSE_CONTROLS
1485 }
1486
1487 // ----------------------------------------------------------------------------
1488 // dialog units translations
1489 // ----------------------------------------------------------------------------
1490
1491 wxPoint wxWindowBase::ConvertPixelsToDialog(const wxPoint& pt)
1492 {
1493     int charWidth = GetCharWidth();
1494     int charHeight = GetCharHeight();
1495     wxPoint pt2(-1, -1);
1496     if (pt.x != -1)
1497         pt2.x = (int) ((pt.x * 4) / charWidth) ;
1498     if (pt.y != -1)
1499         pt2.y = (int) ((pt.y * 8) / charHeight) ;
1500
1501     return pt2;
1502 }
1503
1504 wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt)
1505 {
1506     int charWidth = GetCharWidth();
1507     int charHeight = GetCharHeight();
1508     wxPoint pt2(-1, -1);
1509     if (pt.x != -1)
1510         pt2.x = (int) ((pt.x * charWidth) / 4) ;
1511     if (pt.y != -1)
1512         pt2.y = (int) ((pt.y * charHeight) / 8) ;
1513
1514     return pt2;
1515 }
1516
1517 // ----------------------------------------------------------------------------
1518 // event handlers
1519 // ----------------------------------------------------------------------------
1520
1521 // propagate the colour change event to the subwindows
1522 void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event)
1523 {
1524     wxWindowList::Node *node = GetChildren().GetFirst();
1525     while ( node )
1526     {
1527         // Only propagate to non-top-level windows
1528         wxWindow *win = node->GetData();
1529         if ( !win->IsTopLevel() )
1530         {
1531             wxSysColourChangedEvent event2;
1532             event.m_eventObject = win;
1533             win->GetEventHandler()->ProcessEvent(event2);
1534         }
1535
1536         node = node->GetNext();
1537     }
1538 }
1539
1540 // the default action is to populate dialog with data when it's created
1541 void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
1542 {
1543     TransferDataToWindow();
1544 }
1545
1546 // process Ctrl-Alt-mclick
1547 void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
1548 {
1549 #if wxUSE_MSGDLG
1550     if ( event.ControlDown() && event.AltDown() )
1551     {
1552         // don't translate these strings
1553         wxString port;
1554
1555 #ifdef __WXUNIVERSAL__
1556         port = _T("Univ/");
1557 #endif // __WXUNIVERSAL__
1558
1559         switch ( wxGetOsVersion() )
1560         {
1561             case wxMOTIF_X:     port = _T("Motif"); break;
1562             case wxMAC:
1563             case wxMAC_DARWIN:  port = _T("Mac"); break;
1564             case wxBEOS:        port = _T("BeOS"); break;
1565             case wxGTK:
1566             case wxGTK_WIN32:
1567             case wxGTK_OS2:
1568             case wxGTK_BEOS:    port = _T("GTK"); break;
1569             case wxWINDOWS:
1570             case wxPENWINDOWS:
1571             case wxWINDOWS_NT:
1572             case wxWIN32S:
1573             case wxWIN95:
1574             case wxWIN386:      port = _T("MS Windows"); break;
1575             case wxMGL_UNIX:
1576             case wxMGL_X:
1577             case wxMGL_WIN32:
1578             case wxMGL_OS2:     port = _T("MGL"); break;
1579             case wxWINDOWS_OS2:
1580             case wxOS2_PM:      port = _T("OS/2"); break;
1581             default:            port = _T("unknown"); break;
1582         }
1583
1584         wxMessageBox(wxString::Format(
1585                                       _T(
1586                                         "       wxWindows Library (%s port)\nVersion %u.%u.%u%s, compiled at %s %s\n   Copyright (c) 1995-2002 wxWindows team"
1587                                         ),
1588                                       port.c_str(),
1589                                       wxMAJOR_VERSION,
1590                                       wxMINOR_VERSION,
1591                                       wxRELEASE_NUMBER,
1592 #if wxUSE_UNICODE
1593                                       L" (Unicode)",
1594 #else
1595                                       "",
1596 #endif
1597                                       __TDATE__,
1598                                       __TTIME__
1599                                      ),
1600                      _T("wxWindows information"),
1601                      wxICON_INFORMATION | wxOK,
1602                      (wxWindow *)this);
1603     }
1604     else
1605 #endif // wxUSE_MSGDLG
1606     {
1607         event.Skip();
1608     }
1609 }
1610
1611 // ----------------------------------------------------------------------------
1612 // list classes implementation
1613 // ----------------------------------------------------------------------------
1614
1615 void wxWindowListNode::DeleteData()
1616 {
1617     delete (wxWindow *)GetData();
1618 }
1619
1620 // ----------------------------------------------------------------------------
1621 // borders
1622 // ----------------------------------------------------------------------------
1623
1624 wxBorder wxWindowBase::GetBorder() const
1625 {
1626     wxBorder border = (wxBorder)(m_windowStyle & wxBORDER_MASK);
1627     if ( border == wxBORDER_DEFAULT )
1628     {
1629         border = GetDefaultBorder();
1630     }
1631
1632     return border;
1633 }
1634
1635 wxBorder wxWindowBase::GetDefaultBorder() const
1636 {
1637     return wxBORDER_NONE;
1638 }
1639
1640 // ----------------------------------------------------------------------------
1641 // hit testing
1642 // ----------------------------------------------------------------------------
1643
1644 wxHitTest wxWindowBase::DoHitTest(wxCoord x, wxCoord y) const
1645 {
1646     // here we just check if the point is inside the window or not
1647
1648     // check the top and left border first
1649     bool outside = x < 0 || y < 0;
1650     if ( !outside )
1651     {
1652         // check the right and bottom borders too
1653         wxSize size = GetSize();
1654         outside = x >= size.x || y >= size.y;
1655     }
1656
1657     return outside ? wxHT_WINDOW_OUTSIDE : wxHT_WINDOW_INSIDE;
1658 }
1659
1660 // ----------------------------------------------------------------------------
1661 // mouse capture
1662 // ----------------------------------------------------------------------------
1663
1664 struct WXDLLEXPORT wxWindowNext
1665 {
1666     wxWindow *win;
1667     wxWindowNext *next;
1668 } *wxWindowBase::ms_winCaptureNext = NULL;
1669
1670 void wxWindowBase::CaptureMouse()
1671 {
1672     wxLogTrace(_T("mousecapture"), _T("CaptureMouse(0x%08x)"), this);
1673
1674     wxWindow *winOld = GetCapture();
1675     if ( winOld )
1676     {
1677         // save it on stack
1678         wxWindowNext *item = new wxWindowNext;
1679         item->win = winOld;
1680         item->next = ms_winCaptureNext;
1681         ms_winCaptureNext = item;
1682     }
1683     //else: no mouse capture to save
1684
1685     DoCaptureMouse();
1686 }
1687
1688 void wxWindowBase::ReleaseMouse()
1689 {
1690     wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(0x%08x)"), this);
1691
1692     wxASSERT_MSG( GetCapture() == this, wxT("attempt to release mouse, but this window hasn't captured it") )
1693
1694     DoReleaseMouse();
1695
1696     if ( ms_winCaptureNext )
1697     {
1698         ms_winCaptureNext->win->CaptureMouse();
1699
1700         wxWindowNext *item = ms_winCaptureNext;
1701         ms_winCaptureNext = item->next;
1702         delete item;
1703     }
1704     //else: stack is empty, no previous capture
1705
1706     wxLogTrace(_T("mousecapture"),
1707                _T("After ReleaseMouse() mouse is captured by 0x%08x"),
1708                GetCapture());
1709 }
1710