src/stubs/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        windows.cpp
   3 // Purpose:     wxWindow
   4 // Author:      AUTHOR
   5 // Modified by:
   6 // Created:     ??/??/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) AUTHOR
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "window.h"
  14 #endif
  15
  16 #include "wx/setup.h"
  17 #include "wx/menu.h"
  18 #include "wx/dc.h"
  19 #include "wx/dcclient.h"
  20 #include "wx/utils.h"
  21 #include "wx/app.h"
  22 #include "wx/panel.h"
  23 #include "wx/layout.h"
  24 #include "wx/dialog.h"
  25 #include "wx/listbox.h"
  26 #include "wx/button.h"
  27 #include "wx/settings.h"
  28 #include "wx/msgdlg.h"
  29
  30 #include "wx/menuitem.h"
  31 #include "wx/log.h"
  32
  33 #if  USE_DRAG_AND_DROP
  34 #include "wx/dnd.h"
  35 #endif
  36
  37 #include <string.h>
  38
  39 extern wxList wxPendingDelete;
  40
  41 #if !USE_SHARED_LIBRARY
  42 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxEvtHandler)
  43
  44 BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
  45   EVT_CHAR(wxWindow::OnChar)
  46   EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
  47   EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
  48   EVT_INIT_DIALOG(wxWindow::OnInitDialog)
  49   EVT_IDLE(wxWindow::OnIdle)
  50 END_EVENT_TABLE()
  51
  52 #endif
  53
  54
  55 // Constructor
  56 wxWindow::wxWindow()
  57 {
  58     // Generic
  59     m_windowId = 0;
  60     m_windowStyle = 0;
  61     m_windowParent = NULL;
  62     m_windowEventHandler = this;
  63     m_windowName = "";
  64     m_windowCursor = *wxSTANDARD_CURSOR;
  65     m_children = new wxList;
  66     m_constraints = NULL;
  67     m_constraintsInvolvedIn = NULL;
  68     m_windowSizer = NULL;
  69     m_sizerParent = NULL;
  70     m_autoLayout = FALSE;
  71     m_windowValidator = NULL;
  72     m_defaultItem = NULL;
  73     m_returnCode = 0;
  74     m_caretWidth = 0; m_caretHeight = 0;
  75     m_caretEnabled = FALSE;
  76     m_caretShown = FALSE;
  77     m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
  78     m_foregroundColour = *wxBLACK;
  79     m_defaultForegroundColour = *wxBLACK ;
  80     m_defaultBackgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;
  81
  82 #if  USE_DRAG_AND_DROP
  83     m_pDropTarget = NULL;
  84 #endif
  85 }
  86
  87 // Destructor
  88 wxWindow::~wxWindow()
  89 {
  90         // Have to delete constraints/sizer FIRST otherwise
  91         // sizers may try to look at deleted windows as they
  92         // delete themselves.
  93 #if USE_CONSTRAINTS
  94     DeleteRelatedConstraints();
  95     if (m_constraints)
  96     {
  97         // This removes any dangling pointers to this window
  98         // in other windows' constraintsInvolvedIn lists.
  99         UnsetConstraints(m_constraints);
 100         delete m_constraints;
 101         m_constraints = NULL;
 102     }
 103     if (m_windowSizer)
 104     {
 105         delete m_windowSizer;
 106         m_windowSizer = NULL;
 107     }
 108     // If this is a child of a sizer, remove self from parent
 109     if (m_sizerParent)
 110         m_sizerParent->RemoveChild((wxWindow *)this);
 111 #endif
 112
 113     if (m_windowParent)
 114         m_windowParent->RemoveChild(this);
 115
 116     DestroyChildren();
 117
 118     // TODO: destroy the window
 119
 120     delete m_children;
 121     m_children = NULL;
 122
 123     // Just in case the window has been Closed, but
 124     // we're then deleting immediately: don't leave
 125     // dangling pointers.
 126     wxPendingDelete.DeleteObject(this);
 127
 128     if ( m_windowValidator )
 129             delete m_windowValidator;
 130 }
 131
 132 // Destroy the window (delayed, if a managed window)
 133 bool wxWindow::Destroy()
 134 {
 135     delete this;
 136     return TRUE;
 137 }
 138
 139 // Constructor
 140 bool wxWindow::Create(wxWindow *parent, wxWindowID id,
 141            const wxPoint& pos,
 142            const wxSize& size,
 143            long style,
 144            const wxString& name)
 145 {
 146     // Generic
 147     m_windowId = 0;
 148     m_windowStyle = 0;
 149     m_windowParent = NULL;
 150     m_windowEventHandler = this;
 151     m_windowName = "";
 152     m_windowCursor = *wxSTANDARD_CURSOR;
 153     m_constraints = NULL;
 154     m_constraintsInvolvedIn = NULL;
 155     m_windowSizer = NULL;
 156     m_sizerParent = NULL;
 157     m_autoLayout = FALSE;
 158     m_windowValidator = NULL;
 159
 160 #if USE_DRAG_AND_DROP
 161     m_pDropTarget = NULL;
 162 #endif
 163
 164     m_caretWidth = 0; m_caretHeight = 0;
 165     m_caretEnabled = FALSE;
 166     m_caretShown = FALSE;
 167     m_minSizeX = -1;
 168     m_minSizeY = -1;
 169     m_maxSizeX = -1;
 170     m_maxSizeY = -1;
 171     m_defaultItem = NULL;
 172     m_windowParent = NULL;
 173     if (!parent)
 174         return FALSE;
 175
 176     if (parent) parent->AddChild(this);
 177
 178     m_returnCode = 0;
 179
 180     SetName(name);
 181
 182     if ( id == -1 )
 183         m_windowId = (int)NewControlId();
 184     else
 185         m_windowId = id;
 186
 187     m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
 188     m_foregroundColour = *wxBLACK;
 189     m_defaultForegroundColour = *wxBLACK ;
 190     m_defaultBackgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;
 191
 192     m_windowStyle = style;
 193
 194     if ( id == -1 )
 195         m_windowId = (int)NewControlId();
 196     else
 197         m_windowId = id;
 198
 199     // TODO: create the window
 200
 201     return TRUE;
 202 }
 203
 204 void wxWindow::SetFocus()
 205 {
 206     // TODO
 207 }
 208
 209 void wxWindow::Enable(bool enable)
 210 {
 211     // TODO
 212 }
 213
 214 void wxWindow::CaptureMouse()
 215 {
 216     // TODO
 217 }
 218
 219 void wxWindow::ReleaseMouse()
 220 {
 221     // TODO
 222 }
 223
 224 // Push/pop event handler (i.e. allow a chain of event handlers
 225 // be searched)
 226 void wxWindow::PushEventHandler(wxEvtHandler *handler)
 227 {
 228         handler->SetNextHandler(GetEventHandler());
 229         SetEventHandler(handler);
 230 }
 231
 232 wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
 233 {
 234         if ( GetEventHandler() )
 235         {
 236                 wxEvtHandler *handlerA = GetEventHandler();
 237                 wxEvtHandler *handlerB = handlerA->GetNextHandler();
 238                 handlerA->SetNextHandler(NULL);
 239                 SetEventHandler(handlerB);
 240                 if ( deleteHandler )
 241                 {
 242                         delete handlerA;
 243                         return NULL;
 244                 }
 245                 else
 246                         return handlerA;
 247         }
 248         else
 249                 return NULL;
 250 }
 251
 252 #if    USE_DRAG_AND_DROP
 253
 254 void wxWindow::SetDropTarget(wxDropTarget *pDropTarget)
 255 {
 256   if ( m_pDropTarget != 0 ) {
 257     m_pDropTarget->Revoke(m_hWnd);
 258     delete m_pDropTarget;
 259   }
 260
 261   m_pDropTarget = pDropTarget;
 262   if ( m_pDropTarget != 0 )
 263     m_pDropTarget->Register(m_hWnd);
 264 }
 265
 266 #endif
 267
 268 // Old style file-manager drag&drop
 269 void wxWindow::DragAcceptFiles(bool accept)
 270 {
 271     // TODO
 272 }
 273
 274 // Get total size
 275 void wxWindow::GetSize(int *x, int *y) const
 276 {
 277     // TODO
 278 }
 279
 280 void wxWindow::GetPosition(int *x, int *y) const
 281 {
 282     // TODO
 283 }
 284
 285 void wxWindow::ScreenToClient(int *x, int *y) const
 286 {
 287     // TODO
 288 }
 289
 290 void wxWindow::ClientToScreen(int *x, int *y) const
 291 {
 292     // TODO
 293 }
 294
 295 void wxWindow::SetCursor(const wxCursor& cursor)
 296 {
 297   m_windowCursor = cursor;
 298   if (m_windowCursor.Ok())
 299   {
 300     // TODO
 301   }
 302 }
 303
 304
 305 // Get size *available for subwindows* i.e. excluding menu bar etc.
 306 void wxWindow::GetClientSize(int *x, int *y) const
 307 {
 308     // TODO
 309 }
 310
 311 void wxWindow::SetSize(int x, int y, int width, int height, int sizeFlags)
 312 {
 313     // TODO
 314 }
 315
 316 void wxWindow::SetClientSize(int width, int height)
 317 {
 318     // TODO
 319 }
 320
 321 // For implementation purposes - sometimes decorations make the client area
 322 // smaller
 323 wxPoint wxWindow::GetClientAreaOrigin() const
 324 {
 325     return wxPoint(0, 0);
 326 }
 327
 328 // Makes an adjustment to the window position (for example, a frame that has
 329 // a toolbar that it manages itself).
 330 void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
 331 {
 332     if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
 333     {
 334         wxPoint pt(GetParent()->GetClientAreaOrigin());
 335         x += pt.x; y += pt.y;
 336     }
 337 }
 338
 339 bool wxWindow::Show(bool show)
 340 {
 341     // TODO
 342     return FALSE;
 343 }
 344
 345 bool wxWindow::IsShown() const
 346 {
 347     // TODO
 348     return FALSE;
 349 }
 350
 351 int wxWindow::GetCharHeight() const
 352 {
 353     // TODO
 354     return 0;
 355 }
 356
 357 int wxWindow::GetCharWidth() const
 358 {
 359     // TODO
 360     return 0;
 361 }
 362
 363 void wxWindow::GetTextExtent(const wxString& string, int *x, int *y,
 364                            int *descent, int *externalLeading, const wxFont *theFont, bool) const
 365 {
 366   wxFont *fontToUse = (wxFont *)theFont;
 367   if (!fontToUse)
 368     fontToUse = (wxFont *) & m_windowFont;
 369
 370     // TODO
 371 }
 372
 373 void wxWindow::Refresh(bool eraseBack, const wxRectangle *rect)
 374 {
 375     // TODO
 376 }
 377
 378 // Responds to colour changes: passes event on to children.
 379 void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
 380 {
 381     wxNode *node = GetChildren()->First();
 382     while ( node )
 383     {
 384         // Only propagate to non-top-level windows
 385         wxWindow *win = (wxWindow *)node->Data();
 386         if ( win->GetParent() )
 387         {
 388             wxSysColourChangedEvent event2;
 389             event.m_eventObject = win;
 390             win->GetEventHandler()->ProcessEvent(event2);
 391         }
 392
 393         node = node->Next();
 394     }
 395 }
 396
 397 // This can be called by the app (or wxWindows) to do default processing for the current
 398 // event. Save message/event info in wxWindow so they can be used in this function.
 399 long wxWindow::Default()
 400 {
 401     // TODO
 402     return 0;
 403 }
 404
 405 void wxWindow::InitDialog()
 406 {
 407   wxInitDialogEvent event(GetId());
 408   event.SetEventObject( this );
 409   GetEventHandler()->ProcessEvent(event);
 410 }
 411
 412 // Default init dialog behaviour is to transfer data to window
 413 void wxWindow::OnInitDialog(wxInitDialogEvent& event)
 414 {
 415   TransferDataToWindow();
 416 }
 417
 418 // Caret manipulation
 419 void wxWindow::CreateCaret(int w, int h)
 420 {
 421   m_caretWidth = w;
 422   m_caretHeight = h;
 423   m_caretEnabled = TRUE;
 424 }
 425
 426 void wxWindow::CreateCaret(const wxBitmap *WXUNUSED(bitmap))
 427 {
 428     // TODO
 429 }
 430
 431 void wxWindow::ShowCaret(bool show)
 432 {
 433     // TODO
 434 }
 435
 436 void wxWindow::DestroyCaret()
 437 {
 438     // TODO
 439     m_caretEnabled = FALSE;
 440 }
 441
 442 void wxWindow::SetCaretPos(int x, int y)
 443 {
 444     // TODO
 445 }
 446
 447 void wxWindow::GetCaretPos(int *x, int *y) const
 448 {
 449     // TODO
 450 }
 451
 452 wxWindow *wxGetActiveWindow()
 453 {
 454     // TODO
 455     return NULL;
 456 }
 457
 458 void wxWindow::SetSizeHints(int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH))
 459 {
 460   m_minSizeX = minW;
 461   m_minSizeY = minH;
 462   m_maxSizeX = maxW;
 463   m_maxSizeY = maxH;
 464 }
 465
 466 void wxWindow::Centre(int direction)
 467 {
 468   int x, y, width, height, panel_width, panel_height, new_x, new_y;
 469
 470   wxWindow *father = (wxWindow *)GetParent();
 471   if (!father)
 472     return;
 473
 474   father->GetClientSize(&panel_width, &panel_height);
 475   GetSize(&width, &height);
 476   GetPosition(&x, &y);
 477
 478   new_x = -1;
 479   new_y = -1;
 480
 481   if (direction & wxHORIZONTAL)
 482     new_x = (int)((panel_width - width)/2);
 483
 484   if (direction & wxVERTICAL)
 485     new_y = (int)((panel_height - height)/2);
 486
 487   SetSize(new_x, new_y, -1, -1);
 488
 489 }
 490
 491 // Coordinates relative to the window
 492 void wxWindow::WarpPointer (int x_pos, int y_pos)
 493 {
 494     // TODO
 495 }
 496
 497 void wxWindow::OnEraseBackground(wxEraseEvent& event)
 498 {
 499     // TODO
 500     Default();
 501 }
 502
 503 int wxWindow::GetScrollPos(int orient) const
 504 {
 505     // TODO
 506     return 0;
 507 }
 508
 509 // This now returns the whole range, not just the number
 510 // of positions that we can scroll.
 511 int wxWindow::GetScrollRange(int orient) const
 512 {
 513     // TODO
 514     return 0;
 515 }
 516
 517 int wxWindow::GetScrollThumb(int orient) const
 518 {
 519     // TODO
 520     return 0;
 521 }
 522
 523 void wxWindow::SetScrollPos(int orient, int pos, bool refresh)
 524 {
 525     // TODO
 526     return 0;
 527 }
 528
 529 // New function that will replace some of the above.
 530 void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
 531     int range, bool refresh)
 532 {
 533     // TODO
 534 }
 535
 536 // Does a physical scroll
 537 void wxWindow::ScrollWindow(int dx, int dy, const wxRectangle *rect)
 538 {
 539     // TODO
 540     return 0;
 541 }
 542
 543 void wxWindow::SetFont(const wxFont& font)
 544 {
 545     m_windowFont = font;
 546
 547     if (!m_windowFont.Ok())
 548             return;
 549     // TODO
 550 }
 551
 552 void wxWindow::OnChar(wxKeyEvent& event)
 553 {
 554     if ( event.KeyCode() == WXK_TAB ) {
 555         // propagate the TABs to the parent - it's up to it to decide what
 556         // to do with it
 557         if ( GetParent() ) {
 558             if ( GetParent()->ProcessEvent(event) )
 559                 return;
 560         }
 561     }
 562 }
 563
 564 void wxWindow::OnPaint(wxPaintEvent& event)
 565 {
 566         Default();
 567 }
 568
 569 bool wxWindow::IsEnabled() const
 570 {
 571     // TODO
 572     return FALSE;
 573 }
 574
 575 // Dialog support: override these and call
 576 // base class members to add functionality
 577 // that can't be done using validators.
 578 // NOTE: these functions assume that controls
 579 // are direct children of this window, not grandchildren
 580 // or other levels of descendant.
 581
 582 // Transfer values to controls. If returns FALSE,
 583 // it's an application error (pops up a dialog)
 584 bool wxWindow::TransferDataToWindow()
 585 {
 586         wxNode *node = GetChildren()->First();
 587         while ( node )
 588         {
 589                 wxWindow *child = (wxWindow *)node->Data();
 590                 if ( child->GetValidator() &&
 591                      !child->GetValidator()->TransferToWindow() )
 592                 {
 593                         wxMessageBox("Application Error", "Could not transfer data to window", wxOK|wxICON_EXCLAMATION);
 594                         return FALSE;
 595                 }
 596
 597                 node = node->Next();
 598         }
 599         return TRUE;
 600 }
 601
 602 // Transfer values from controls. If returns FALSE,
 603 // validation failed: don't quit
 604 bool wxWindow::TransferDataFromWindow()
 605 {
 606         wxNode *node = GetChildren()->First();
 607         while ( node )
 608         {
 609                 wxWindow *child = (wxWindow *)node->Data();
 610                 if ( child->GetValidator() && !child->GetValidator()->TransferFromWindow() )
 611                 {
 612                         return FALSE;
 613                 }
 614
 615                 node = node->Next();
 616         }
 617         return TRUE;
 618 }
 619
 620 bool wxWindow::Validate()
 621 {
 622         wxNode *node = GetChildren()->First();
 623         while ( node )
 624         {
 625                 wxWindow *child = (wxWindow *)node->Data();
 626                 if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this) )
 627                 {
 628                         return FALSE;
 629                 }
 630
 631                 node = node->Next();
 632         }
 633         return TRUE;
 634 }
 635
 636 // Get the window with the focus
 637 wxWindow *wxWindow::FindFocus()
 638 {
 639     // TODO
 640     return NULL;
 641 }
 642
 643 void wxWindow::AddChild(wxWindow *child)
 644 {
 645     GetChildren()->Append(child);
 646     child->m_windowParent = this;
 647 }
 648
 649 void wxWindow::RemoveChild(wxWindow *child)
 650 {
 651     if (GetChildren())
 652         GetChildren()->DeleteObject(child);
 653     child->m_windowParent = NULL;
 654 }
 655
 656 void wxWindow::DestroyChildren()
 657 {
 658   if (GetChildren()) {
 659     wxNode *node;
 660     while ((node = GetChildren()->First()) != (wxNode *)NULL) {
 661       wxWindow *child;
 662       if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) {
 663         delete child;
 664                 if ( GetChildren()->Member(child) )
 665                         delete node;
 666       }
 667     } /* while */
 668   }
 669 }
 670
 671 void wxWindow::MakeModal(bool modal)
 672 {
 673   // Disable all other windows
 674   if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
 675   {
 676     wxNode *node = wxTopLevelWindows.First();
 677     while (node)
 678     {
 679       wxWindow *win = (wxWindow *)node->Data();
 680       if (win != this)
 681         win->Enable(!modal);
 682
 683       node = node->Next();
 684     }
 685   }
 686 }
 687
 688 // If nothing defined for this, try the parent.
 689 // E.g. we may be a button loaded from a resource, with no callback function
 690 // defined.
 691 void wxWindow::OnCommand(wxWindow& win, wxCommandEvent& event)
 692 {
 693   if (GetEventHandler()->ProcessEvent(event) )
 694         return;
 695   if (m_windowParent)
 696     m_windowParent->GetEventHandler()->OnCommand(win, event);
 697 }
 698
 699 void wxWindow::SetConstraints(wxLayoutConstraints *c)
 700 {
 701   if (m_constraints)
 702   {
 703     UnsetConstraints(m_constraints);
 704     delete m_constraints;
 705   }
 706   m_constraints = c;
 707   if (m_constraints)
 708   {
 709     // Make sure other windows know they're part of a 'meaningful relationship'
 710     if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this))
 711       m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
 712     if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this))
 713       m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
 714     if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this))
 715       m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
 716     if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this))
 717       m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
 718     if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this))
 719       m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
 720     if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this))
 721       m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
 722     if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this))
 723       m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
 724     if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this))
 725       m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
 726   }
 727 }
 728
 729 // This removes any dangling pointers to this window
 730 // in other windows' constraintsInvolvedIn lists.
 731 void wxWindow::UnsetConstraints(wxLayoutConstraints *c)
 732 {
 733   if (c)
 734   {
 735     if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this))
 736       c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
 737     if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this))
 738       c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
 739     if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this))
 740       c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
 741     if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this))
 742       c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
 743     if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this))
 744       c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
 745     if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this))
 746       c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
 747     if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this))
 748       c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
 749     if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this))
 750       c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
 751   }
 752 }
 753
 754 // Back-pointer to other windows we're involved with, so if we delete
 755 // this window, we must delete any constraints we're involved with.
 756 void wxWindow::AddConstraintReference(wxWindow *otherWin)
 757 {
 758   if (!m_constraintsInvolvedIn)
 759     m_constraintsInvolvedIn = new wxList;
 760   if (!m_constraintsInvolvedIn->Member(otherWin))
 761     m_constraintsInvolvedIn->Append(otherWin);
 762 }
 763
 764 // REMOVE back-pointer to other windows we're involved with.
 765 void wxWindow::RemoveConstraintReference(wxWindow *otherWin)
 766 {
 767   if (m_constraintsInvolvedIn)
 768     m_constraintsInvolvedIn->DeleteObject(otherWin);
 769 }
 770
 771 // Reset any constraints that mention this window
 772 void wxWindow::DeleteRelatedConstraints()
 773 {
 774   if (m_constraintsInvolvedIn)
 775   {
 776     wxNode *node = m_constraintsInvolvedIn->First();
 777     while (node)
 778     {
 779       wxWindow *win = (wxWindow *)node->Data();
 780       wxNode *next = node->Next();
 781       wxLayoutConstraints *constr = win->GetConstraints();
 782
 783       // Reset any constraints involving this window
 784       if (constr)
 785       {
 786         constr->left.ResetIfWin((wxWindow *)this);
 787         constr->top.ResetIfWin((wxWindow *)this);
 788         constr->right.ResetIfWin((wxWindow *)this);
 789         constr->bottom.ResetIfWin((wxWindow *)this);
 790         constr->width.ResetIfWin((wxWindow *)this);
 791         constr->height.ResetIfWin((wxWindow *)this);
 792         constr->centreX.ResetIfWin((wxWindow *)this);
 793         constr->centreY.ResetIfWin((wxWindow *)this);
 794       }
 795       delete node;
 796       node = next;
 797     }
 798     delete m_constraintsInvolvedIn;
 799     m_constraintsInvolvedIn = NULL;
 800   }
 801 }
 802
 803 void wxWindow::SetSizer(wxSizer *sizer)
 804 {
 805   m_windowSizer = sizer;
 806   if (sizer)
 807     sizer->SetSizerParent((wxWindow *)this);
 808 }
 809
 810 /*
 811  * New version
 812  */
 813
 814 bool wxWindow::Layout()
 815 {
 816   if (GetConstraints())
 817   {
 818     int w, h;
 819     GetClientSize(&w, &h);
 820     GetConstraints()->width.SetValue(w);
 821     GetConstraints()->height.SetValue(h);
 822   }
 823
 824   // If top level (one sizer), evaluate the sizer's constraints.
 825   if (GetSizer())
 826   {
 827     int noChanges;
 828     GetSizer()->ResetConstraints();   // Mark all constraints as unevaluated
 829     GetSizer()->LayoutPhase1(&noChanges);
 830     GetSizer()->LayoutPhase2(&noChanges);
 831     GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
 832     return TRUE;
 833   }
 834   else
 835   {
 836     // Otherwise, evaluate child constraints
 837     ResetConstraints();   // Mark all constraints as unevaluated
 838     DoPhase(1);           // Just one phase need if no sizers involved
 839     DoPhase(2);
 840     SetConstraintSizes(); // Recursively set the real window sizes
 841   }
 842   return TRUE;
 843 }
 844
 845
 846 // Do a phase of evaluating constraints:
 847 // the default behaviour. wxSizers may do a similar
 848 // thing, but also impose their own 'constraints'
 849 // and order the evaluation differently.
 850 bool wxWindow::LayoutPhase1(int *noChanges)
 851 {
 852   wxLayoutConstraints *constr = GetConstraints();
 853   if (constr)
 854   {
 855     return constr->SatisfyConstraints((wxWindow *)this, noChanges);
 856   }
 857   else
 858     return TRUE;
 859 }
 860
 861 bool wxWindow::LayoutPhase2(int *noChanges)
 862 {
 863   *noChanges = 0;
 864
 865   // Layout children
 866   DoPhase(1);
 867   DoPhase(2);
 868   return TRUE;
 869 }
 870
 871 // Do a phase of evaluating child constraints
 872 bool wxWindow::DoPhase(int phase)
 873 {
 874   int noIterations = 0;
 875   int maxIterations = 500;
 876   int noChanges = 1;
 877   int noFailures = 0;
 878   wxList succeeded;
 879   while ((noChanges > 0) && (noIterations < maxIterations))
 880   {
 881     noChanges = 0;
 882     noFailures = 0;
 883     wxNode *node = GetChildren()->First();
 884     while (node)
 885     {
 886       wxWindow *child = (wxWindow *)node->Data();
 887       if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)))
 888       {
 889         wxLayoutConstraints *constr = child->GetConstraints();
 890         if (constr)
 891         {
 892           if (succeeded.Member(child))
 893           {
 894           }
 895           else
 896           {
 897             int tempNoChanges = 0;
 898             bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
 899             noChanges += tempNoChanges;
 900             if (success)
 901             {
 902               succeeded.Append(child);
 903             }
 904           }
 905         }
 906       }
 907       node = node->Next();
 908     }
 909     noIterations ++;
 910   }
 911   return TRUE;
 912 }
 913
 914 void wxWindow::ResetConstraints()
 915 {
 916   wxLayoutConstraints *constr = GetConstraints();
 917   if (constr)
 918   {
 919     constr->left.SetDone(FALSE);
 920     constr->top.SetDone(FALSE);
 921     constr->right.SetDone(FALSE);
 922     constr->bottom.SetDone(FALSE);
 923     constr->width.SetDone(FALSE);
 924     constr->height.SetDone(FALSE);
 925     constr->centreX.SetDone(FALSE);
 926     constr->centreY.SetDone(FALSE);
 927   }
 928   wxNode *node = GetChildren()->First();
 929   while (node)
 930   {
 931     wxWindow *win = (wxWindow *)node->Data();
 932     if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
 933       win->ResetConstraints();
 934     node = node->Next();
 935   }
 936 }
 937
 938 // Need to distinguish between setting the 'fake' size for
 939 // windows and sizers, and setting the real values.
 940 void wxWindow::SetConstraintSizes(bool recurse)
 941 {
 942   wxLayoutConstraints *constr = GetConstraints();
 943   if (constr && constr->left.GetDone() && constr->right.GetDone() &&
 944                 constr->width.GetDone() && constr->height.GetDone())
 945   {
 946     int x = constr->left.GetValue();
 947     int y = constr->top.GetValue();
 948     int w = constr->width.GetValue();
 949     int h = constr->height.GetValue();
 950
 951     // If we don't want to resize this window, just move it...
 952     if ((constr->width.GetRelationship() != wxAsIs) ||
 953         (constr->height.GetRelationship() != wxAsIs))
 954     {
 955       // Calls Layout() recursively. AAAGH. How can we stop that.
 956       // Simply take Layout() out of non-top level OnSizes.
 957       SizerSetSize(x, y, w, h);
 958     }
 959     else
 960     {
 961       SizerMove(x, y);
 962     }
 963   }
 964   else if (constr)
 965   {
 966     char *windowClass = this->GetClassInfo()->GetClassName();
 967
 968     wxString winName;
 969         if (GetName() == "")
 970                 winName = "unnamed";
 971         else
 972                 winName = GetName();
 973     wxDebugMsg("Constraint(s) not satisfied for window of type %s, name %s:\n", (const char *)windowClass, (const char *)winName);
 974     if (!constr->left.GetDone())
 975       wxDebugMsg("  unsatisfied 'left' constraint.\n");
 976     if (!constr->right.GetDone())
 977       wxDebugMsg("  unsatisfied 'right' constraint.\n");
 978     if (!constr->width.GetDone())
 979       wxDebugMsg("  unsatisfied 'width' constraint.\n");
 980     if (!constr->height.GetDone())
 981       wxDebugMsg("  unsatisfied 'height' constraint.\n");
 982     wxDebugMsg("Please check constraints: try adding AsIs() constraints.\n");
 983   }
 984
 985   if (recurse)
 986   {
 987     wxNode *node = GetChildren()->First();
 988     while (node)
 989     {
 990       wxWindow *win = (wxWindow *)node->Data();
 991       if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
 992         win->SetConstraintSizes();
 993       node = node->Next();
 994     }
 995   }
 996 }
 997
 998 // This assumes that all sizers are 'on' the same
 999 // window, i.e. the parent of this window.
