src/generic/laywin.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        laywin.cpp
   3 // Purpose:     Implements a simple layout algorithm, plus
   4 //              wxSashLayoutWindow which is an example of a window with
   5 //              layout-awareness (via event handlers). This is suited to
   6 //              IDE-style window layout.
   7 // Author:      Julian Smart
   8 // Modified by:
   9 // Created:     04/01/98
  10 // RCS-ID:      $Id$
  11 // Copyright:   (c) Julian Smart
  12 // Licence:     wxWindows licence
  13 /////////////////////////////////////////////////////////////////////////////
  14
  15 // For compilers that support precompilation, includes "wx/wx.h".
  16 #include "wx/wxprec.h"
  17
  18 #ifdef __BORLANDC__
  19 #pragma hdrstop
  20 #endif
  21
  22 #ifndef WX_PRECOMP
  23     #include "wx/frame.h"
  24     #include "wx/mdi.h"
  25 #endif
  26
  27 #include "wx/laywin.h"
  28
  29 IMPLEMENT_DYNAMIC_CLASS(wxQueryLayoutInfoEvent, wxEvent)
  30 IMPLEMENT_DYNAMIC_CLASS(wxCalculateLayoutEvent, wxEvent)
  31
  32 DEFINE_EVENT_TYPE(wxEVT_QUERY_LAYOUT_INFO)
  33 DEFINE_EVENT_TYPE(wxEVT_CALCULATE_LAYOUT)
  34
  35 #if wxUSE_SASH
  36 IMPLEMENT_CLASS(wxSashLayoutWindow, wxSashWindow)
  37
  38 BEGIN_EVENT_TABLE(wxSashLayoutWindow, wxSashWindow)
  39     EVT_CALCULATE_LAYOUT(wxSashLayoutWindow::OnCalculateLayout)
  40     EVT_QUERY_LAYOUT_INFO(wxSashLayoutWindow::OnQueryLayoutInfo)
  41 END_EVENT_TABLE()
  42
  43 bool wxSashLayoutWindow::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos,
  44         const wxSize& size, long style, const wxString& name)
  45 {
  46     return wxSashWindow::Create(parent, id, pos, size, style, name);
  47 }
  48
  49 void wxSashLayoutWindow::Init()
  50 {
  51     m_orientation = wxLAYOUT_HORIZONTAL;
  52     m_alignment = wxLAYOUT_TOP;
  53 #ifdef __WXMAC__
  54     MacSetClipChildren( true ) ;
  55 #endif
  56 }
  57
  58 // This is the function that wxLayoutAlgorithm calls to ascertain the window
  59 // dimensions.
  60 void wxSashLayoutWindow::OnQueryLayoutInfo(wxQueryLayoutInfoEvent& event)
  61 {
  62   //    int flags = event.GetFlags();
  63     int requestedLength = event.GetRequestedLength();
  64
  65     event.SetOrientation(m_orientation);
  66     event.SetAlignment(m_alignment);
  67
  68     if (m_orientation == wxLAYOUT_HORIZONTAL)
  69         event.SetSize(wxSize(requestedLength, m_defaultSize.y));
  70     else
  71         event.SetSize(wxSize(m_defaultSize.x, requestedLength));
  72 }
  73
  74 // Called by parent to allow window to take a bit out of the
  75 // client rectangle, and size itself if not in wxLAYOUT_QUERY mode.
  76
  77 void wxSashLayoutWindow::OnCalculateLayout(wxCalculateLayoutEvent& event)
  78 {
  79     wxRect clientSize(event.GetRect());
  80
  81     int flags = event.GetFlags();
  82
  83     if (!IsShown())
  84         return;
  85
  86     // Let's assume that all windows stretch the full extent of the window in
  87     // the direction of that window orientation. This will work for non-docking toolbars,
  88     // and the status bar. Note that the windows have to have been created in a certain
  89     // order to work, else you might get a left-aligned window going to the bottom
  90     // of the window, and the status bar appearing to the right of it. The
  91     // status bar would have to be created after or before the toolbar(s).
  92
  93     wxRect thisRect;
  94
  95     // Try to stretch
  96     int length = (GetOrientation() == wxLAYOUT_HORIZONTAL) ? clientSize.width : clientSize.height;
  97     wxLayoutOrientation orient = GetOrientation();
  98
  99     // We assume that a window that says it's horizontal, wants to be stretched in that
 100     // direction. Is this distinction too fine? Do we assume that any horizontal
 101     // window needs to be stretched in that direction? Possibly.
 102     int whichDimension = (GetOrientation() == wxLAYOUT_HORIZONTAL) ? wxLAYOUT_LENGTH_X : wxLAYOUT_LENGTH_Y;
 103
 104     wxQueryLayoutInfoEvent infoEvent(GetId());
 105     infoEvent.SetEventObject(this);
 106     infoEvent.SetRequestedLength(length);
 107     infoEvent.SetFlags(orient | whichDimension);
 108
 109     if (!GetEventHandler()->ProcessEvent(infoEvent))
 110         return;
 111
 112     wxSize sz = infoEvent.GetSize();
 113
 114     if (sz.x == 0 && sz.y == 0) // Assume it's invisible
 115         return;
 116
 117     // Now we know the size it wants to be. We wish to decide where to place it, i.e.
 118     // how it's aligned.
 119     switch (GetAlignment())
 120     {
 121         case wxLAYOUT_TOP:
 122         {
 123             thisRect.x = clientSize.x; thisRect.y = clientSize.y;
 124             thisRect.width = sz.x; thisRect.height = sz.y;
 125             clientSize.y += thisRect.height;
 126             clientSize.height -= thisRect.height;
 127             break;
 128         }
 129         case wxLAYOUT_LEFT:
 130         {
 131             thisRect.x = clientSize.x; thisRect.y = clientSize.y;
 132             thisRect.width = sz.x; thisRect.height = sz.y;
 133             clientSize.x += thisRect.width;
 134             clientSize.width -= thisRect.width;
 135             break;
 136         }
 137         case wxLAYOUT_RIGHT:
 138         {
 139             thisRect.x = clientSize.x + (clientSize.width - sz.x); thisRect.y = clientSize.y;
 140             thisRect.width = sz.x; thisRect.height = sz.y;
 141             clientSize.width -= thisRect.width;
 142             break;
 143         }
 144         case wxLAYOUT_BOTTOM:
 145         {
 146             thisRect.x = clientSize.x; thisRect.y = clientSize.y + (clientSize.height - sz.y);
 147             thisRect.width = sz.x; thisRect.height = sz.y;
 148             clientSize.height -= thisRect.height;
 149             break;
 150         }
 151         case wxLAYOUT_NONE:
 152         {
 153             break;
 154         }
 155
 156     }
 157
 158     if ((flags & wxLAYOUT_QUERY) == 0)
 159     {
 160         // If not in query mode, resize the window.
 161         // TODO: add wxRect& form to wxWindow::SetSize
 162         wxSize sz2 = GetSize();
 163         wxPoint pos = GetPosition();
 164         SetSize(thisRect.x, thisRect.y, thisRect.width, thisRect.height);
 165
 166         // Make sure the sash is erased when the window is resized
 167         if ((pos.x != thisRect.x || pos.y != thisRect.y || sz2.x != thisRect.width || sz2.y != thisRect.height) &&
 168             (GetSashVisible(wxSASH_TOP) || GetSashVisible(wxSASH_RIGHT) || GetSashVisible(wxSASH_BOTTOM) || GetSashVisible(wxSASH_LEFT)))
 169             Refresh(true);
 170
 171     }
 172
 173     event.SetRect(clientSize);
 174 }
 175 #endif // wxUSE_SASH
 176
 177 /*
 178  * wxLayoutAlgorithm
 179  */
 180
 181 #if wxUSE_MDI_ARCHITECTURE
 182
 183 // Lays out windows for an MDI frame. The MDI client area gets what's left
 184 // over.
 185 bool wxLayoutAlgorithm::LayoutMDIFrame(wxMDIParentFrame* frame, wxRect* r)
 186 {
 187     int cw, ch;
 188     frame->GetClientSize(& cw, & ch);
 189
 190     wxRect rect(0, 0, cw, ch);
 191     if (r)
 192         rect = * r;
 193
 194     wxCalculateLayoutEvent event;
 195     event.SetRect(rect);
 196
 197     wxWindowList::compatibility_iterator node = frame->GetChildren().GetFirst();
 198     while (node)
 199     {
 200         wxWindow* win = node->GetData();
 201
 202         event.SetId(win->GetId());
 203         event.SetEventObject(win);
 204         event.SetFlags(0); // ??
 205
 206         win->GetEventHandler()->ProcessEvent(event);
 207
 208         node = node->GetNext();
 209     }
 210
 211     wxWindow* clientWindow = frame->GetClientWindow();
 212
 213     rect = event.GetRect();
 214
 215     clientWindow->SetSize(rect.x, rect.y, rect.width, rect.height);
 216
 217     return true;
 218 }
 219
 220 #endif // wxUSE_MDI_ARCHITECTURE
 221
 222 bool wxLayoutAlgorithm::LayoutFrame(wxFrame* frame, wxWindow* mainWindow)
 223 {
 224     return LayoutWindow(frame, mainWindow);
 225 }
 226
 227 // Layout algorithm for any window. mainWindow gets what's left over.
 228 bool wxLayoutAlgorithm::LayoutWindow(wxWindow* parent, wxWindow* mainWindow)
 229 {
 230     // Test if the parent is a sash window, and if so,
 231     // reduce the available space to allow space for any active edges.
 232
 233     int leftMargin = 0, rightMargin = 0, topMargin = 0, bottomMargin = 0;
 234 #if wxUSE_SASH
 235     if (parent->IsKindOf(CLASSINFO(wxSashWindow)))
 236     {
 237         wxSashWindow* sashWindow = (wxSashWindow*) parent;
 238
 239         leftMargin = sashWindow->GetExtraBorderSize();
 240         rightMargin = sashWindow->GetExtraBorderSize();
 241         topMargin = sashWindow->GetExtraBorderSize();
 242         bottomMargin = sashWindow->GetExtraBorderSize();
 243
 244         if (sashWindow->GetSashVisible(wxSASH_LEFT))
 245             leftMargin += sashWindow->GetDefaultBorderSize();
 246         if (sashWindow->GetSashVisible(wxSASH_RIGHT))
 247             rightMargin += sashWindow->GetDefaultBorderSize();
 248         if (sashWindow->GetSashVisible(wxSASH_TOP))
 249             topMargin += sashWindow->GetDefaultBorderSize();
 250         if (sashWindow->GetSashVisible(wxSASH_BOTTOM))
 251             bottomMargin += sashWindow->GetDefaultBorderSize();
 252     }
 253 #endif // wxUSE_SASH
 254
 255     int cw, ch;
 256     parent->GetClientSize(& cw, & ch);
 257
 258     wxRect rect(leftMargin, topMargin, cw - leftMargin - rightMargin, ch - topMargin - bottomMargin);
 259
 260     wxCalculateLayoutEvent event;
 261     event.SetRect(rect);
 262
 263     // Find the last layout-aware window, so we can make it fill all remaining
 264     // space.
 265     wxWindow *lastAwareWindow = NULL;
 266     wxWindowList::compatibility_iterator node = parent->GetChildren().GetFirst();
 267
 268     while (node)
 269     {
 270         wxWindow* win = node->GetData();
 271
 272         if (win->IsShown())
 273         {
 274             wxCalculateLayoutEvent tempEvent(win->GetId());
 275             tempEvent.SetEventObject(win);
 276             tempEvent.SetFlags(wxLAYOUT_QUERY);
 277             tempEvent.SetRect(event.GetRect());
 278             if (win->GetEventHandler()->ProcessEvent(tempEvent))
 279                 lastAwareWindow = win;
 280         }
 281
 282         node = node->GetNext();
 283     }
 284
 285     // Now do a dummy run to see if we have any space left for the final window (fail if not)
 286     node = parent->GetChildren().GetFirst();
 287     while (node)
 288     {
 289         wxWindow* win = node->GetData();
 290
 291         // If mainWindow is NULL and we're at the last window,
 292         // skip this, because we'll simply make it fit the remaining space.
 293         if (win->IsShown() && (win != mainWindow) && (mainWindow != NULL || win != lastAwareWindow))
 294         {
 295             event.SetId(win->GetId());
 296             event.SetEventObject(win);
 297             event.SetFlags(wxLAYOUT_QUERY);
 298
 299             win->GetEventHandler()->ProcessEvent(event);
 300         }
 301
 302         node = node->GetNext();
 303     }
 304
 305     if (event.GetRect().GetWidth() < 0 || event.GetRect().GetHeight() < 0)
 306         return false;
 307
 308     event.SetRect(rect);
 309
 310     node = parent->GetChildren().GetFirst();
 311     while (node)
 312     {
 313         wxWindow* win = node->GetData();
 314
 315         // If mainWindow is NULL and we're at the last window,
 316         // skip this, because we'll simply make it fit the remaining space.
 317         if (win->IsShown() && (win != mainWindow) && (mainWindow != NULL || win != lastAwareWindow))
 318         {
 319             event.SetId(win->GetId());
 320             event.SetEventObject(win);
 321             event.SetFlags(0); // ??
 322
 323             win->GetEventHandler()->ProcessEvent(event);
 324         }
 325
 326         node = node->GetNext();
 327     }
 328
 329     rect = event.GetRect();
 330
 331     if (mainWindow)
 332         mainWindow->SetSize(rect.x, rect.y, wxMax(0, rect.width), wxMax(0, rect.height));
 333     else if (lastAwareWindow)
 334     {
 335         // Fit the remaining space
 336         lastAwareWindow->SetSize(rect.x, rect.y, wxMax(0, rect.width), wxMax(0, rect.height));
 337     }
 338
 339     return true;
 340 }
 341