[wxWidgets.git] / src / generic / laywin.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/generic/laywin.cpp
// Purpose:     Implements a simple layout algorithm, plus
//              wxSashLayoutWindow which is an example of a window with
//              layout-awareness (via event handlers). This is suited to
//              IDE-style window layout.
// Author:      Julian Smart
// Modified by:
// Created:     04/01/98
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/frame.h"
#endif

#include "wx/laywin.h"
#include "wx/mdi.h"


IMPLEMENT_DYNAMIC_CLASS(wxQueryLayoutInfoEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxCalculateLayoutEvent, wxEvent)

wxDEFINE_EVENT( wxEVT_QUERY_LAYOUT_INFO, wxQueryLayoutInfoEvent );
wxDEFINE_EVENT( wxEVT_CALCULATE_LAYOUT, wxCalculateLayoutEvent );


// ----------------------------------------------------------------------------
// wxSashLayoutWindow
// ----------------------------------------------------------------------------

#if wxUSE_SASH
IMPLEMENT_CLASS(wxSashLayoutWindow, wxSashWindow)
BEGIN_EVENT_TABLE(wxSashLayoutWindow, wxSashWindow)
    EVT_CALCULATE_LAYOUT(wxSashLayoutWindow::OnCalculateLayout)
    EVT_QUERY_LAYOUT_INFO(wxSashLayoutWindow::OnQueryLayoutInfo)
END_EVENT_TABLE()

bool wxSashLayoutWindow::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos,
        const wxSize& size, long style, const wxString& name)
{
    return wxSashWindow::Create(parent, id, pos, size, style, name);
}

void wxSashLayoutWindow::Init()
{
    m_orientation = wxLAYOUT_HORIZONTAL;
    m_alignment = wxLAYOUT_TOP;
#ifdef __WXMAC__
    MacSetClipChildren( true ) ;
#endif
}

// This is the function that wxLayoutAlgorithm calls to ascertain the window
// dimensions.
void wxSashLayoutWindow::OnQueryLayoutInfo(wxQueryLayoutInfoEvent& event)
{
  //    int flags = event.GetFlags();
    int requestedLength = event.GetRequestedLength();

    event.SetOrientation(m_orientation);
    event.SetAlignment(m_alignment);

    if (m_orientation == wxLAYOUT_HORIZONTAL)
        event.SetSize(wxSize(requestedLength, m_defaultSize.y));
    else
        event.SetSize(wxSize(m_defaultSize.x, requestedLength));
}

// Called by parent to allow window to take a bit out of the
// client rectangle, and size itself if not in wxLAYOUT_QUERY mode.