1000 void wxWindow::TransformSizerToActual(int *x, int *y) const
1001 {
1002   if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
1003                          m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
1004     return;
1005
1006   int xp, yp;
1007   m_sizerParent->GetPosition(&xp, &yp);
1008   m_sizerParent->TransformSizerToActual(&xp, &yp);
1009   *x += xp;
1010   *y += yp;
1011 }
1012
1013 void wxWindow::SizerSetSize(int x, int y, int w, int h)
1014 {
1015         int xx = x;
1016         int yy = y;
1017   TransformSizerToActual(&xx, &yy);
1018   SetSize(xx, yy, w, h);
1019 }
1020
1021 void wxWindow::SizerMove(int x, int y)
1022 {
1023         int xx = x;
1024         int yy = y;
1025   TransformSizerToActual(&xx, &yy);
1026   Move(xx, yy);
1027 }
1028
1029 // Only set the size/position of the constraint (if any)
1030 void wxWindow::SetSizeConstraint(int x, int y, int w, int h)
1031 {
1032   wxLayoutConstraints *constr = GetConstraints();
1033   if (constr)
1034   {
1035     if (x != -1)
1036     {
1037       constr->left.SetValue(x);
1038       constr->left.SetDone(TRUE);
1039     }
1040     if (y != -1)
1041     {
1042       constr->top.SetValue(y);
1043       constr->top.SetDone(TRUE);
1044     }
1045     if (w != -1)
1046     {
1047       constr->width.SetValue(w);
1048       constr->width.SetDone(TRUE);
1049     }
1050     if (h != -1)
1051     {
1052       constr->height.SetValue(h);
1053       constr->height.SetDone(TRUE);
1054     }
1055   }
1056 }
1057
1058 void wxWindow::MoveConstraint(int x, int y)
1059 {
1060   wxLayoutConstraints *constr = GetConstraints();
1061   if (constr)
1062   {
1063     if (x != -1)
1064     {
1065       constr->left.SetValue(x);
1066       constr->left.SetDone(TRUE);
1067     }
1068     if (y != -1)
1069     {
1070       constr->top.SetValue(y);
1071       constr->top.SetDone(TRUE);
1072     }
1073   }
1074 }
1075
1076 void wxWindow::GetSizeConstraint(int *w, int *h) const
1077 {
1078   wxLayoutConstraints *constr = GetConstraints();
1079   if (constr)
1080   {
1081     *w = constr->width.GetValue();
1082     *h = constr->height.GetValue();
1083   }
1084   else
1085     GetSize(w, h);
1086 }
1087
1088 void wxWindow::GetClientSizeConstraint(int *w, int *h) const
1089 {
1090   wxLayoutConstraints *constr = GetConstraints();
1091   if (constr)
1092   {
1093     *w = constr->width.GetValue();
1094     *h = constr->height.GetValue();
1095   }
1096   else
1097     GetClientSize(w, h);
1098 }
1099
1100 void wxWindow::GetPositionConstraint(int *x, int *y) const
1101 {
1102   wxLayoutConstraints *constr = GetConstraints();
1103   if (constr)
1104   {
1105     *x = constr->left.GetValue();
1106     *y = constr->top.GetValue();
1107   }
1108   else
1109     GetPosition(x, y);
1110 }
1111
1112 bool wxWindow::Close(bool force)
1113 {
1114   wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
1115   event.SetEventObject(this);
1116   event.SetForce(force);
1117
1118   return GetEventHandler()->ProcessEvent(event);
1119 }
1120
1121 wxObject* wxWindow::GetChild(int number) const
1122 {
1123   // Return a pointer to the Nth object in the window
1124   if (!GetChildren())
1125     return(NULL) ;
1126   wxNode *node = GetChildren()->First();
1127   int n = number;
1128   while (node && n--)
1129     node = node->Next() ;
1130   if (node)
1131   {
1132     wxObject *obj = (wxObject *)node->Data();
1133     return(obj) ;
1134   }
1135   else
1136     return NULL ;
1137 }
1138
1139 void wxWindow::OnDefaultAction(wxControl *initiatingItem)
1140 {
1141     // Obsolete function
1142 }
1143
1144 void wxWindow::Clear()
1145 {
1146         wxClientDC dc(this);
1147     wxBrush brush(GetBackgroundColour(), wxSOLID);
1148     dc.SetBackground(brush);
1149     dc.Clear();
1150 }
1151
1152 // Fits the panel around the items
1153 void wxWindow::Fit()
1154 {
1155         int maxX = 0;
1156         int maxY = 0;
1157         wxNode *node = GetChildren()->First();
1158         while ( node )
1159         {
1160                 wxWindow *win = (wxWindow *)node->Data();
1161                 int wx, wy, ww, wh;
1162                 win->GetPosition(&wx, &wy);
1163                 win->GetSize(&ww, &wh);
1164                 if ( wx + ww > maxX )
1165                         maxX = wx + ww;
1166                 if ( wy + wh > maxY )
1167                         maxY = wy + wh;
1168
1169                 node = node->Next();
1170         }
1171         SetClientSize(maxX + 5, maxY + 5);
1172 }
1173
1174 void wxWindow::SetValidator(const wxValidator& validator)
1175 {
1176         if ( m_windowValidator )
1177                 delete m_windowValidator;
1178         m_windowValidator = validator.Clone();
1179
1180         if ( m_windowValidator )
1181                 m_windowValidator->SetWindow(this) ;
1182 }
1183
1184 // Find a window by id or name
1185 wxWindow *wxWindow::FindWindow(long id)
1186 {
1187         if ( GetId() == id)
1188                 return this;
1189
1190         wxNode *node = GetChildren()->First();
1191         while ( node )
1192         {
1193                 wxWindow *child = (wxWindow *)node->Data();
1194                 wxWindow *found = child->FindWindow(id);
1195                 if ( found )
1196                         return found;
1197                 node = node->Next();
1198         }
1199         return NULL;
1200 }
1201
1202 wxWindow *wxWindow::FindWindow(const wxString& name)
1203 {
1204         if ( GetName() == name)
1205                 return this;
1206
1207         wxNode *node = GetChildren()->First();
1208         while ( node )
1209         {
1210                 wxWindow *child = (wxWindow *)node->Data();
1211                 wxWindow *found = child->FindWindow(name);
1212                 if ( found )
1213                         return found;
1214                 node = node->Next();
1215         }
1216         return NULL;
1217 }
1218
1219 void wxWindow::OnIdle(wxIdleEvent& event)
1220 {
1221 /* TODO: you may need to do something like this
1222  * if your GUI doesn't generate enter/leave events
1223
1224     // Check if we need to send a LEAVE event
1225     if (m_mouseInWindow)
1226     {
1227         POINT pt;
1228         ::GetCursorPos(&pt);
1229         if (::WindowFromPoint(pt) != (HWND) GetHWND())
1230         {
1231             // Generate a LEAVE event
1232             m_mouseInWindow = FALSE;
1233             MSWOnMouseLeave(pt.x, pt.y, 0);
1234         }
1235     }
1236 */
1237
1238     // This calls the UI-update mechanism (querying windows for
1239     // menu/toolbar/control state information)
1240         UpdateWindowUI();
1241 }
1242
1243 // Raise the window to the top of the Z order
1244 void wxWindow::Raise()
1245 {
1246     // TODO
1247 }
1248
1249 // Lower the window to the bottom of the Z order
1250 void wxWindow::Lower()
1251 {
1252     // TODO
1253 }
1254
1255 bool wxWindow::AcceptsFocus() const
1256 {
1257   return IsShown() && IsEnabled();
1258 }
1259
1260 // Update region access
1261 wxRegion wxWindow::GetUpdateRegion() const
1262 {
1263     return m_updateRegion;
1264 }
1265
1266 bool wxWindow::IsExposed(int x, int y, int w, int h) const
1267 {
1268     return (m_updateRegion.Contains(x, y, w, h) != wxOutRegion);
1269 }
1270
1271 bool wxWindow::IsExposed(const wxPoint& pt) const
1272 {
1273     return (m_updateRegion.Contains(pt) != wxOutRegion);
1274 }
1275
1276 bool wxWindow::IsExposed(const wxRect& rect) const
1277 {
1278     return (m_updateRegion.Contains(rect) != wxOutRegion);
1279 }
1280
1281