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/checkbox.h"
  39     #include "wx/radiobut.h"
  40     #include "wx/textctrl.h"
  41     #include "wx/settings.h"
  42     #include "wx/dialog.h"
  43 #endif //WX_PRECOMP
  44
  45 #if wxUSE_CONSTRAINTS
  46     #include "wx/layout.h"
  47     #include "wx/sizer.h"
  48 #endif // wxUSE_CONSTRAINTS
  49
  50 #if wxUSE_DRAG_AND_DROP
  51     #include "wx/dnd.h"
  52 #endif // wxUSE_DRAG_AND_DROP
  53
  54 #if wxUSE_TOOLTIPS
  55     #include "wx/tooltip.h"
  56 #endif // wxUSE_TOOLTIPS
  57
  58 #if wxUSE_CARET
  59     #include "wx/caret.h"
  60 #endif // wxUSE_CARET
  61
  62 // ----------------------------------------------------------------------------
  63 // static data
  64 // ----------------------------------------------------------------------------
  65
  66 int wxWindowBase::ms_lastControlId = -200;
  67
  68 IMPLEMENT_ABSTRACT_CLASS(wxWindowBase, wxEvtHandler)
  69
  70 // ----------------------------------------------------------------------------
  71 // event table
  72 // ----------------------------------------------------------------------------
  73
  74 BEGIN_EVENT_TABLE(wxWindowBase, wxEvtHandler)
  75     EVT_SYS_COLOUR_CHANGED(wxWindowBase::OnSysColourChanged)
  76     EVT_INIT_DIALOG(wxWindowBase::OnInitDialog)
  77 END_EVENT_TABLE()
  78
  79 // ============================================================================
  80 // implementation of the common functionality of the wxWindow class
  81 // ============================================================================
  82
  83 // ----------------------------------------------------------------------------
  84 // initialization
  85 // ----------------------------------------------------------------------------
  86
  87 // the default initialization
  88 void wxWindowBase::InitBase()
  89 {
  90     // no window yet, no parent nor children
  91     m_parent = (wxWindow *)NULL;
  92     m_windowId = -1;
  93     m_children.DeleteContents( FALSE ); // don't auto delete node data
  94
  95     // no constraints on the minimal window size
  96     m_minWidth =
  97     m_minHeight =
  98     m_maxWidth =
  99     m_maxHeight = -1;
 100
 101     // window is created enabled but it's not visible yet
 102     m_isShown = FALSE;
 103     m_isEnabled = TRUE;
 104
 105     // no client data (yet)
 106     m_clientData = NULL;
 107     m_clientDataType = ClientData_None;
 108
 109     // the default event handler is just this window
 110     m_eventHandler = this;
 111
 112 #if wxUSE_VALIDATORS
 113     // no validator
 114     m_windowValidator = (wxValidator *) NULL;
 115 #endif // wxUSE_VALIDATORS
 116
 117     // use the system default colours
 118     wxSystemSettings settings;
 119
 120     m_backgroundColour = settings.GetSystemColour(wxSYS_COLOUR_BTNFACE);
 121     // m_foregroundColour = *wxBLACK;  // TODO take this from sys settings too?
 122     m_foregroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOWTEXT);
 123
 124 #if !defined(__WXMAC__) && !defined(__WXGTK__)
 125     m_font = *wxSWISS_FONT;         //      and this?
 126 #else
 127         m_font = settings.GetSystemFont(wxSYS_DEFAULT_GUI_FONT);
 128 #endif
 129     // no style bits
 130     m_windowStyle = 0;
 131
 132     // an optimization for the event processing: checking this flag is much
 133     // faster than using IsKindOf(CLASSINFO(wxWindow))
 134     m_isWindow = TRUE;
 135
 136 #if wxUSE_CONSTRAINTS
 137     // no constraints whatsoever
 138     m_constraints = (wxLayoutConstraints *) NULL;
 139     m_constraintsInvolvedIn = (wxWindowList *) NULL;
 140     m_windowSizer = (wxSizer *) NULL;
 141     m_autoLayout = FALSE;
 142 #endif // wxUSE_CONSTRAINTS
 143
 144 #if wxUSE_DRAG_AND_DROP
 145     m_dropTarget = (wxDropTarget *)NULL;
 146 #endif // wxUSE_DRAG_AND_DROP
 147
 148 #if wxUSE_TOOLTIPS
 149     m_tooltip = (wxToolTip *)NULL;
 150 #endif // wxUSE_TOOLTIPS
 151
 152 #if wxUSE_CARET
 153     m_caret = (wxCaret *)NULL;
 154 #endif // wxUSE_CARET
 155 }
 156
 157 // common part of window creation process
 158 bool wxWindowBase::CreateBase(wxWindowBase *parent,
 159                               wxWindowID id,
 160                               const wxPoint& WXUNUSED(pos),
 161                               const wxSize& WXUNUSED(size),
 162                               long style,
 163                               const wxValidator& validator,
 164                               const wxString& name)
 165 {
 166     // m_isWindow is set to TRUE in wxWindowBase::Init() as well as many other
 167     // member variables - check that it has been called (will catch the case
 168     // when a new ctor is added which doesn't call InitWindow)
 169     wxASSERT_MSG( m_isWindow, wxT("Init() must have been called before!") );
 170
 171     // generate a new id if the user doesn't care about it
 172     m_windowId = id == -1 ? NewControlId() : id;
 173
 174     SetName(name);
 175     SetWindowStyleFlag(style);
 176     SetParent(parent);
 177
 178 #if wxUSE_VALIDATORS
 179     SetValidator(validator);
 180 #endif // wxUSE_VALIDATORS
 181
 182     return TRUE;
 183 }
 184
 185 // ----------------------------------------------------------------------------
 186 // destruction
 187 // ----------------------------------------------------------------------------
 188
 189 // common clean up
 190 wxWindowBase::~wxWindowBase()
 191 {
 192     // FIXME if these 2 cases result from programming errors in the user code
 193     //       we should probably assert here instead of silently fixing them
 194
 195     // Just in case the window has been Closed, but we're then deleting
 196     // immediately: don't leave dangling pointers.
 197     wxPendingDelete.DeleteObject(this);
 198
 199     // Just in case we've loaded a top-level window via LoadNativeDialog but
 200     // we weren't a dialog class
 201     wxTopLevelWindows.DeleteObject(this);
 202
 203     wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
 204
 205     // make sure that there are no dangling pointers left pointing to us
 206     wxPanel *panel = wxDynamicCast(GetParent(), wxPanel);
 207     if ( panel )
 208     {
 209         if ( panel->GetLastFocus() == this )
 210         {
 211             panel->SetLastFocus((wxWindow *)NULL);
 212         }
 213     }
 214
 215 #if wxUSE_CARET
 216     if ( m_caret )
 217         delete m_caret;
 218 #endif // wxUSE_CARET
 219
 220 #if wxUSE_VALIDATORS
 221     if ( m_windowValidator )
 222         delete m_windowValidator;
 223 #endif // wxUSE_VALIDATORS
 224
 225     // we only delete object data, not untyped
 226     if ( m_clientDataType == ClientData_Object )
 227         delete m_clientObject;
 228
 229 #if wxUSE_CONSTRAINTS
 230     // Have to delete constraints/sizer FIRST otherwise sizers may try to look
 231     // at deleted windows as they delete themselves.
 232     DeleteRelatedConstraints();
 233
 234     if ( m_constraints )
 235     {
 236         // This removes any dangling pointers to this window in other windows'
 237         // constraintsInvolvedIn lists.
 238         UnsetConstraints(m_constraints);
 239         delete m_constraints;
 240         m_constraints = NULL;
 241     }
 242
 243     if ( m_windowSizer )
 244         delete m_windowSizer;
 245
 246 #endif // wxUSE_CONSTRAINTS
 247
 248 #if wxUSE_DRAG_AND_DROP
 249     if ( m_dropTarget )
 250         delete m_dropTarget;
 251 #endif // wxUSE_DRAG_AND_DROP
 252
 253 #if wxUSE_TOOLTIPS
 254     if ( m_tooltip )
 255         delete m_tooltip;
 256 #endif // wxUSE_TOOLTIPS
 257 }
 258
 259 bool wxWindowBase::Destroy()
 260 {
 261     delete this;
 262
 263     return TRUE;
 264 }
 265
 266 bool wxWindowBase::Close(bool force)
 267 {
 268     wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
 269     event.SetEventObject(this);
 270 #if WXWIN_COMPATIBILITY
 271     event.SetForce(force);
 272 #endif // WXWIN_COMPATIBILITY
 273     event.SetCanVeto(!force);
 274
 275     // return FALSE if window wasn't closed because the application vetoed the
 276     // close event
 277     return GetEventHandler()->ProcessEvent(event) && !event.GetVeto();
 278 }
 279
 280 bool wxWindowBase::DestroyChildren()
 281 {
 282     wxWindowList::Node *node;
 283     for ( ;; )
 284     {
 285         // we iterate until the list becomes empty
 286         node = GetChildren().GetFirst();
 287         if ( !node )
 288             break;
 289
 290         wxWindow *child = node->GetData();
 291
 292         wxASSERT_MSG( child, wxT("children list contains empty nodes") );
 293
 294         delete child;
 295
 296         wxASSERT_MSG( !GetChildren().Find(child),
 297                       wxT("child didn't remove itself using RemoveChild()") );
 298     }
 299
 300     return TRUE;
 301 }
 302
 303 // ----------------------------------------------------------------------------
 304 // size/position related methods
 305 // ----------------------------------------------------------------------------
 306
 307 // centre the window with respect to its parent in either (or both) directions
 308 void wxWindowBase::Centre(int direction)
 309 {
 310     int widthParent, heightParent;
 311
 312     wxWindow *parent = GetParent();
 313     if ( !parent )
 314     {
 315         // no other choice
 316         direction |= wxCENTRE_ON_SCREEN;
 317     }
 318
 319     if ( direction & wxCENTRE_ON_SCREEN )
 320     {
 321         // centre with respect to the whole screen
 322         wxDisplaySize(&widthParent, &heightParent);
 323     }
 324     else
 325     {
 326         // centre inside the parents rectangle
 327         parent->GetClientSize(&widthParent, &heightParent);
 328     }
 329
 330     int width, height;
 331     GetSize(&width, &height);
 332
 333     int xNew = -1,
 334         yNew = -1;
 335
 336     if ( direction & wxHORIZONTAL )
 337         xNew = (widthParent - width)/2;
 338
 339     if ( direction & wxVERTICAL )
 340         yNew = (heightParent - height)/2;
 341
 342     // controls are always centered on their parent because it doesn't make
 343     // sense to centre them on the screen
 344     if ( !(direction & wxCENTRE_ON_SCREEN) || wxDynamicCast(this, wxControl) )
 345     {
 346         // theo nly chance to get this is to have a wxControl without parent
 347         wxCHECK_RET( parent, wxT("a control must have a parent") );
 348
 349         // adjust to the parents client area origin
 350         wxPoint posParent = parent->ClientToScreen(wxPoint(0, 0));
 351
 352         xNew += posParent.x;
 353         yNew += posParent.y;
 354     }
 355
 356     // move the centre of this window to this position
 357     Move(xNew, yNew);
 358 }
 359
 360 // fits the window around the children
 361 void wxWindowBase::Fit()
 362 {
 363     if ( GetChildren().GetCount() > 0 )
 364     {
 365         SetClientSize(DoGetBestSize());
 366     }
 367     //else: do nothing if we have no children
 368 }
 369
 370 // return the size best suited for the current window
 371 wxSize wxWindowBase::DoGetBestSize() const
 372 {
 373     if ( GetChildren().GetCount() > 0 )
 374     {
 375         // our minimal acceptable size is such that all our windows fit inside
 376         int maxX = 0,
 377             maxY = 0;
 378
 379         for ( wxWindowList::Node *node = GetChildren().GetFirst();
 380               node;
 381               node = node->GetNext() )
 382         {
 383             wxWindow *win = node->GetData();
 384             if ( win->IsTopLevel() )
 385             {
 386                 // dialogs and frames lie in different top level windows -
 387                 // don't deal with them here
 388                 continue;
 389             }
 390
 391             int wx, wy, ww, wh;
 392             win->GetPosition(&wx, &wy);
 393             win->GetSize(&ww, &wh);
 394             if ( wx + ww > maxX )
 395                 maxX = wx + ww;
 396             if ( wy + wh > maxY )
 397                 maxY = wy + wh;
 398         }
 399
 400         // leave a margin
 401         return wxSize(maxX + 7, maxY + 14);
 402     }
 403     else
 404     {
 405         // for a generic window there is no natural best size - just use the
 406         // current one
 407         return GetSize();
 408     }
 409 }
 410
 411 // set the min/max size of the window
 412 void wxWindowBase::SetSizeHints(int minW, int minH,
 413                                 int maxW, int maxH,
 414                                 int WXUNUSED(incW), int WXUNUSED(incH))
 415 {
 416     m_minWidth = minW;
 417     m_maxWidth = maxW;
 418     m_minHeight = minH;
 419     m_maxHeight = maxH;
 420 }
 421
 422 // ----------------------------------------------------------------------------
 423 // show/hide/enable/disable the window
 424 // ----------------------------------------------------------------------------
 425
 426 bool wxWindowBase::Show(bool show)
 427 {
 428     if ( show != m_isShown )
 429     {
 430         m_isShown = show;
 431
 432         return TRUE;
 433     }
 434     else
 435     {
 436         return FALSE;
 437     }
 438 }
 439
 440 bool wxWindowBase::Enable(bool enable)
 441 {
 442     if ( enable != m_isEnabled )
 443     {
 444         m_isEnabled = enable;
 445
 446         return TRUE;
 447     }
 448     else
 449     {
 450         return FALSE;
 451     }
 452 }
 453 // ----------------------------------------------------------------------------
 454 // RTTI
 455 // ----------------------------------------------------------------------------
 456
 457 bool wxWindowBase::IsTopLevel() const
 458 {
 459     return FALSE;
 460 }
 461
 462 // ----------------------------------------------------------------------------
 463 // reparenting the window
 464 // ----------------------------------------------------------------------------
 465
 466 void wxWindowBase::AddChild(wxWindowBase *child)
 467 {
 468     wxCHECK_RET( child, wxT("can't add a NULL child") );
 469
 470     GetChildren().Append(child);
 471     child->SetParent(this);
 472 }
 473
 474 void wxWindowBase::RemoveChild(wxWindowBase *child)
 475 {
 476     wxCHECK_RET( child, wxT("can't remove a NULL child") );
 477
 478     GetChildren().DeleteObject(child);
 479     child->SetParent((wxWindow *)NULL);
 480 }
 481
 482 bool wxWindowBase::Reparent(wxWindowBase *newParent)
 483 {
 484     wxWindow *oldParent = GetParent();
 485     if ( newParent == oldParent )
 486     {
 487         // nothing done
 488         return FALSE;
 489     }
 490
 491     // unlink this window from the existing parent.
 492     if ( oldParent )
 493     {
 494         oldParent->RemoveChild(this);
 495     }
 496     else
 497     {
 498         wxTopLevelWindows.DeleteObject(this);
 499     }
 500
 501     // add it to the new one
 502     if ( newParent )
 503     {
 504         newParent->AddChild(this);
 505     }
 506     else
 507     {
 508         wxTopLevelWindows.Append(this);
 509     }
 510
 511     return TRUE;
 512 }
 513
 514 // ----------------------------------------------------------------------------
 515 // event handler stuff
 516 // ----------------------------------------------------------------------------
 517
 518 void wxWindowBase::PushEventHandler(wxEvtHandler *handler)
 519 {
 520     handler->SetNextHandler(GetEventHandler());
 521     SetEventHandler(handler);
 522 }
 523
 524 wxEvtHandler *wxWindowBase::PopEventHandler(bool deleteHandler)
 525 {
 526     wxEvtHandler *handlerA = GetEventHandler();
 527     if ( handlerA )
 528     {
 529         wxEvtHandler *handlerB = handlerA->GetNextHandler();
 530         handlerA->SetNextHandler((wxEvtHandler *)NULL);
 531         SetEventHandler(handlerB);
 532         if ( deleteHandler )
 533         {
 534             delete handlerA;
 535             handlerA = (wxEvtHandler *)NULL;
 536         }
 537     }
 538
 539     return handlerA;
 540 }
 541
 542 // ----------------------------------------------------------------------------
 543 // cursors, fonts &c
 544 // ----------------------------------------------------------------------------
 545
 546 bool wxWindowBase::SetBackgroundColour( const wxColour &colour )
 547 {
 548     if ( !colour.Ok() || (colour == m_backgroundColour) )
 549         return FALSE;
 550
 551     m_backgroundColour = colour;
 552
 553     return TRUE;
 554 }
 555
 556 bool wxWindowBase::SetForegroundColour( const wxColour &colour )
 557 {
 558     if ( !colour.Ok() || (colour == m_foregroundColour) )
 559         return FALSE;
 560
 561     m_foregroundColour = colour;
 562
 563     return TRUE;
 564 }
 565
 566 bool wxWindowBase::SetCursor(const wxCursor& cursor)
 567 {
 568     // don't try to set invalid cursor, always fall back to the default
 569     const wxCursor& cursorOk = cursor.Ok() ? cursor : *wxSTANDARD_CURSOR;
 570
 571     if ( (wxCursor&)cursorOk == m_cursor )
 572     {
 573         // no change
 574         return FALSE;
 575     }
 576
 577     m_cursor = cursorOk;
 578
 579     return TRUE;
 580 }
 581
 582 bool wxWindowBase::SetFont(const wxFont& font)
 583 {
 584     // don't try to set invalid font, always fall back to the default
 585     const wxFont& fontOk = font.Ok() ? font : *wxSWISS_FONT;
 586
 587     if ( (wxFont&)fontOk == m_font )
 588     {
 589         // no change
 590         return FALSE;
 591     }
 592
 593     m_font = fontOk;
 594
 595     return TRUE;
 596 }
 597
 598 #if wxUSE_CARET
 599 void wxWindowBase::SetCaret(wxCaret *caret)
 600 {
 601     if ( m_caret )
 602     {
 603         delete m_caret;
 604     }
 605
 606     m_caret = caret;
 607
 608     if ( m_caret )
 609     {
 610         wxASSERT_MSG( m_caret->GetWindow() == this,
 611                       wxT("caret should be created associated to this window") );
 612     }
 613 }
 614 #endif // wxUSE_CARET
 615
 616 #if wxUSE_VALIDATORS
 617 // ----------------------------------------------------------------------------
 618 // validators
 619 // ----------------------------------------------------------------------------
 620
 621 void wxWindowBase::SetValidator(const wxValidator& validator)
 622 {
 623     if ( m_windowValidator )
 624         delete m_windowValidator;
 625
 626     m_windowValidator = (wxValidator *)validator.Clone();
 627
 628     if ( m_windowValidator )
 629         m_windowValidator->SetWindow(this) ;
 630 }
 631 #endif // wxUSE_VALIDATORS
 632
 633 // ----------------------------------------------------------------------------
 634 // update region testing
 635 // ----------------------------------------------------------------------------
 636
 637 bool wxWindowBase::IsExposed(int x, int y) const
 638 {
 639     return m_updateRegion.Contains(x, y) != wxOutRegion;
 640 }
 641
 642 bool wxWindowBase::IsExposed(int x, int y, int w, int h) const
 643 {
 644     return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
 645 }
 646
 647 // ----------------------------------------------------------------------------
 648 // find window by id or name
 649 // ----------------------------------------------------------------------------
 650
 651 wxWindow *wxWindowBase::FindWindow( long id )
 652 {
 653     if ( id == m_windowId )
 654         return (wxWindow *)this;
 655
 656     wxWindowBase *res = (wxWindow *)NULL;
 657     wxWindowList::Node *node;
 658     for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
 659     {
 660         wxWindowBase *child = node->GetData();
 661         res = child->FindWindow( id );
 662     }
 663
 664     return (wxWindow *)res;
 665 }
 666
 667 wxWindow *wxWindowBase::FindWindow( const wxString& name )
 668 {
 669     if ( name == m_windowName )
 670         return (wxWindow *)this;
 671
 672     wxWindowBase *res = (wxWindow *)NULL;
 673     wxWindowList::Node *node;
 674     for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
 675     {
 676         wxWindow *child = node->GetData();
 677         res = child->FindWindow(name);
 678     }
 679
 680     return (wxWindow *)res;
 681 }
 682
 683 // ----------------------------------------------------------------------------
 684 // dialog oriented functions
 685 // ----------------------------------------------------------------------------
 686
 687 void wxWindowBase::MakeModal(bool modal)
 688 {
 689     // Disable all other windows
 690     if ( IsTopLevel() )
 691     {
 692         wxWindowList::Node *node = wxTopLevelWindows.GetFirst();
 693         while (node)
 694         {
 695             wxWindow *win = node->GetData();
 696             if (win != this)
 697                 win->Enable(!modal);
 698
 699             node = node->GetNext();
 700         }
 701     }
 702 }
 703
 704 bool wxWindowBase::Validate()
 705 {
 706 #if wxUSE_VALIDATORS
 707     wxWindowList::Node *node;
 708     for ( node = m_children.GetFirst(); node; node = node->GetNext() )
 709     {
 710         wxWindowBase *child = node->GetData();
 711         wxValidator *validator = child->GetValidator();
 712         if ( validator && !validator->Validate((wxWindow *)this) )
 713         {
 714             return FALSE;
 715         }
 716     }
 717 #endif // wxUSE_VALIDATORS
 718
 719     return TRUE;
 720 }
 721
 722 bool wxWindowBase::TransferDataToWindow()
 723 {
 724 #if wxUSE_VALIDATORS
 725     wxWindowList::Node *node;
 726     for ( node = m_children.GetFirst(); node; node = node->GetNext() )
 727     {
 728         wxWindowBase *child = node->GetData();
 729         wxValidator *validator = child->GetValidator();
 730         if ( validator && !validator->TransferToWindow() )
 731         {
 732             wxLog *log = wxLog::GetActiveTarget();
 733             if ( log )
 734             {
 735                 wxLogWarning(_("Could not transfer data to window"));
 736                 log->Flush();
 737             }
 738
 739             return FALSE;
 740         }
 741     }
 742 #endif // wxUSE_VALIDATORS
 743
 744     return TRUE;
 745 }
 746
 747 bool wxWindowBase::TransferDataFromWindow()
 748 {
 749 #if wxUSE_VALIDATORS
 750     wxWindowList::Node *node;
 751     for ( node = m_children.GetFirst(); node; node = node->GetNext() )
 752     {
 753         wxWindow *child = node->GetData();
 754         if ( child->GetValidator() &&
 755              !child->GetValidator()->TransferFromWindow() )
 756         {
 757             return FALSE;
 758         }
 759     }
 760 #endif // wxUSE_VALIDATORS
 761
 762     return TRUE;
 763 }
 764
 765 void wxWindowBase::InitDialog()
 766 {
 767     wxInitDialogEvent event(GetId());
 768     event.SetEventObject( this );
 769     GetEventHandler()->ProcessEvent(event);
 770 }
 771
 772 // ----------------------------------------------------------------------------
 773 // tooltips
 774 // ----------------------------------------------------------------------------
 775
 776 #if wxUSE_TOOLTIPS
 777
 778 void wxWindowBase::SetToolTip( const wxString &tip )
 779 {
 780     // don't create the new tooltip if we already have one
 781     if ( m_tooltip )
 782     {
 783         m_tooltip->SetTip( tip );
 784     }
 785     else
 786     {
 787         SetToolTip( new wxToolTip( tip ) );
 788     }
 789
 790     // setting empty tooltip text does not remove the tooltip any more - use
 791     // SetToolTip((wxToolTip *)NULL) for this
 792 }
 793
 794 void wxWindowBase::DoSetToolTip(wxToolTip *tooltip)
 795 {
 796     if ( m_tooltip )
 797         delete m_tooltip;
 798
 799     m_tooltip = tooltip;
 800 }
 801
 802 #endif // wxUSE_TOOLTIPS
 803
 804 // ----------------------------------------------------------------------------
 805 // constraints and sizers
 806 // ----------------------------------------------------------------------------
 807
 808 #if wxUSE_CONSTRAINTS
 809
 810 void wxWindowBase::SetConstraints( wxLayoutConstraints *constraints )
 811 {
 812     if ( m_constraints )
 813     {
 814         UnsetConstraints(m_constraints);
 815         delete m_constraints;
 816     }
 817     m_constraints = constraints;
 818     if ( m_constraints )
 819     {
 820         // Make sure other windows know they're part of a 'meaningful relationship'
 821         if ( m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this) )
 822             m_constraints->left.GetOtherWindow()->AddConstraintReference(this);
 823         if ( m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this) )
 824             m_constraints->top.GetOtherWindow()->AddConstraintReference(this);
 825         if ( m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this) )
 826             m_constraints->right.GetOtherWindow()->AddConstraintReference(this);
 827         if ( m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this) )
 828             m_constraints->bottom.GetOtherWindow()->AddConstraintReference(this);
 829         if ( m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this) )
 830             m_constraints->width.GetOtherWindow()->AddConstraintReference(this);
 831         if ( m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this) )
 832             m_constraints->height.GetOtherWindow()->AddConstraintReference(this);
 833         if ( m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this) )
 834             m_constraints->centreX.GetOtherWindow()->AddConstraintReference(this);
 835         if ( m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this) )
 836             m_constraints->centreY.GetOtherWindow()->AddConstraintReference(this);
 837     }
 838 }
 839
 840 // This removes any dangling pointers to this window in other windows'
 841 // constraintsInvolvedIn lists.
 842 void wxWindowBase::UnsetConstraints(wxLayoutConstraints *c)
 843 {
 844     if ( c )
 845     {
 846         if ( c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
 847             c->left.GetOtherWindow()->RemoveConstraintReference(this);
 848         if ( c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
 849             c->top.GetOtherWindow()->RemoveConstraintReference(this);
 850         if ( c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this) )
 851             c->right.GetOtherWindow()->RemoveConstraintReference(this);
 852         if ( c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this) )
 853             c->bottom.GetOtherWindow()->RemoveConstraintReference(this);
 854         if ( c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this) )
 855             c->width.GetOtherWindow()->RemoveConstraintReference(this);
 856         if ( c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this) )
 857             c->height.GetOtherWindow()->RemoveConstraintReference(this);
 858         if ( c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this) )
 859             c->centreX.GetOtherWindow()->RemoveConstraintReference(this);
 860         if ( c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this) )
 861             c->centreY.GetOtherWindow()->RemoveConstraintReference(this);
 862     }
 863 }
 864
 865 // Back-pointer to other windows we're involved with, so if we delete this
 866 // window, we must delete any constraints we're involved with.
 867 void wxWindowBase::AddConstraintReference(wxWindowBase *otherWin)
 868 {
 869     if ( !m_constraintsInvolvedIn )
 870         m_constraintsInvolvedIn = new wxWindowList;
 871     if ( !m_constraintsInvolvedIn->Find(otherWin) )
 872         m_constraintsInvolvedIn->Append(otherWin);
 873 }
 874
 875 // REMOVE back-pointer to other windows we're involved with.
 876 void wxWindowBase::RemoveConstraintReference(wxWindowBase *otherWin)
 877 {
 878     if ( m_constraintsInvolvedIn )
 879         m_constraintsInvolvedIn->DeleteObject(otherWin);
 880 }
 881
 882 // Reset any constraints that mention this window
 883 void wxWindowBase::DeleteRelatedConstraints()
 884 {
 885     if ( m_constraintsInvolvedIn )
 886     {
 887         wxWindowList::Node *node = m_constraintsInvolvedIn->GetFirst();
 888         while (node)
 889         {
 890             wxWindow *win = node->GetData();
 891             wxLayoutConstraints *constr = win->GetConstraints();
 892
 893             // Reset any constraints involving this window
 894             if ( constr )
 895             {
 896                 constr->left.ResetIfWin(this);
 897                 constr->top.ResetIfWin(this);
 898                 constr->right.ResetIfWin(this);
 899                 constr->bottom.ResetIfWin(this);
 900                 constr->width.ResetIfWin(this);
 901                 constr->height.ResetIfWin(this);
 902                 constr->centreX.ResetIfWin(this);
 903                 constr->centreY.ResetIfWin(this);
 904             }
 905
 906             wxWindowList::Node *next = node->GetNext();
 907             delete node;
 908             node = next;
 909         }
 910
 911         delete m_constraintsInvolvedIn;
 912         m_constraintsInvolvedIn = (wxWindowList *) NULL;
 913     }
 914 }
 915
 916 void wxWindowBase::SetSizer(wxSizer *sizer)
 917 {
 918     if (m_windowSizer) delete m_windowSizer;
 919
 920     m_windowSizer = sizer;
 921 }
 922
 923 bool wxWindowBase::Layout()
 924 {
 925     int w, h;
 926     GetClientSize(&w, &h);
 927
 928     // If there is a sizer, use it instead of the constraints
 929     if ( GetSizer() )
 930     {
 931         GetSizer()->SetDimension( 0, 0, w, h );
 932         return TRUE;
 933     }
 934
 935     if ( GetConstraints() )
 936     {
 937         GetConstraints()->width.SetValue(w);
 938         GetConstraints()->height.SetValue(h);
 939     }
 940
 941     // Evaluate child constraints
 942     ResetConstraints();   // Mark all constraints as unevaluated
 943     DoPhase(1);           // Just one phase need if no sizers involved
 944     DoPhase(2);
 945     SetConstraintSizes(); // Recursively set the real window sizes
 946
 947     return TRUE;
 948 }
 949
 950
 951 // Do a phase of evaluating constraints: the default behaviour. wxSizers may
 952 // do a similar thing, but also impose their own 'constraints' and order the
 953 // evaluation differently.
 954 bool wxWindowBase::LayoutPhase1(int *noChanges)
 955 {
 956     wxLayoutConstraints *constr = GetConstraints();
 957     if ( constr )
 958     {
 959         return constr->SatisfyConstraints(this, noChanges);
 960     }
 961     else
 962         return TRUE;
 963 }
 964
 965 bool wxWindowBase::LayoutPhase2(int *noChanges)
 966 {
 967     *noChanges = 0;
 968
 969     // Layout children
 970     DoPhase(1);
 971     DoPhase(2);
 972     return TRUE;
 973 }
 974
 975 // Do a phase of evaluating child constraints
 976 bool wxWindowBase::DoPhase(int phase)
 977 {
 978     int noIterations = 0;
 979     int maxIterations = 500;
 980     int noChanges = 1;
 981     int noFailures = 0;
 982     wxWindowList succeeded;
 983     while ((noChanges > 0) && (noIterations < maxIterations))
 984     {
 985         noChanges = 0;
 986         noFailures = 0;
 987         wxWindowList::Node *node = GetChildren().GetFirst();
 988         while (node)
 989         {
 990             wxWindow *child = node->GetData();
 991             if ( !child->IsTopLevel() )
 992             {
 993                 wxLayoutConstraints *constr = child->GetConstraints();
 994                 if ( constr )
 995                 {
 996                     if ( !succeeded.Find(child) )
 997                     {
 998                         int tempNoChanges = 0;
 999                         bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
1000                         noChanges += tempNoChanges;
1001                         if ( success )
1002                         {
1003                             succeeded.Append(child);
1004                         }
1005                     }
1006                 }
1007             }
1008             node = node->GetNext();
1009         }
1010
1011         noIterations++;
1012     }
1013
1014     return TRUE;
1015 }
1016
1017 void wxWindowBase::ResetConstraints()
1018 {
1019     wxLayoutConstraints *constr = GetConstraints();
1020     if ( constr )
1021     {
1022         constr->left.SetDone(FALSE);
1023         constr->top.SetDone(FALSE);
1024         constr->right.SetDone(FALSE);
1025         constr->bottom.SetDone(FALSE);
1026         constr->width.SetDone(FALSE);
1027         constr->height.SetDone(FALSE);
1028         constr->centreX.SetDone(FALSE);
1029         constr->centreY.SetDone(FALSE);
1030     }
1031     wxWindowList::Node *node = GetChildren().GetFirst();
1032     while (node)
1033     {
1034         wxWindow *win = node->GetData();
1035         if ( !win->IsTopLevel() )
1036             win->ResetConstraints();
1037         node = node->GetNext();
1038     }
1039 }
1040
1041 // Need to distinguish between setting the 'fake' size for windows and sizers,
1042 // and setting the real values.
1043 void wxWindowBase::SetConstraintSizes(bool recurse)
1044 {
1045     wxLayoutConstraints *constr = GetConstraints();
1046     if ( constr && constr->left.GetDone() && constr->right.GetDone( ) &&
1047             constr->width.GetDone() && constr->height.GetDone())
1048     {
1049         int x = constr->left.GetValue();
1050         int y = constr->top.GetValue();
1051         int w = constr->width.GetValue();
1052         int h = constr->height.GetValue();
1053
1054         if ( (constr->width.GetRelationship() != wxAsIs ) ||
1055              (constr->height.GetRelationship() != wxAsIs) )
1056         {
1057             SetSize(x, y, w, h);
1058         }
1059         else
1060         {
1061             // If we don't want to resize this window, just move it...
1062             Move(x, y);
1063         }
1064     }
1065     else if ( constr )
1066     {
1067         wxChar *windowClass = GetClassInfo()->GetClassName();
1068
1069         wxString winName;
1070         if ( GetName() == wxT("") )
1071             winName = wxT("unnamed");
1072         else
1073             winName = GetName();
1074         wxLogDebug( wxT("Constraint(s) not satisfied for window of type %s, name %s:\n"),
1075                 (const wxChar *)windowClass,
1076                 (const wxChar *)winName);
1077         if ( !constr->left.GetDone()) wxLogDebug( wxT("  unsatisfied 'left' constraint.\n")  );
1078         if ( !constr->right.GetDone()) wxLogDebug( wxT("  unsatisfied 'right' constraint.\n")  );
1079         if ( !constr->width.GetDone()) wxLogDebug( wxT("  unsatisfied 'width' constraint.\n")  );
1080         if ( !constr->height.GetDone())  wxLogDebug( wxT("  unsatisfied 'height' constraint.\n")  );
1081         wxLogDebug( wxT("Please check constraints: try adding AsIs() constraints.\n") );
1082     }
1083
1084     if ( recurse )
1085     {
1086         wxWindowList::Node *node = GetChildren().GetFirst();
1087         while (node)
1088         {
1089             wxWindow *win = node->GetData();
1090             if ( !win->IsTopLevel() )
1091                 win->SetConstraintSizes();
1092             node = node->GetNext();
1093         }
1094     }
1095 }
1096
1097 // Only set the size/position of the constraint (if any)
1098 void wxWindowBase::SetSizeConstraint(int x, int y, int w, int h)
1099 {
1100     wxLayoutConstraints *constr = GetConstraints();
1101     if ( constr )
1102     {
1103         if ( x != -1 )
1104         {
1105             constr->left.SetValue(x);
1106             constr->left.SetDone(TRUE);
1107         }
1108         if ( y != -1 )
1109         {
1110             constr->top.SetValue(y);
1111             constr->top.SetDone(TRUE);
1112         }
1113         if ( w != -1 )
1114         {
1115             constr->width.SetValue(w);
1116             constr->width.SetDone(TRUE);
1117         }
1118         if ( h != -1 )
1119         {
1120             constr->height.SetValue(h);
1121             constr->height.SetDone(TRUE);
1122         }
1123     }
1124 }
1125
1126 void wxWindowBase::MoveConstraint(int x, int y)
1127 {
1128     wxLayoutConstraints *constr = GetConstraints();
1129     if ( constr )
1130     {
1131         if ( x != -1 )
1132         {
1133             constr->left.SetValue(x);
1134             constr->left.SetDone(TRUE);
1135         }
1136         if ( y != -1 )
1137         {
1138             constr->top.SetValue(y);
1139             constr->top.SetDone(TRUE);
1140         }
1141     }
1142 }
1143
1144 void wxWindowBase::GetSizeConstraint(int *w, int *h) const
1145 {
1146     wxLayoutConstraints *constr = GetConstraints();
1147     if ( constr )
1148     {
1149         *w = constr->width.GetValue();
1150         *h = constr->height.GetValue();
1151     }
1152     else
1153         GetSize(w, h);
1154 }
1155
1156 void wxWindowBase::GetClientSizeConstraint(int *w, int *h) const
1157 {
1158     wxLayoutConstraints *constr = GetConstraints();
1159     if ( constr )
1160     {
1161         *w = constr->width.GetValue();
1162         *h = constr->height.GetValue();
1163     }
1164     else
1165         GetClientSize(w, h);
1166 }
1167
1168 void wxWindowBase::GetPositionConstraint(int *x, int *y) const
1169 {
1170     wxLayoutConstraints *constr = GetConstraints();
1171     if ( constr )
1172     {
1173         *x = constr->left.GetValue();
1174         *y = constr->top.GetValue();
1175     }
1176     else
1177         GetPosition(x, y);
1178 }
1179
1180 #endif // wxUSE_CONSTRAINTS
1181
1182 // ----------------------------------------------------------------------------
1183 // do Update UI processing for child controls
1184 // ----------------------------------------------------------------------------
1185
1186 // TODO: should this be implemented for the child window rather
1187 // than the parent? Then you can override it e.g. for wxCheckBox
1188 // to do the Right Thing rather than having to assume a fixed number
1189 // of control classes.
1190 void wxWindowBase::UpdateWindowUI()
1191 {
1192     wxUpdateUIEvent event(GetId());
1193     event.m_eventObject = this;
1194
1195     if ( GetEventHandler()->ProcessEvent(event) )
1196     {
1197         if ( event.GetSetEnabled() )
1198             Enable(event.GetEnabled());
1199
1200         if ( event.GetSetText() )
1201         {
1202             wxControl *control = wxDynamicCast(this, wxControl);
1203             if ( control )
1204             {
1205                 wxTextCtrl *text = wxDynamicCast(control, wxTextCtrl);
1206                 if ( text )
1207                     text->SetValue(event.GetText());
1208                 else
1209                     control->SetLabel(event.GetText());
1210             }
1211         }
1212
1213 #if wxUSE_CHECKBOX
1214         wxCheckBox *checkbox = wxDynamicCast(this, wxCheckBox);
1215         if ( checkbox )
1216         {
1217             if ( event.GetSetChecked() )
1218                 checkbox->SetValue(event.GetChecked());
1219         }
1220 #endif // wxUSE_CHECKBOX
1221
1222 #if wxUSE_RADIOBTN
1223         wxRadioButton *radiobtn = wxDynamicCast(this, wxRadioButton);
1224         if ( radiobtn )
1225         {
1226             if ( event.GetSetChecked() )
1227                 radiobtn->SetValue(event.GetChecked());
1228         }
1229 #endif // wxUSE_RADIOBTN
1230     }
1231 }
1232
1233 // ----------------------------------------------------------------------------
1234 // dialog units translations
1235 // ----------------------------------------------------------------------------
1236
1237 wxPoint wxWindowBase::ConvertPixelsToDialog(const wxPoint& pt)
1238 {
1239     int charWidth = GetCharWidth();
1240     int charHeight = GetCharHeight();
1241     wxPoint pt2(-1, -1);
1242     if (pt.x != -1)
1243         pt2.x = (int) ((pt.x * 4) / charWidth) ;
1244     if (pt.y != -1)
1245         pt2.y = (int) ((pt.y * 8) / charHeight) ;
1246
1247     return pt2;
1248 }
1249
1250 wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt)
1251 {
1252     int charWidth = GetCharWidth();
1253     int charHeight = GetCharHeight();
1254     wxPoint pt2(-1, -1);
1255     if (pt.x != -1)
1256         pt2.x = (int) ((pt.x * charWidth) / 4) ;
1257     if (pt.y != -1)
1258         pt2.y = (int) ((pt.y * charHeight) / 8) ;
1259
1260     return pt2;
1261 }
1262
1263 // ----------------------------------------------------------------------------
1264 // client data
1265 // ----------------------------------------------------------------------------
1266
1267 void wxWindowBase::DoSetClientObject( wxClientData *data )
1268 {
1269     wxASSERT_MSG( m_clientDataType != ClientData_Void,
1270                   wxT("can't have both object and void client data") );
1271
1272     if ( m_clientObject )
1273         delete m_clientObject;
1274
1275     m_clientObject = data;
1276     m_clientDataType = ClientData_Object;
1277 }
1278
1279 wxClientData *wxWindowBase::DoGetClientObject() const
1280 {
1281     // it's not an error to call GetClientObject() on a window which doesn't
1282     // have client data at all - NULL will be returned
1283     wxASSERT_MSG( m_clientDataType != ClientData_Void,
1284                   wxT("this window doesn't have object client data") );
1285
1286     return m_clientObject;
1287 }
1288
1289 void wxWindowBase::DoSetClientData( void *data )
1290 {
1291     wxASSERT_MSG( m_clientDataType != ClientData_Object,
1292                   wxT("can't have both object and void client data") );
1293
1294     m_clientData = data;
1295     m_clientDataType = ClientData_Void;
1296 }
1297
1298 void *wxWindowBase::DoGetClientData() const
1299 {
1300     // it's not an error to call GetClientData() on a window which doesn't have
1301     // client data at all - NULL will be returned
1302     wxASSERT_MSG( m_clientDataType != ClientData_Object,
1303                   wxT("this window doesn't have void client data") );
1304
1305     return m_clientData;
1306 }
1307
1308 // ----------------------------------------------------------------------------
1309 // event handlers
1310 // ----------------------------------------------------------------------------
1311
1312 // propagate the colour change event to the subwindows
1313 void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event)
1314 {
1315     wxWindowList::Node *node = GetChildren().GetFirst();
1316     while ( node )
1317     {
1318         // Only propagate to non-top-level windows
1319         wxWindow *win = node->GetData();
1320         if ( !win->IsTopLevel() )
1321         {
1322             wxSysColourChangedEvent event2;
1323             event.m_eventObject = win;
1324             win->GetEventHandler()->ProcessEvent(event2);
1325         }
1326
1327         node = node->GetNext();
1328     }
1329 }
1330
1331 // the default action is to populate dialog with data when it's created
1332 void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
1333 {
1334     TransferDataToWindow();
1335 }
1336
1337 // ----------------------------------------------------------------------------
1338 // list classes implementation
1339 // ----------------------------------------------------------------------------
1340
1341 void wxWindowListNode::DeleteData()
1342 {
1343     delete (wxWindow *)GetData();
1344 }
1345