void wxSashLayoutWindow::OnCalculateLayout(wxCalculateLayoutEvent& event)
{
    wxRect clientSize(event.GetRect());

    int flags = event.GetFlags();

    if (!IsShown())
        return;

    // Let's assume that all windows stretch the full extent of the window in
    // the direction of that window orientation. This will work for non-docking toolbars,
    // and the status bar. Note that the windows have to have been created in a certain
    // order to work, else you might get a left-aligned window going to the bottom
    // of the window, and the status bar appearing to the right of it. The
    // status bar would have to be created after or before the toolbar(s).

    wxRect thisRect;

    // Try to stretch
    int length = (GetOrientation() == wxLAYOUT_HORIZONTAL) ? clientSize.width : clientSize.height;
    wxLayoutOrientation orient = GetOrientation();

    // We assume that a window that says it's horizontal, wants to be stretched in that
    // direction. Is this distinction too fine? Do we assume that any horizontal
    // window needs to be stretched in that direction? Possibly.
    int whichDimension = (GetOrientation() == wxLAYOUT_HORIZONTAL) ? wxLAYOUT_LENGTH_X : wxLAYOUT_LENGTH_Y;

    wxQueryLayoutInfoEvent infoEvent(GetId());
    infoEvent.SetEventObject(this);
    infoEvent.SetRequestedLength(length);
    infoEvent.SetFlags(orient | whichDimension);

    if (!GetEventHandler()->ProcessEvent(infoEvent))
        return;

    wxSize sz = infoEvent.GetSize();

    if (sz.x == 0 && sz.y == 0) // Assume it's invisible
        return;

    // Now we know the size it wants to be. We wish to decide where to place it, i.e.
    // how it's aligned.
    switch (GetAlignment())
    {
        case wxLAYOUT_TOP:
        {
            thisRect.x = clientSize.x; thisRect.y = clientSize.y;
            thisRect.width = sz.x; thisRect.height = sz.y;
            clientSize.y += thisRect.height;
            clientSize.height -= thisRect.height;
            break;
        }
        case wxLAYOUT_LEFT:
        {
            thisRect.x = clientSize.x; thisRect.y = clientSize.y;
            thisRect.width = sz.x; thisRect.height = sz.y;
            clientSize.x += thisRect.width;
            clientSize.width -= thisRect.width;
            break;
        }
        case wxLAYOUT_RIGHT:
        {
            thisRect.x = clientSize.x + (clientSize.width - sz.x); thisRect.y = clientSize.y;
            thisRect.width = sz.x; thisRect.height = sz.y;
            clientSize.width -= thisRect.width;
            break;
        }
        case wxLAYOUT_BOTTOM:
        {
            thisRect.x = clientSize.x; thisRect.y = clientSize.y + (clientSize.height - sz.y);
            thisRect.width = sz.x; thisRect.height = sz.y;
            clientSize.height -= thisRect.height;
            break;
        }
        case wxLAYOUT_NONE:
        {
            break;
        }

    }

    if ((flags & wxLAYOUT_QUERY) == 0)
    {
        // If not in query mode, resize the window.
        // TODO: add wxRect& form to wxWindow::SetSize
        wxSize sz2 = GetSize();
        wxPoint pos = GetPosition();
        SetSize(thisRect.x, thisRect.y, thisRect.width, thisRect.height);

        // Make sure the sash is erased when the window is resized
        if ((pos.x != thisRect.x || pos.y != thisRect.y || sz2.x != thisRect.width || sz2.y != thisRect.height) &&
            (GetSashVisible(wxSASH_TOP) || GetSashVisible(wxSASH_RIGHT) || GetSashVisible(wxSASH_BOTTOM) || GetSashVisible(wxSASH_LEFT)))
            Refresh(true);

    }

    event.SetRect(clientSize);
}
#endif // wxUSE_SASH


// ----------------------------------------------------------------------------
// wxLayoutAlgorithm
// ----------------------------------------------------------------------------

#if wxUSE_MDI_ARCHITECTURE

// Lays out windows for an MDI frame. The MDI client area gets what's left
// over.
bool wxLayoutAlgorithm::LayoutMDIFrame(wxMDIParentFrame* frame, wxRect* r)
{
    int cw, ch;
    frame->GetClientSize(& cw, & ch);

    wxRect rect(0, 0, cw, ch);
    if (r)
        rect = * r;

    wxCalculateLayoutEvent event;
    event.SetRect(rect);

    wxWindowList::compatibility_iterator node = frame->GetChildren().GetFirst();
    while (node)
    {
        wxWindow* win = node->GetData();

        event.SetId(win->GetId());
        event.SetEventObject(win);
        event.SetFlags(0); // ??

        win->GetEventHandler()->ProcessEvent(event);

        node = node->GetNext();
    }

    wxWindow* clientWindow = frame->GetClientWindow();

    rect = event.GetRect();

    clientWindow->SetSize(rect.x, rect.y, rect.width, rect.height);

    return true;
}

#endif // wxUSE_MDI_ARCHITECTURE

bool wxLayoutAlgorithm::LayoutFrame(wxFrame* frame, wxWindow* mainWindow)
{
    return LayoutWindow(frame, mainWindow);
}

