Main Page | Namespace List | Class Hierarchy | Class List | Directories | File List | Namespace Members | Class Members | File Members | Search for 
wxXtra

framemanager.cpp File Reference

(r1785/r1769)

#include "framemanager.h"
#include "dockart.h"
#include "floatpane.h"
#include <wx/settings.h>
#include <wx/app.h>
#include <wx/dcclient.h>
#include <wx/dcscreen.h>
#include <wx/toolbar.h>
#include <wx/mdi.h>
#include <wx/image.h>
#include <wx/arrimpl.cpp>

Go to the source code of this file.

Classes

class  wxPseudoTransparentFrame

Functions

 WX_DECLARE_OBJARRAY (wxRect, wxAuiRectArray)
static wxBitmap wxPaneCreateStippleBitmap ()
static void DrawResizeHint (wxDC &dc, const wxRect &rect)
static void CopyDocksAndPanes (wxAuiDockInfoArray &dest_docks, wxAuiPaneInfoArray &dest_panes, const wxAuiDockInfoArray &src_docks, const wxAuiPaneInfoArray &src_panes)
static int GetMaxLayer (const wxAuiDockInfoArray &docks, int dock_direction)
static int GetMaxRow (const wxAuiPaneInfoArray &panes, int direction, int layer)
static void DoInsertDockLayer (wxAuiPaneInfoArray &panes, int dock_direction, int dock_layer)
static void DoInsertDockRow (wxAuiPaneInfoArray &panes, int dock_direction, int dock_layer, int dock_row)
static void DoInsertPane (wxAuiPaneInfoArray &panes, int dock_direction, int dock_layer, int dock_row, int dock_pos)
static void FindDocks (wxAuiDockInfoArray &docks, int dock_direction, int dock_layer, int dock_row, wxAuiDockInfoPtrArray &arr)
static wxAuiPaneInfo * FindPaneInDock (const wxAuiDockInfo &dock, wxWindow *window)
static void RemovePaneFromDocks (wxAuiDockInfoArray &docks, wxAuiPaneInfo &pane, wxAuiDockInfo *except=NULL)
static void RenumberDockRows (wxAuiDockInfoPtrArray &docks)
static void SetActivePane (wxAuiPaneInfoArray &panes, wxWindow *active_pane)
static int PaneSortFunc (wxAuiPaneInfo **p1, wxAuiPaneInfo **p2)
 wx__DECLARE_EVT0 (wxEVT_AUI_PANE_BUTTON,(wxObjectEventFunction)(wxEventFunction) wxStaticCastEvent(wxAuiManagerEventFunction,&wxAuiManager::OnPaneButton)) wx__DECLARE_EVT0(wxEVT_AUI_RENDER
static wxString EscapeDelimiters (const wxString &s)

Variables

wxAuiPaneInfo wxAuiNullPaneInfo
wxAuiDockInfo wxAuiNullDockInfo
( wxObjectEventFunction )(wxEventFunction) wxStaticCastEvent(wxAuiManagerEventFunction
const int auiInsertRowPixels = 10
const int auiNewRowPixels = 40
const int auiLayerInsertPixels = 40
const int auiLayerInsertOffset = 5

Function Documentation

static void CopyDocksAndPanes (  wxAuiDockInfoArray &  dest_docks,
wxAuiPaneInfoArray &  dest_panes,
const wxAuiDockInfoArray &  src_docks,
const wxAuiPaneInfoArray &  src_panes
)  [static]
 

Definition at line 186 of file framemanager.cpp.

00190 {
00191     dest_docks = src_docks;
00192     dest_panes = src_panes;
00193     int i, j, k, dock_count, pc1, pc2;
00194     for (i = 0, dock_count = dest_docks.GetCount(); i < dock_count; ++i)
00195     {
00196         wxAuiDockInfo& dock = dest_docks.Item(i);
00197         for (j = 0, pc1 = dock.panes.GetCount(); j < pc1; ++j)
00198             for (k = 0, pc2 = src_panes.GetCount(); k < pc2; ++k)
00199                 if (dock.panes.Item(j) == &src_panes.Item(k))
00200                     dock.panes.Item(j) = &dest_panes.Item(k);
00201     }
00202 }

static void DoInsertDockLayer (  wxAuiPaneInfoArray &  panes,
int  dock_direction,
int  dock_layer
)  [static]
 

Definition at line 240 of file framemanager.cpp.

00243 {
00244     int i, pane_count;
00245     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
00246     {
00247         wxAuiPaneInfo& pane = panes.Item(i);
00248         if (!pane.IsFloating() &&
00249             pane.dock_direction == dock_direction &&
00250             pane.dock_layer >= dock_layer)
00251                 pane.dock_layer++;
00252     }
00253 }

static void DoInsertDockRow (  wxAuiPaneInfoArray &  panes,
int  dock_direction,
int  dock_layer,
int  dock_row
)  [static]
 

Definition at line 257 of file framemanager.cpp.

00261 {
00262     int i, pane_count;
00263     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
00264     {
00265         wxAuiPaneInfo& pane = panes.Item(i);
00266         if (!pane.IsFloating() &&
00267             pane.dock_direction == dock_direction &&
00268             pane.dock_layer == dock_layer &&
00269             pane.dock_row >= dock_row)
00270                 pane.dock_row++;
00271     }
00272 }

static void DoInsertPane (  wxAuiPaneInfoArray &  panes,
int  dock_direction,
int  dock_layer,
int  dock_row,
int  dock_pos
)  [static]
 

Definition at line 276 of file framemanager.cpp.

00281 {
00282     int i, pane_count;
00283     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
00284     {
00285         wxAuiPaneInfo& pane = panes.Item(i);
00286         if (!pane.IsFloating() &&
00287             pane.dock_direction == dock_direction &&
00288             pane.dock_layer == dock_layer &&
00289             pane.dock_row == dock_row &&
00290             pane.dock_pos >= dock_pos)
00291                 pane.dock_pos++;
00292     }
00293 }

static void DrawResizeHint (  wxDC &  dc,
const wxRect &  rect
)  [static]
 

Definition at line 168 of file framemanager.cpp.

00169 {
00170     wxBitmap stipple = wxPaneCreateStippleBitmap();
00171     wxBrush brush(stipple);
00172     dc.SetBrush(brush);
00173     dc.SetPen(*wxTRANSPARENT_PEN);
00174 
00175     dc.SetLogicalFunction(wxXOR);
00176     dc.DrawRectangle(rect);
00177 }

static wxString EscapeDelimiters (  const wxString &  s  )  [static]
 

Definition at line 906 of file framemanager.cpp.

00907 {
00908     wxString result;
00909     result.Alloc(s.length());
00910     const wxChar* ch = s.c_str();
00911     while (*ch)
00912     {
00913         if (*ch == wxT(';') || *ch == wxT('|'))
00914             result += wxT('\\');
00915         result += *ch;
00916         ++ch;
00917     }
00918     return result;
00919 }

static void FindDocks (  wxAuiDockInfoArray &  docks,
int  dock_direction,
int  dock_layer,
int  dock_row,
wxAuiDockInfoPtrArray &  arr
)  [static]
 

Definition at line 298 of file framemanager.cpp.

00303 {
00304     int begin_layer = dock_layer;
00305     int end_layer = dock_layer;
00306     int begin_row = dock_row;
00307     int end_row = dock_row;
00308     int dock_count = docks.GetCount();
00309     int layer, row, i, max_row = 0, max_layer = 0;
00310 
00311     // discover the maximum dock layer and the max row
00312     for (i = 0; i < dock_count; ++i)
00313     {
00314         max_row = wxMax(max_row, docks.Item(i).dock_row);
00315         max_layer = wxMax(max_layer, docks.Item(i).dock_layer);
00316     }
00317 
00318     // if no dock layer was specified, search all dock layers
00319     if (dock_layer == -1)
00320     {
00321         begin_layer = 0;
00322         end_layer = max_layer;
00323     }
00324 
00325     // if no dock row was specified, search all dock row
00326     if (dock_row == -1)
00327     {
00328         begin_row = 0;
00329         end_row = max_row;
00330     }
00331 
00332     arr.Clear();
00333 
00334     for (layer = begin_layer; layer <= end_layer; ++layer)
00335         for (row = begin_row; row <= end_row; ++row)
00336             for (i = 0; i < dock_count; ++i)
00337             {
00338                 wxAuiDockInfo& d = docks.Item(i);
00339                 if (dock_direction == -1 || dock_direction == d.dock_direction)
00340                 {
00341                     if (d.dock_layer == layer && d.dock_row == row)
00342                         arr.Add(&d);
00343                 }
00344             }
00345 }

static wxAuiPaneInfo* FindPaneInDock (  const wxAuiDockInfo &  dock,
wxWindow *  window
)  [static]
 

Definition at line 349 of file framemanager.cpp.

00350 {
00351     int i, count = dock.panes.GetCount();
00352     for (i = 0; i < count; ++i)
00353     {
00354         wxAuiPaneInfo* p = dock.panes.Item(i);
00355         if (p->window == window)
00356             return p;
00357     }
00358     return NULL;
00359 }

static int GetMaxLayer (  const wxAuiDockInfoArray &  docks,
int  dock_direction
)  [static]
 

Definition at line 206 of file framemanager.cpp.

00207 {
00208     int i, dock_count, max_layer = 0;
00209     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
00210     {
00211         wxAuiDockInfo& dock = docks.Item(i);
00212         if (dock.dock_direction == dock_direction &&
00213             dock.dock_layer > max_layer && !dock.fixed)
00214                 max_layer = dock.dock_layer;
00215     }
00216     return max_layer;
00217 }

static int GetMaxRow (  const wxAuiPaneInfoArray &  panes,
int  direction,
int  layer
)  [static]
 

Definition at line 222 of file framemanager.cpp.

00223 {
00224     int i, pane_count, max_row = 0;
00225     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
00226     {
00227         wxAuiPaneInfo& pane = panes.Item(i);
00228         if (pane.dock_direction == direction &&
00229             pane.dock_layer == layer &&
00230             pane.dock_row > max_row)
00231                 max_row = pane.dock_row;
00232     }
00233     return max_row;
00234 }

static int PaneSortFunc (  wxAuiPaneInfo **  p1,
wxAuiPaneInfo **  p2
)  [static]
 

Definition at line 412 of file framemanager.cpp.

00413 {
00414     return ((*p1)->dock_pos < (*p2)->dock_pos) ? -1 : 1;
00415 }

static void RemovePaneFromDocks (  wxAuiDockInfoArray &  docks,
wxAuiPaneInfo &  pane,
wxAuiDockInfo *  except = NULL
)  [static]
 

Definition at line 363 of file framemanager.cpp.

00366 {
00367     int i, dock_count;
00368     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
00369     {
00370         wxAuiDockInfo& d = docks.Item(i);
00371         if (&d == except)
00372             continue;
00373         wxAuiPaneInfo* pi = FindPaneInDock(d, pane.window);
00374         if (pi)
00375             d.panes.Remove(pi);
00376     }
00377 }

static void RenumberDockRows (  wxAuiDockInfoPtrArray &  docks  )  [static]
 

Definition at line 382 of file framemanager.cpp.

00383 {
00384     int i, dock_count, j, pane_count;
00385     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
00386     {
00387         wxAuiDockInfo& dock = *docks.Item(i);
00388         dock.dock_row = i;
00389         for (j = 0, pane_count = dock.panes.GetCount(); j < pane_count; ++j)
00390             dock.panes.Item(j)->dock_row = i;
00391     }
00392 }

static void SetActivePane (  wxAuiPaneInfoArray &  panes,
wxWindow *  active_pane
)  [static]
 

Definition at line 398 of file framemanager.cpp.

00399 {
00400     int i, pane_count;
00401     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
00402     {
00403         wxAuiPaneInfo& pane = panes.Item(i);
00404         pane.state &= ~wxAuiPaneInfo::optionActive;
00405         if (pane.window == active_pane)
00406             pane.state |= wxAuiPaneInfo::optionActive;
00407     }
00408 }

wx__DECLARE_EVT0 (  wxEVT_AUI_PANE_BUTTON  ,
(wxObjectEventFunction)(wxEventFunction) wxStaticCastEvent(wxAuiManagerEventFunction,&wxAuiManager::OnPaneButton) 
) 
 

WX_DECLARE_OBJARRAY (  wxRect  ,
wxAuiRectArray 
) 
 

static wxBitmap wxPaneCreateStippleBitmap (   )  [static]
 

Definition at line 161 of file framemanager.cpp.

00162 {
00163     unsigned char data[] = { 0,0,0,192,192,192, 192,192,192,0,0,0 };
00164     wxImage img(2,2,data,true);
00165     return wxBitmap(img);
00166 }

Variable Documentation

const int auiInsertRowPixels = 10
 

Definition at line 2244 of file framemanager.cpp.

const int auiLayerInsertOffset = 5
 

Definition at line 2247 of file framemanager.cpp.

const int auiLayerInsertPixels = 40
 

Definition at line 2246 of file framemanager.cpp.

const int auiNewRowPixels = 40
 

Definition at line 2245 of file framemanager.cpp.

wxAuiDockInfo wxAuiNullDockInfo
 

Definition at line 43 of file framemanager.cpp.

wxAuiPaneInfo wxAuiNullPaneInfo
 

Definition at line 42 of file framemanager.cpp.

( wxObjectEventFunction)(wxEventFunction) wxStaticCastEvent(wxAuiManagerEventFunction
 

Generated on Sat Nov 10 03:49:37 2007 for Camelot by  doxygen 1.4.4