NAME

       wxLayoutAlgorithm - Functions for wxLayoutAlgorithm class

DESCRIPTION

       wxLayoutAlgorithm implements layout of subwindows in MDI or SDI frames. It sends a wxCalculateLayoutEvent
       (not implemented in wx) event to children of the frame, asking them for information about their size. For
       MDI  parent  frames, the algorithm allocates the remaining space to the MDI client window (which contains
       the MDI child frames).

       For SDI (normal) frames, a 'main' window is specified as taking up the remaining space.

       Because the event system is used, this technique can be applied to any windows, which are not necessarily
       'aware' of the layout classes (no virtual  functions  in  wxWindow  refer  to  wxLayoutAlgorithm  or  its
       events).  However,  you  may wish to use wxSashLayoutWindow for your subwindows since this class provides
       handlers for the required events, and accessors to specify the desired  size  of  the  window.  The  sash
       behaviour in the base class can be used, optionally, to make the windows user-resizable.

       wxLayoutAlgorithm is typically used in IDE (integrated development environment) applications, where there
       are  several  resizable  windows  in  addition to the MDI client window, or other primary editing window.
       Resizable windows might include toolbars, a project window, and a window for displaying error and warning
       messages.

       When a window receives an OnCalculateLayout event, it should call SetRect in the given event  object,  to
       be  the  old supplied rectangle minus whatever space the window takes up. It should also set its own size
       accordingly. wxSashLayoutWindow::OnCalculateLayout (not implemented in wx) generates an OnQueryLayoutInfo
       event which it sends to itself to determine the orientation, alignment and size of the window,  which  it
       gets from internal member variables set by the application.

       The  algorithm  works  by starting off with a rectangle equal to the whole frame client area. It iterates
       through the frame children, generating wxLayoutAlgorithm::OnCalculateLayout  events  which  subtract  the
       window  size  and  return  the  remaining  rectangle  for  the  next window to process. It is assumed (by
       wxSashLayoutWindow::OnCalculateLayout (not implemented in wx)) that a window stretches the full dimension
       of the frame client, according to the orientation it specifies. For example,  a  horizontal  window  will
       stretch  the  full width of the remaining portion of the frame client area. In the other orientation, the
       window will be fixed to whatever size was specified by wxLayoutAlgorithm::OnQueryLayoutInfo. An alignment
       setting will make the window 'stick' to the left, top, right or bottom of the remaining client area. This
       scheme implies that order of window creation is important. Say you wish to have an extra toolbar  at  the
       top  of  the frame, a project window to the left of the MDI client window, and an output window above the
       status bar. You should therefore create the windows  in  this  order:  toolbar,  output  window,  project
       window. This ensures that the toolbar and output window take up space at the top and bottom, and then the
       remaining height in-between is used for the project window.

       wxLayoutAlgorithm  is  quite independent of the way in which wxLayoutAlgorithm::OnCalculateLayout chooses
       to interpret a window's size and alignment. Therefore you could implement a different window class with a
       new wxLayoutAlgorithm::OnCalculateLayout event handler, that has a more sophisticated way of  laying  out
       the  windows. It might allow specification of whether stretching occurs in the specified orientation, for
       example, rather than always assuming stretching. (This could,  and  probably  should,  be  added  to  the
       existing implementation).

       Note:  wxLayoutAlgorithm  has  nothing  to  do with wxLayoutConstraints (not implemented in wx). It is an
       alternative way of specifying layouts for which the normal constraint system is unsuitable.

       See: wxSashEvent, wxSashLayoutWindow, Overview events

       wxWidgets docs: wxLayoutAlgorithm

DATA TYPES

       wxLayoutAlgorithm() = wx:wx_object()

EXPORTS

       new() -> wxLayoutAlgorithm()

              Default constructor.

       destroy(This :: wxLayoutAlgorithm()) -> ok

              Destructor.

       layoutFrame(This, Frame) -> boolean()

              Types:

                 This = wxLayoutAlgorithm()
                 Frame = wxFrame:wxFrame()

       layoutFrame(This, Frame, Options :: [Option]) -> boolean()

              Types:

                 This = wxLayoutAlgorithm()
                 Frame = wxFrame:wxFrame()
                 Option = {mainWindow, wxWindow:wxWindow()}

              Lays out the children of a normal frame.

              mainWindow is set to occupy the remaining space. This function simply calls layoutWindow/3.

       layoutMDIFrame(This, Frame) -> boolean()

              Types:

                 This = wxLayoutAlgorithm()
                 Frame = wxMDIParentFrame:wxMDIParentFrame()

       layoutMDIFrame(This, Frame, Options :: [Option]) -> boolean()

              Types:

                 This = wxLayoutAlgorithm()
                 Frame = wxMDIParentFrame:wxMDIParentFrame()
                 Option =
                     {rect,
                      {X :: integer(),
                       Y :: integer(),
                       W :: integer(),
                       H :: integer()}}

              Lays out the children of an MDI parent frame.

              If rect is non-NULL, the given rectangle will be used as a starting point instead of  the  frame's
              client area. The MDI client window is set to occupy the remaining space.

       layoutWindow(This, Parent) -> boolean()

              Types:

                 This = wxLayoutAlgorithm()
                 Parent = wxWindow:wxWindow()

       layoutWindow(This, Parent, Options :: [Option]) -> boolean()

              Types:

                 This = wxLayoutAlgorithm()
                 Parent = wxWindow:wxWindow()
                 Option = {mainWindow, wxWindow:wxWindow()}

              Lays out the children of a normal frame or other window.

              mainWindow  is  set  to occupy the remaining space. If this is not specified, then the last window
              that responds to a calculate layout event in query mode will get the remaining space (that  is,  a
              non-query  OnCalculateLayout  event  will not be sent to this window and the window will be set to
              the remaining size).

wxWidgets team.                                    wx 2.2.2.1                            wxLayoutAlgorithm(3erl)