// Layout algorithm for any window. mainWindow gets what's left over.
bool wxLayoutAlgorithm::LayoutWindow(wxWindow* parent, wxWindow* mainWindow)
{
    // Test if the parent is a sash window, and if so,
    // reduce the available space to allow space for any active edges.

    int leftMargin = 0, rightMargin = 0, topMargin = 0, bottomMargin = 0;
#if wxUSE_SASH
    if (wxDynamicCast(parent, wxSashWindow))
    {
        wxSashWindow* sashWindow = (wxSashWindow*) parent;

        leftMargin = sashWindow->GetExtraBorderSize();
        rightMargin = sashWindow->GetExtraBorderSize();
        topMargin = sashWindow->GetExtraBorderSize();
        bottomMargin = sashWindow->GetExtraBorderSize();

        if (sashWindow->GetSashVisible(wxSASH_LEFT))
            leftMargin += sashWindow->GetDefaultBorderSize();
        if (sashWindow->GetSashVisible(wxSASH_RIGHT))
            rightMargin += sashWindow->GetDefaultBorderSize();
        if (sashWindow->GetSashVisible(wxSASH_TOP))
            topMargin += sashWindow->GetDefaultBorderSize();
        if (sashWindow->GetSashVisible(wxSASH_BOTTOM))
            bottomMargin += sashWindow->GetDefaultBorderSize();
    }
#endif // wxUSE_SASH

    int cw, ch;
    parent->GetClientSize(& cw, & ch);

    wxRect rect(leftMargin, topMargin, cw - leftMargin - rightMargin, ch - topMargin - bottomMargin);

    wxCalculateLayoutEvent event;
    event.SetRect(rect);

    // Find the last layout-aware window, so we can make it fill all remaining
    // space.
    wxWindow *lastAwareWindow = NULL;
    wxWindowList::compatibility_iterator node = parent->GetChildren().GetFirst();

    while (node)
    {
        wxWindow* win = node->GetData();

        if (win->IsShown())
        {
            wxCalculateLayoutEvent tempEvent(win->GetId());
            tempEvent.SetEventObject(win);
            tempEvent.SetFlags(wxLAYOUT_QUERY);
            tempEvent.SetRect(event.GetRect());
            if (win->GetEventHandler()->ProcessEvent(tempEvent))
                lastAwareWindow = win;
        }

        node = node->GetNext();
    }

    // Now do a dummy run to see if we have any space left for the final window (fail if not)
    node = parent->GetChildren().GetFirst();
    while (node)
    {
        wxWindow* win = node->GetData();

        // If mainWindow is NULL and we're at the last window,
        // skip this, because we'll simply make it fit the remaining space.
        if (win->IsShown() && (win != mainWindow) && (mainWindow != NULL || win != lastAwareWindow))
        {
            event.SetId(win->GetId());
            event.SetEventObject(win);
            event.SetFlags(wxLAYOUT_QUERY);

            win->GetEventHandler()->ProcessEvent(event);
        }

        node = node->GetNext();
    }

    if (event.GetRect().GetWidth() < 0 || event.GetRect().GetHeight() < 0)
        return false;

    event.SetRect(rect);

    node = parent->GetChildren().GetFirst();
    while (node)
    {
        wxWindow* win = node->GetData();

        // If mainWindow is NULL and we're at the last window,
        // skip this, because we'll simply make it fit the remaining space.
        if (win->IsShown() && (win != mainWindow) && (mainWindow != NULL || win != lastAwareWindow))
        {
            event.SetId(win->GetId());
            event.SetEventObject(win);
            event.SetFlags(0); // ??

            win->GetEventHandler()->ProcessEvent(event);
        }

        node = node->GetNext();
    }

    rect = event.GetRect();

    if (mainWindow)
        mainWindow->SetSize(rect.x, rect.y, wxMax(0, rect.width), wxMax(0, rect.height));
    else if (lastAwareWindow)
    {
        // Fit the remaining space
        lastAwareWindow->SetSize(rect.x, rect.y, wxMax(0, rect.width), wxMax(0, rect.height));
    }

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