src/generic/splitter.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        splitter.cpp
// Purpose:     wxSplitterWindow implementation
// Author:      Julian Smart
// Modified by:
// Created:     01/02/97
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart and Markus Holzem
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
    #pragma implementation "splitter.h"
#endif

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

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

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

#include <math.h>
#include <stdlib.h>

#include "wx/string.h"
#include "wx/splitter.h"
#include "wx/dcscreen.h"

#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxSplitterWindow, wxWindow)

BEGIN_EVENT_TABLE(wxSplitterWindow, wxWindow)
    EVT_PAINT(wxSplitterWindow::OnPaint)
    EVT_SIZE(wxSplitterWindow::OnSize)
    EVT_MOUSE_EVENTS(wxSplitterWindow::OnMouseEvent)
END_EVENT_TABLE()
#endif

wxSplitterWindow::wxSplitterWindow()
{
    m_splitMode = wxSPLIT_VERTICAL;
    m_windowOne = (wxWindow *) NULL;
    m_windowTwo = (wxWindow *) NULL;
    m_dragMode = wxSPLIT_DRAG_NONE;
    m_oldX = 0;
    m_oldY = 0;
    m_firstX = 0;
    m_firstY = 0;
    m_sashSize = 7;
    m_borderSize = 2;
    m_sashPosition = 0;
    m_sashCursorWE = (wxCursor *) NULL;
    m_sashCursorNS = (wxCursor *) NULL;
    m_sashTrackerPen = (wxPen *) NULL;
    m_lightShadowPen = (wxPen *) NULL;
    m_mediumShadowPen = (wxPen *) NULL;
    m_darkShadowPen = (wxPen *) NULL;
    m_faceBrush = (wxBrush *) NULL;
    m_facePen = (wxPen *) NULL;
    m_hilightPen = (wxPen *) NULL;
    m_minimumPaneSize = 0;
}

wxSplitterWindow::wxSplitterWindow(wxWindow *parent, wxWindowID id,
                                   const wxPoint& pos,
                                   const wxSize& size,
                                   long style,
                                   const wxString& name)
                : wxWindow(parent, id, pos, size, style, name)
{
    m_splitMode = wxSPLIT_VERTICAL;
    m_windowOne = (wxWindow *) NULL;
    m_windowTwo = (wxWindow *) NULL;
    m_dragMode = wxSPLIT_DRAG_NONE;
    m_oldX = 0;
    m_oldY = 0;
    m_firstX = 0;
    m_firstY = 0;
    m_sashSize = 7;
    m_borderSize = 2;
    m_sashPosition = 0;
    m_minimumPaneSize = 0;
    m_sashCursorWE = new wxCursor(wxCURSOR_SIZEWE);
    m_sashCursorNS = new wxCursor(wxCURSOR_SIZENS);
    m_sashTrackerPen = new wxPen(*wxBLACK, 2, wxSOLID);
    m_lightShadowPen = (wxPen *) NULL;
    m_mediumShadowPen = (wxPen *) NULL;
    m_darkShadowPen = (wxPen *) NULL;
    m_faceBrush = (wxBrush *) NULL;
    m_facePen = (wxPen *) NULL;
    m_hilightPen = (wxPen *) NULL;

    if ( style & wxSP_3D )
    {
        m_borderSize = 2;
        m_sashSize = 7;
    }
    else if ( style & wxSP_BORDER )
    {
        m_borderSize = 1;
        m_sashSize = 3;
    }
    else
    {
        m_borderSize = 0;
        m_sashSize = 3;
    }

    // Eventually, we'll respond to colour change messages
    InitColours();

    // For debugging purposes, to see the background.
//    SetBackground(wxBLUE_BRUSH);
}

wxSplitterWindow::~wxSplitterWindow()
{
    delete m_sashCursorWE;
    delete m_sashCursorNS;
    delete m_sashTrackerPen;
    delete m_lightShadowPen;
    delete m_darkShadowPen;
    delete m_mediumShadowPen;
    delete m_hilightPen;
    delete m_facePen;
    delete m_faceBrush;
}

void wxSplitterWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
{
    wxPaintDC dc(this);

    if ( m_borderSize > 0 )
        DrawBorders(dc);
    DrawSash(dc);
}


void wxSplitterWindow::OnMouseEvent(wxMouseEvent& event)
{
    long x = event.GetX();
    long y = event.GetY();

    // reset the cursor
#ifdef __WXMOTIF__
    SetCursor(* wxSTANDARD_CURSOR);
#endif
#ifdef __WXMSW__
    SetCursor(wxCursor());
#endif

    // under wxGTK the method above causes the mouse
    // to flicker so we set the standard cursor only
    // when leaving the window and when moving over
    // non-sash parts of the window. this should work
    // on the other platforms as well, but who knows.
#ifdef __WXGTK__
    if (event.Leaving())
        SetCursor(* wxSTANDARD_CURSOR);
#endif

    if (event.LeftDown())
    {
        if ( SashHitTest(x, y) )
        {
            CaptureMouse();

            m_dragMode = wxSPLIT_DRAG_DRAGGING;

            DrawSashTracker(x, y);
            m_oldX = x;
            m_oldY = y;
            return;
        }
    }
    else if (event.LeftUp() && m_dragMode == wxSPLIT_DRAG_DRAGGING)
    {
        // We can stop dragging now and see what we've got.
        m_dragMode = wxSPLIT_DRAG_NONE;
        ReleaseMouse();

        // Erase old tracker
        DrawSashTracker(m_oldX, m_oldY);

        // Obtain window size. We are only interested in the dimension the sash
        // splits up
        int w, h;
        GetClientSize(&w, &h);
        int window_size = (m_splitMode == wxSPLIT_VERTICAL ? w : h );
        int new_sash_position =
            (int) ( m_splitMode == wxSPLIT_VERTICAL ? x : y );

        if ( !OnSashPositionChange(new_sash_position) )
            return;

        if ( new_sash_position == 0 )
        {
            // We remove the first window from the view
            wxWindow *removedWindow = m_windowOne;
            m_windowOne = m_windowTwo;
            m_windowTwo = (wxWindow *) NULL;
            OnUnsplit(removedWindow);
            m_sashPosition = 0;
        }
        else if ( new_sash_position == window_size )
        {
            // We remove the second window from the view
            wxWindow *removedWindow = m_windowTwo;
            m_windowTwo = (wxWindow *) NULL;
            OnUnsplit(removedWindow);
            m_sashPosition = 0;
        }
        else
        {
            m_sashPosition = new_sash_position;
        }
        SizeWindows();
    }  // left up && dragging
    else if (event.Moving() && !event.Dragging())
    {
        // Just change the cursor if required
        if ( SashHitTest(x, y) )
        {
                if ( m_splitMode == wxSPLIT_VERTICAL )
                {
                    SetCursor(*m_sashCursorWE);
                }
                else
                {
                    SetCursor(*m_sashCursorNS);
                }
        }
#ifdef __WXGTK__
        else
	{
	    // where else do we unset the cursor?
            SetCursor(* wxSTANDARD_CURSOR);
	}
#endif
    }
    else if (event.Dragging() && (m_dragMode == wxSPLIT_DRAG_DRAGGING))
    {
        // Erase old tracker
        DrawSashTracker(m_oldX, m_oldY);

        // Draw new one
        DrawSashTracker(x, y);

        m_oldX = x;
        m_oldY = y;
    }
    else if ( event.LeftDClick() )
    {
        OnDoubleClickSash(x, y);
    }
}

void wxSplitterWindow::OnSize(wxSizeEvent& WXUNUSED(event))
{
    int cw, ch;
    GetClientSize( &cw, &ch );
    if ( m_windowTwo )
    {
        if ( m_splitMode == wxSPLIT_VERTICAL )
        {
            if ( m_sashPosition >= (cw - 5) )
                m_sashPosition = wxMax(10, cw - 40);
        }
        if ( m_splitMode == wxSPLIT_HORIZONTAL )
        {
            if ( m_sashPosition >= (ch - 5) )
                m_sashPosition = wxMax(10, ch - 40);
        }
    }
    SizeWindows();
}

bool wxSplitterWindow::SashHitTest(int x, int y, int tolerance)
{
    if ( m_windowTwo == NULL || m_sashPosition == 0)
        return FALSE; // No sash

    if ( m_splitMode == wxSPLIT_VERTICAL )
    {
        if ( (x >= m_sashPosition - tolerance) && (x <= m_sashPosition + m_sashSize + tolerance) )
            return TRUE;
        else
            return FALSE;
    }
    else
    {
        if ( (y >= (m_sashPosition- tolerance)) && (y <= (m_sashPosition + m_sashSize + tolerance)) )
            return TRUE;
        else
            return FALSE;
    }

    return FALSE;
}

// Draw 3D effect borders
void wxSplitterWindow::DrawBorders(wxDC& dc)
{
    int w, h;
    GetClientSize(&w, &h);

    if ( GetWindowStyleFlag() & wxSP_3D )
    {
        dc.SetPen(*m_mediumShadowPen);
        dc.DrawLine(0, 0, w-1, 0);
        dc.DrawLine(0, 0, 0, h - 1);

        dc.SetPen(*m_darkShadowPen);
        dc.DrawLine(1, 1, w-2, 1);
        dc.DrawLine(1, 1, 1, h-2);

        dc.SetPen(*m_hilightPen);
        dc.DrawLine(0, h-1, w-1, h-1);
        dc.DrawLine(w-1, 0, w-1, h); // Surely the maximum y pos. should be h - 1.
                                     /// Anyway, h is required for MSW.

        dc.SetPen(*m_lightShadowPen);
        dc.DrawLine(w-2, 1, w-2, h-2); // Right hand side
        dc.DrawLine(1, h-2, w-1, h-2);     // Bottom
    }
    else if ( GetWindowStyleFlag() & wxSP_BORDER )
    {
        dc.SetBrush(*wxTRANSPARENT_BRUSH);
        dc.SetPen(*wxBLACK_PEN);
        dc.DrawRectangle(0, 0, w-1, h-1);
    }

    dc.SetPen(wxNullPen);
    dc.SetBrush(wxNullBrush);
}

// Draw the sash
void wxSplitterWindow::DrawSash(wxDC& dc)
{
    if ( m_sashPosition == 0 || !m_windowTwo)
        return;

    int w, h;
    GetClientSize(&w, &h);

    if ( GetWindowStyleFlag() & wxSP_3D )
    {
        if ( m_splitMode == wxSPLIT_VERTICAL )
        {
            dc.SetPen(*m_facePen);
            dc.SetBrush(*m_faceBrush);
            dc.DrawRectangle(m_sashPosition + 2, 0, m_sashSize - 4, h);

            dc.SetBrush(*wxTRANSPARENT_BRUSH);

            dc.SetPen(*m_lightShadowPen);
            dc.DrawLine(m_sashPosition, 1, m_sashPosition, h-2);

            dc.SetPen(*m_hilightPen);
            dc.DrawLine(m_sashPosition+1, 0, m_sashPosition+1, h);

            dc.SetPen(*m_mediumShadowPen);
            dc.DrawLine(m_sashPosition+m_sashSize-2, 1, m_sashPosition+m_sashSize-2, h-1);

            dc.SetPen(*m_darkShadowPen);
            dc.DrawLine(m_sashPosition+m_sashSize-1, 2, m_sashPosition+m_sashSize-1, h-2);
        }
        else
        {
            dc.SetPen(*m_facePen);
            dc.SetBrush(*m_faceBrush);
            dc.DrawRectangle(0, m_sashPosition + 2, w, m_sashSize - 4);

            dc.SetBrush(*wxTRANSPARENT_BRUSH);

            dc.SetPen(*m_lightShadowPen);
            dc.DrawLine(1, m_sashPosition, w-2, m_sashPosition);

            dc.SetPen(*m_hilightPen);
            dc.DrawLine(0, m_sashPosition+1, w, m_sashPosition+1);

            dc.SetPen(*m_mediumShadowPen);
            dc.DrawLine(1, m_sashPosition+m_sashSize-2, w-1, m_sashPosition+m_sashSize-2);

            dc.SetPen(*m_darkShadowPen);
            dc.DrawLine(2, m_sashPosition+m_sashSize-1, w-2, m_sashPosition+m_sashSize-1);
        }
    }
    else
    {
        if ( m_splitMode == wxSPLIT_VERTICAL )
        {
            dc.SetPen(*wxBLACK_PEN);
            dc.SetBrush(*wxBLACK_BRUSH);
            int h1 = h-1;
            if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER )
                h1 += 1; // Not sure why this is necessary...
            dc.DrawRectangle(m_sashPosition, 0, m_sashSize, h1);
        }
        else
        {
            dc.SetPen(*wxBLACK_PEN);
            dc.SetBrush(*wxBLACK_BRUSH);
            int w1 = w-1;
            if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER )
                w1 ++;

            dc.DrawRectangle(0, m_sashPosition, w1, m_sashSize);
        }

    }

    dc.SetPen(wxNullPen);
    dc.SetBrush(wxNullBrush);
}

// Draw the sash tracker (for whilst moving the sash)
void wxSplitterWindow::DrawSashTracker(int x, int y)
{
    int w, h;
    GetClientSize(&w, &h);

    wxScreenDC screenDC;
    int x1, y1;
    int x2, y2;

    if ( m_splitMode == wxSPLIT_VERTICAL )
    {
        x1 = x; y1 = 2;
        x2 = x; y2 = h-2;

        if ( x1 > w )
        {
            x1 = w; x2 = w;
        }
        else if ( x1 < 0 )
        {
            x1 = 0; x2 = 0;
        }
    }
    else
    {
        x1 = 2; y1 = y;
        x2 = w-2; y2 = y;

        if ( y1 > h )
        {
            y1 = h;
            y2 = h;
        }
        else if ( y1 < 0 )
        {
            y1 = 0;
            y2 = 0;
        }
    }

    ClientToScreen(&x1, &y1);
    ClientToScreen(&x2, &y2);

    screenDC.SetLogicalFunction(wxXOR);
    screenDC.SetPen(*m_sashTrackerPen);
    screenDC.SetBrush(*wxTRANSPARENT_BRUSH);

    screenDC.DrawLine(x1, y1, x2, y2);

    screenDC.SetLogicalFunction(wxCOPY);

    screenDC.SetPen(wxNullPen);
    screenDC.SetBrush(wxNullBrush);
}

// Position and size subwindows.
// Note that the border size applies to each subwindow, not
// including the edges next to the sash.
void wxSplitterWindow::SizeWindows()
{
    int w, h;
    GetClientSize(&w, &h);

    if ( m_windowOne && !m_windowTwo )
    {
        m_windowOne->SetSize(m_borderSize, m_borderSize, w - 2*m_borderSize, h - 2*m_borderSize);
    }
    else if ( m_windowOne && m_windowTwo )
    {
        if (m_splitMode == wxSPLIT_VERTICAL)
        {
            int x1 = m_borderSize;
            int y1 = m_borderSize;
            int w1 = m_sashPosition - m_borderSize;
            int h1 = h - 2*m_borderSize;

            int x2 = m_sashPosition + m_sashSize;
            int y2 = m_borderSize;
            int w2 = w - 2*m_borderSize - m_sashSize - w1;
            int h2 = h - 2*m_borderSize;

            m_windowOne->SetSize(x1, y1, w1, h1);
            m_windowTwo->SetSize(x2, y2, w2, h2);
        }
        else
        {
            m_windowOne->SetSize(m_borderSize, m_borderSize,
                w - 2*m_borderSize, m_sashPosition - m_borderSize);
            m_windowTwo->SetSize(m_borderSize, m_sashPosition + m_sashSize,
                w - 2*m_borderSize, h - 2*m_borderSize - m_sashSize - (m_sashPosition - m_borderSize));
        }
    }
    wxClientDC dc(this);
    DrawBorders(dc);
    DrawSash(dc);
}

// Set pane for unsplit window
void wxSplitterWindow::Initialize(wxWindow *window)
{
    m_windowOne = window;
    m_windowTwo = (wxWindow *) NULL;
    m_sashPosition = 0;
}

// Associates the given window with window 2, drawing the appropriate sash
// and changing the split mode.
// Does nothing and returns FALSE if the window is already split.
bool wxSplitterWindow::SplitVertically(wxWindow *window1, wxWindow *window2, int sashPosition)
{
    if ( IsSplit() )
        return FALSE;

    int w, h;
    GetClientSize(&w, &h);

    m_splitMode = wxSPLIT_VERTICAL;
    m_windowOne = window1;
    m_windowTwo = window2;
    if ( sashPosition > 0 )
        m_sashPosition = sashPosition;
    else if ( sashPosition < 0 )
        m_sashPosition = w - sashPosition;
    else    // default
        m_sashPosition = w/2;

    SizeWindows();

    return TRUE;
}

bool wxSplitterWindow::SplitHorizontally(wxWindow *window1, wxWindow *window2, int sashPosition)
{
    if ( IsSplit() )
        return FALSE;

    int w, h;
    GetClientSize(&w, &h);

    m_splitMode = wxSPLIT_HORIZONTAL;
    m_windowOne = window1;
    m_windowTwo = window2;
    if ( sashPosition > 0 )
        m_sashPosition = sashPosition;
    else if ( sashPosition < 0 )
        m_sashPosition = h - sashPosition;
    else    // default
        m_sashPosition = h/2;

    SizeWindows();

    return TRUE;
}


// Remove the specified (or second) window from the view
// Doesn't actually delete the window.
bool wxSplitterWindow::Unsplit(wxWindow *toRemove)
{
    if ( ! IsSplit() )
        return FALSE;

    wxWindow *win = NULL;
    if ( toRemove == NULL || toRemove == m_windowTwo)
    {
        win = m_windowTwo ;
        m_windowTwo = (wxWindow *) NULL;
    }
    else if ( toRemove == m_windowOne )
    {
        win = m_windowOne ;
        m_windowOne = m_windowTwo;
        m_windowTwo = (wxWindow *) NULL;
    }
    else
    {
        wxFAIL_MSG(_T("splitter: attempt to remove a non-existent window"));

        return FALSE;
    }

    OnUnsplit(win);
    m_sashPosition = 0;
    SizeWindows();

    return TRUE;
}

// Replace a window with another one
bool wxSplitterWindow::ReplaceWindow(wxWindow *winOld, wxWindow *winNew)
{
    wxCHECK_MSG( winOld, FALSE, _T("use one of Split() functions instead") );
    wxCHECK_MSG( winNew, FALSE, _T("use Unsplit() functions instead") );

    if ( winOld == m_windowTwo )
    {
        m_windowTwo = winNew;
    }
    else if ( winOld == m_windowOne )
    {
        m_windowOne = winNew;
    }
    else
    {
        wxFAIL_MSG(_T("splitter: attempt to replace a non-existent window"));

        return FALSE;
    }

    SizeWindows();

    return TRUE;
}

void wxSplitterWindow::SetSashPosition(int position, bool redraw)
{
    m_sashPosition = position;

    if ( redraw )
    {
        SizeWindows();
    }
}

bool wxSplitterWindow::OnSashPositionChange(int& newSashPosition)
{
    // If within UNSPLIT_THRESHOLD from edge, set to edge to cause closure.
    const int UNSPLIT_THRESHOLD = 4;

    if (newSashPosition <= UNSPLIT_THRESHOLD)   // threshold top / left check
    {
        newSashPosition = 0;
        return TRUE;
    }

    // Obtain relevant window dimension for bottom / right threshold check
    int w, h;
    GetClientSize(&w, &h);
    int window_size = (m_splitMode == wxSPLIT_VERTICAL) ? w : h ;

    if ( newSashPosition >= window_size - UNSPLIT_THRESHOLD )
    {
        newSashPosition = window_size;
        return TRUE;
    }

    // If resultant pane would be too small, enlarge it.

    // Check upper / left pane
    if ( newSashPosition < m_minimumPaneSize )
        newSashPosition = m_minimumPaneSize;   // NB: don't return just yet

    // Check lower / right pane (check even if sash was just adjusted)
    if ( newSashPosition > window_size - m_minimumPaneSize )
        newSashPosition = window_size - m_minimumPaneSize;

    // If the result is out of bounds it means minimum size is too big, so
    // split window in half as best compromise.
    if (newSashPosition < 0 || newSashPosition > window_size)
        newSashPosition = window_size / 2;
    return TRUE;
}

// Called when the sash is double-clicked.
// The default behaviour is to remove the sash if the
// minimum pane size is zero.
void wxSplitterWindow::OnDoubleClickSash(int WXUNUSED(x), int WXUNUSED(y) )
{
    if ( GetMinimumPaneSize() == 0 )
    {
        Unsplit();
    }
}

// Initialize colours
void wxSplitterWindow::InitColours()
{
    wxDELETE( m_facePen );
    wxDELETE( m_faceBrush );
    wxDELETE( m_mediumShadowPen );
    wxDELETE( m_darkShadowPen );
    wxDELETE( m_lightShadowPen );
    wxDELETE( m_hilightPen );

    // Shadow colours
#if defined(__WIN95__)
    wxColour faceColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
    m_facePen = new wxPen(faceColour, 1, wxSOLID);
    m_faceBrush = new wxBrush(faceColour, wxSOLID);

    wxColour mediumShadowColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DSHADOW));
    m_mediumShadowPen = new wxPen(mediumShadowColour, 1, wxSOLID);

    wxColour darkShadowColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DDKSHADOW));
    m_darkShadowPen = new wxPen(darkShadowColour, 1, wxSOLID);

    wxColour lightShadowColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DLIGHT));
    m_lightShadowPen = new wxPen(lightShadowColour, 1, wxSOLID);

    wxColour hilightColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DHILIGHT));
    m_hilightPen = new wxPen(hilightColour, 1, wxSOLID);
#else // !Win32
    m_facePen = new wxPen("LIGHT GREY", 1, wxSOLID);
    m_faceBrush = new wxBrush("LIGHT GREY", wxSOLID);
    m_mediumShadowPen = new wxPen("GREY", 1, wxSOLID);
    m_darkShadowPen = new wxPen("BLACK", 1, wxSOLID);
    m_lightShadowPen = new wxPen("LIGHT GREY", 1, wxSOLID);
    m_hilightPen = new wxPen("WHITE", 1, wxSOLID);
#endif // Win32/!Win32
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: splitter.cpp
	3	// Purpose: wxSplitterWindow implementation
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 01/02/97
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart and Markus Holzem
	9	// Licence: wxWindows license
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "splitter.h"
	14	#endif
	15
	16	// For compilers that support precompilation, includes "wx.h".
	17	#include "wx/wxprec.h"
	18
	19	#ifdef __BORLANDC__
	20	#pragma hdrstop
	21	#endif
	22
	23	#ifndef WX_PRECOMP
	24	#include "wx/wx.h"
	25	#endif
	26
	27	#include <math.h>
	28	#include <stdlib.h>
	29
	30	#include "wx/string.h"
	31	#include "wx/splitter.h"
	32	#include "wx/dcscreen.h"
	33
	34	#if !USE_SHARED_LIBRARY
	35	IMPLEMENT_DYNAMIC_CLASS(wxSplitterWindow, wxWindow)
	36
	37	BEGIN_EVENT_TABLE(wxSplitterWindow, wxWindow)
	38	EVT_PAINT(wxSplitterWindow::OnPaint)
	39	EVT_SIZE(wxSplitterWindow::OnSize)
	40	EVT_MOUSE_EVENTS(wxSplitterWindow::OnMouseEvent)
	41	END_EVENT_TABLE()
	42	#endif
	43
	44	wxSplitterWindow::wxSplitterWindow()
	45	{
	46	m_splitMode = wxSPLIT_VERTICAL;
	47	m_windowOne = (wxWindow *) NULL;
	48	m_windowTwo = (wxWindow *) NULL;
	49	m_dragMode = wxSPLIT_DRAG_NONE;
	50	m_oldX = 0;
	51	m_oldY = 0;
	52	m_firstX = 0;
	53	m_firstY = 0;
	54	m_sashSize = 7;
	55	m_borderSize = 2;
	56	m_sashPosition = 0;
	57	m_sashCursorWE = (wxCursor *) NULL;
	58	m_sashCursorNS = (wxCursor *) NULL;
	59	m_sashTrackerPen = (wxPen *) NULL;
	60	m_lightShadowPen = (wxPen *) NULL;
	61	m_mediumShadowPen = (wxPen *) NULL;
	62	m_darkShadowPen = (wxPen *) NULL;
	63	m_faceBrush = (wxBrush *) NULL;
	64	m_facePen = (wxPen *) NULL;
	65	m_hilightPen = (wxPen *) NULL;
	66	m_minimumPaneSize = 0;
	67	}
	68
	69	wxSplitterWindow::wxSplitterWindow(wxWindow *parent, wxWindowID id,
	70	const wxPoint& pos,
	71	const wxSize& size,
	72	long style,
	73	const wxString& name)
	74	: wxWindow(parent, id, pos, size, style, name)
	75	{
	76	m_splitMode = wxSPLIT_VERTICAL;
	77	m_windowOne = (wxWindow *) NULL;
	78	m_windowTwo = (wxWindow *) NULL;
	79	m_dragMode = wxSPLIT_DRAG_NONE;
	80	m_oldX = 0;
	81	m_oldY = 0;
	82	m_firstX = 0;
	83	m_firstY = 0;
	84	m_sashSize = 7;
	85	m_borderSize = 2;
	86	m_sashPosition = 0;
	87	m_minimumPaneSize = 0;
	88	m_sashCursorWE = new wxCursor(wxCURSOR_SIZEWE);
	89	m_sashCursorNS = new wxCursor(wxCURSOR_SIZENS);
	90	m_sashTrackerPen = new wxPen(*wxBLACK, 2, wxSOLID);
	91	m_lightShadowPen = (wxPen *) NULL;
	92	m_mediumShadowPen = (wxPen *) NULL;
	93	m_darkShadowPen = (wxPen *) NULL;
	94	m_faceBrush = (wxBrush *) NULL;
	95	m_facePen = (wxPen *) NULL;
	96	m_hilightPen = (wxPen *) NULL;
	97
	98	if ( style & wxSP_3D )
	99	{
	100	m_borderSize = 2;
	101	m_sashSize = 7;
	102	}
	103	else if ( style & wxSP_BORDER )
	104	{
	105	m_borderSize = 1;
	106	m_sashSize = 3;
	107	}
	108	else
	109	{
	110	m_borderSize = 0;
	111	m_sashSize = 3;
	112	}
	113
	114	// Eventually, we'll respond to colour change messages
	115	InitColours();
	116
	117	// For debugging purposes, to see the background.
	118	// SetBackground(wxBLUE_BRUSH);
	119	}
	120
	121	wxSplitterWindow::~wxSplitterWindow()
	122	{
	123	delete m_sashCursorWE;
	124	delete m_sashCursorNS;
	125	delete m_sashTrackerPen;
	126	delete m_lightShadowPen;
	127	delete m_darkShadowPen;
	128	delete m_mediumShadowPen;
	129	delete m_hilightPen;
	130	delete m_facePen;
	131	delete m_faceBrush;
	132	}
	133
	134	void wxSplitterWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
	135	{
	136	wxPaintDC dc(this);
	137
	138	if ( m_borderSize > 0 )
	139	DrawBorders(dc);
	140	DrawSash(dc);
	141	}
	142
	143
	144	void wxSplitterWindow::OnMouseEvent(wxMouseEvent& event)
	145	{
	146	long x = event.GetX();
	147	long y = event.GetY();
	148
	149	// reset the cursor
	150	#ifdef __WXMOTIF__
	151	SetCursor(* wxSTANDARD_CURSOR);
	152	#endif
	153	#ifdef __WXMSW__
	154	SetCursor(wxCursor());
	155	#endif
	156
	157	// under wxGTK the method above causes the mouse
	158	// to flicker so we set the standard cursor only
	159	// when leaving the window and when moving over
	160	// non-sash parts of the window. this should work
	161	// on the other platforms as well, but who knows.
	162	#ifdef __WXGTK__
	163	if (event.Leaving())
	164	SetCursor(* wxSTANDARD_CURSOR);
	165	#endif
	166
	167	if (event.LeftDown())
	168	{
	169	if ( SashHitTest(x, y) )
	170	{
	171	CaptureMouse();
	172
	173	m_dragMode = wxSPLIT_DRAG_DRAGGING;
	174
	175	DrawSashTracker(x, y);
	176	m_oldX = x;
	177	m_oldY = y;
	178	return;
	179	}
	180	}
	181	else if (event.LeftUp() && m_dragMode == wxSPLIT_DRAG_DRAGGING)
	182	{
	183	// We can stop dragging now and see what we've got.
	184	m_dragMode = wxSPLIT_DRAG_NONE;
	185	ReleaseMouse();
	186
	187	// Erase old tracker
	188	DrawSashTracker(m_oldX, m_oldY);
	189
	190	// Obtain window size. We are only interested in the dimension the sash
	191	// splits up
	192	int w, h;
	193	GetClientSize(&w, &h);
	194	int window_size = (m_splitMode == wxSPLIT_VERTICAL ? w : h );
	195	int new_sash_position =
	196	(int) ( m_splitMode == wxSPLIT_VERTICAL ? x : y );
	197
	198	if ( !OnSashPositionChange(new_sash_position) )
	199	return;
	200
	201	if ( new_sash_position == 0 )
	202	{
	203	// We remove the first window from the view
	204	wxWindow *removedWindow = m_windowOne;
	205	m_windowOne = m_windowTwo;
	206	m_windowTwo = (wxWindow *) NULL;
	207	OnUnsplit(removedWindow);
	208	m_sashPosition = 0;
	209	}
	210	else if ( new_sash_position == window_size )
	211	{
	212	// We remove the second window from the view
	213	wxWindow *removedWindow = m_windowTwo;
	214	m_windowTwo = (wxWindow *) NULL;
	215	OnUnsplit(removedWindow);
	216	m_sashPosition = 0;
	217	}
	218	else
	219	{
	220	m_sashPosition = new_sash_position;
	221	}
	222	SizeWindows();
	223	} // left up && dragging
	224	else if (event.Moving() && !event.Dragging())
	225	{
	226	// Just change the cursor if required
	227	if ( SashHitTest(x, y) )
	228	{
	229	if ( m_splitMode == wxSPLIT_VERTICAL )
	230	{
	231	SetCursor(*m_sashCursorWE);
	232	}
	233	else
	234	{
	235	SetCursor(*m_sashCursorNS);
	236	}
	237	}
	238	#ifdef __WXGTK__
	239	else
	240	{
	241	// where else do we unset the cursor?
	242	SetCursor(* wxSTANDARD_CURSOR);
	243	}
	244	#endif
	245	}
	246	else if (event.Dragging() && (m_dragMode == wxSPLIT_DRAG_DRAGGING))
	247	{
	248	// Erase old tracker
	249	DrawSashTracker(m_oldX, m_oldY);
	250
	251	// Draw new one
	252	DrawSashTracker(x, y);
	253
	254	m_oldX = x;
	255	m_oldY = y;
	256	}
	257	else if ( event.LeftDClick() )
	258	{
	259	OnDoubleClickSash(x, y);
	260	}
	261	}
	262
	263	void wxSplitterWindow::OnSize(wxSizeEvent& WXUNUSED(event))
	264	{
	265	int cw, ch;
	266	GetClientSize( &cw, &ch );
	267	if ( m_windowTwo )
	268	{
	269	if ( m_splitMode == wxSPLIT_VERTICAL )
	270	{
	271	if ( m_sashPosition >= (cw - 5) )
	272	m_sashPosition = wxMax(10, cw - 40);
	273	}
	274	if ( m_splitMode == wxSPLIT_HORIZONTAL )
	275	{
	276	if ( m_sashPosition >= (ch - 5) )
	277	m_sashPosition = wxMax(10, ch - 40);
	278	}
	279	}
	280	SizeWindows();
	281	}
	282
	283	bool wxSplitterWindow::SashHitTest(int x, int y, int tolerance)
	284	{
	285	if ( m_windowTwo == NULL \|\| m_sashPosition == 0)
	286	return FALSE; // No sash
	287
	288	if ( m_splitMode == wxSPLIT_VERTICAL )
	289	{
	290	if ( (x >= m_sashPosition - tolerance) && (x <= m_sashPosition + m_sashSize + tolerance) )
	291	return TRUE;
	292	else
	293	return FALSE;
	294	}
	295	else
	296	{
	297	if ( (y >= (m_sashPosition- tolerance)) && (y <= (m_sashPosition + m_sashSize + tolerance)) )
	298	return TRUE;
	299	else
	300	return FALSE;
	301	}
	302
	303	return FALSE;
	304	}
	305
	306	// Draw 3D effect borders
	307	void wxSplitterWindow::DrawBorders(wxDC& dc)
	308	{
	309	int w, h;
	310	GetClientSize(&w, &h);
	311
	312	if ( GetWindowStyleFlag() & wxSP_3D )
	313	{
	314	dc.SetPen(*m_mediumShadowPen);
	315	dc.DrawLine(0, 0, w-1, 0);
	316	dc.DrawLine(0, 0, 0, h - 1);
	317
	318	dc.SetPen(*m_darkShadowPen);
	319	dc.DrawLine(1, 1, w-2, 1);
	320	dc.DrawLine(1, 1, 1, h-2);
	321
	322	dc.SetPen(*m_hilightPen);
	323	dc.DrawLine(0, h-1, w-1, h-1);
	324	dc.DrawLine(w-1, 0, w-1, h); // Surely the maximum y pos. should be h - 1.
	325	/// Anyway, h is required for MSW.
	326
	327	dc.SetPen(*m_lightShadowPen);
	328	dc.DrawLine(w-2, 1, w-2, h-2); // Right hand side
	329	dc.DrawLine(1, h-2, w-1, h-2); // Bottom
	330	}
	331	else if ( GetWindowStyleFlag() & wxSP_BORDER )
	332	{
	333	dc.SetBrush(*wxTRANSPARENT_BRUSH);
	334	dc.SetPen(*wxBLACK_PEN);
	335	dc.DrawRectangle(0, 0, w-1, h-1);
	336	}
	337
	338	dc.SetPen(wxNullPen);
	339	dc.SetBrush(wxNullBrush);
	340	}
	341
	342	// Draw the sash
	343	void wxSplitterWindow::DrawSash(wxDC& dc)
	344	{
	345	if ( m_sashPosition == 0 \|\| !m_windowTwo)
	346	return;
	347
	348	int w, h;
	349	GetClientSize(&w, &h);
	350
	351	if ( GetWindowStyleFlag() & wxSP_3D )
	352	{
	353	if ( m_splitMode == wxSPLIT_VERTICAL )
	354	{
	355	dc.SetPen(*m_facePen);
	356	dc.SetBrush(*m_faceBrush);
	357	dc.DrawRectangle(m_sashPosition + 2, 0, m_sashSize - 4, h);
	358
	359	dc.SetBrush(*wxTRANSPARENT_BRUSH);
	360
	361	dc.SetPen(*m_lightShadowPen);
	362	dc.DrawLine(m_sashPosition, 1, m_sashPosition, h-2);
	363
	364	dc.SetPen(*m_hilightPen);
	365	dc.DrawLine(m_sashPosition+1, 0, m_sashPosition+1, h);
	366
	367	dc.SetPen(*m_mediumShadowPen);
	368	dc.DrawLine(m_sashPosition+m_sashSize-2, 1, m_sashPosition+m_sashSize-2, h-1);
	369
	370	dc.SetPen(*m_darkShadowPen);
	371	dc.DrawLine(m_sashPosition+m_sashSize-1, 2, m_sashPosition+m_sashSize-1, h-2);
	372	}
	373	else
	374	{
	375	dc.SetPen(*m_facePen);
	376	dc.SetBrush(*m_faceBrush);
	377	dc.DrawRectangle(0, m_sashPosition + 2, w, m_sashSize - 4);
	378
	379	dc.SetBrush(*wxTRANSPARENT_BRUSH);
	380
	381	dc.SetPen(*m_lightShadowPen);
	382	dc.DrawLine(1, m_sashPosition, w-2, m_sashPosition);
	383
	384	dc.SetPen(*m_hilightPen);
	385	dc.DrawLine(0, m_sashPosition+1, w, m_sashPosition+1);
	386
	387	dc.SetPen(*m_mediumShadowPen);
	388	dc.DrawLine(1, m_sashPosition+m_sashSize-2, w-1, m_sashPosition+m_sashSize-2);
	389
	390	dc.SetPen(*m_darkShadowPen);
	391	dc.DrawLine(2, m_sashPosition+m_sashSize-1, w-2, m_sashPosition+m_sashSize-1);
	392	}
	393	}
	394	else
	395	{
	396	if ( m_splitMode == wxSPLIT_VERTICAL )
	397	{
	398	dc.SetPen(*wxBLACK_PEN);
	399	dc.SetBrush(*wxBLACK_BRUSH);
	400	int h1 = h-1;
	401	if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER )
	402	h1 += 1; // Not sure why this is necessary...
	403	dc.DrawRectangle(m_sashPosition, 0, m_sashSize, h1);
	404	}
	405	else
	406	{
	407	dc.SetPen(*wxBLACK_PEN);
	408	dc.SetBrush(*wxBLACK_BRUSH);
	409	int w1 = w-1;
	410	if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER )
	411	w1 ++;
	412
	413	dc.DrawRectangle(0, m_sashPosition, w1, m_sashSize);
	414	}
	415
	416	}
	417
	418	dc.SetPen(wxNullPen);
	419	dc.SetBrush(wxNullBrush);
	420	}
	421
	422	// Draw the sash tracker (for whilst moving the sash)
	423	void wxSplitterWindow::DrawSashTracker(int x, int y)
	424	{
	425	int w, h;
	426	GetClientSize(&w, &h);
	427
	428	wxScreenDC screenDC;
	429	int x1, y1;
	430	int x2, y2;
	431
	432	if ( m_splitMode == wxSPLIT_VERTICAL )
	433	{
	434	x1 = x; y1 = 2;
	435	x2 = x; y2 = h-2;
	436
	437	if ( x1 > w )
	438	{
	439	x1 = w; x2 = w;
	440	}
	441	else if ( x1 < 0 )
	442	{
	443	x1 = 0; x2 = 0;
	444	}
	445	}
	446	else
	447	{
	448	x1 = 2; y1 = y;
	449	x2 = w-2; y2 = y;
	450
	451	if ( y1 > h )
	452	{
	453	y1 = h;
	454	y2 = h;
	455	}
	456	else if ( y1 < 0 )
	457	{
	458	y1 = 0;
	459	y2 = 0;
	460	}
	461	}
	462
	463	ClientToScreen(&x1, &y1);
	464	ClientToScreen(&x2, &y2);
	465
	466	screenDC.SetLogicalFunction(wxXOR);
	467	screenDC.SetPen(*m_sashTrackerPen);
	468	screenDC.SetBrush(*wxTRANSPARENT_BRUSH);
	469
	470	screenDC.DrawLine(x1, y1, x2, y2);
	471
	472	screenDC.SetLogicalFunction(wxCOPY);
	473
	474	screenDC.SetPen(wxNullPen);
	475	screenDC.SetBrush(wxNullBrush);
	476	}
	477
	478	// Position and size subwindows.
	479	// Note that the border size applies to each subwindow, not
	480	// including the edges next to the sash.
	481	void wxSplitterWindow::SizeWindows()
	482	{
	483	int w, h;
	484	GetClientSize(&w, &h);
	485
	486	if ( m_windowOne && !m_windowTwo )
	487	{
	488	m_windowOne->SetSize(m_borderSize, m_borderSize, w - 2m_borderSize, h - 2m_borderSize);
	489	}
	490	else if ( m_windowOne && m_windowTwo )
	491	{
	492	if (m_splitMode == wxSPLIT_VERTICAL)
	493	{
	494	int x1 = m_borderSize;
	495	int y1 = m_borderSize;
	496	int w1 = m_sashPosition - m_borderSize;
	497	int h1 = h - 2*m_borderSize;
	498
	499	int x2 = m_sashPosition + m_sashSize;
	500	int y2 = m_borderSize;
	501	int w2 = w - 2*m_borderSize - m_sashSize - w1;
	502	int h2 = h - 2*m_borderSize;
	503
	504	m_windowOne->SetSize(x1, y1, w1, h1);
	505	m_windowTwo->SetSize(x2, y2, w2, h2);
	506	}
	507	else
	508	{
	509	m_windowOne->SetSize(m_borderSize, m_borderSize,
	510	w - 2*m_borderSize, m_sashPosition - m_borderSize);
	511	m_windowTwo->SetSize(m_borderSize, m_sashPosition + m_sashSize,
	512	w - 2m_borderSize, h - 2m_borderSize - m_sashSize - (m_sashPosition - m_borderSize));
	513	}
	514	}
	515	wxClientDC dc(this);
	516	DrawBorders(dc);
	517	DrawSash(dc);
	518	}
	519
	520	// Set pane for unsplit window
	521	void wxSplitterWindow::Initialize(wxWindow *window)
	522	{
	523	m_windowOne = window;
	524	m_windowTwo = (wxWindow *) NULL;
	525	m_sashPosition = 0;
	526	}
	527
	528	// Associates the given window with window 2, drawing the appropriate sash
	529	// and changing the split mode.
	530	// Does nothing and returns FALSE if the window is already split.
	531	bool wxSplitterWindow::SplitVertically(wxWindow window1, wxWindow window2, int sashPosition)
	532	{
	533	if ( IsSplit() )
	534	return FALSE;
	535
	536	int w, h;
	537	GetClientSize(&w, &h);
	538
	539	m_splitMode = wxSPLIT_VERTICAL;
	540	m_windowOne = window1;
	541	m_windowTwo = window2;
	542	if ( sashPosition > 0 )
	543	m_sashPosition = sashPosition;
	544	else if ( sashPosition < 0 )
	545	m_sashPosition = w - sashPosition;
	546	else // default
	547	m_sashPosition = w/2;
	548
	549	SizeWindows();
	550
	551	return TRUE;
	552	}
	553
	554	bool wxSplitterWindow::SplitHorizontally(wxWindow window1, wxWindow window2, int sashPosition)
	555	{
	556	if ( IsSplit() )
	557	return FALSE;
	558
	559	int w, h;
	560	GetClientSize(&w, &h);
	561
	562	m_splitMode = wxSPLIT_HORIZONTAL;
	563	m_windowOne = window1;
	564	m_windowTwo = window2;
	565	if ( sashPosition > 0 )
	566	m_sashPosition = sashPosition;
	567	else if ( sashPosition < 0 )
	568	m_sashPosition = h - sashPosition;
	569	else // default
	570	m_sashPosition = h/2;
	571
	572	SizeWindows();
	573
	574	return TRUE;
	575	}
	576
	577
	578	// Remove the specified (or second) window from the view
	579	// Doesn't actually delete the window.
	580	bool wxSplitterWindow::Unsplit(wxWindow *toRemove)
	581	{
	582	if ( ! IsSplit() )
	583	return FALSE;
	584
	585	wxWindow *win = NULL;
	586	if ( toRemove == NULL \|\| toRemove == m_windowTwo)
	587	{
	588	win = m_windowTwo ;
	589	m_windowTwo = (wxWindow *) NULL;
	590	}
	591	else if ( toRemove == m_windowOne )
	592	{
	593	win = m_windowOne ;
	594	m_windowOne = m_windowTwo;
	595	m_windowTwo = (wxWindow *) NULL;
	596	}
	597	else
	598	{
	599	wxFAIL_MSG(_T("splitter: attempt to remove a non-existent window"));
	600
	601	return FALSE;
	602	}
	603
	604	OnUnsplit(win);
	605	m_sashPosition = 0;
	606	SizeWindows();
	607
	608	return TRUE;
	609	}
	610
	611	// Replace a window with another one
	612	bool wxSplitterWindow::ReplaceWindow(wxWindow winOld, wxWindow winNew)
	613	{
	614	wxCHECK_MSG( winOld, FALSE, _T("use one of Split() functions instead") );
	615	wxCHECK_MSG( winNew, FALSE, _T("use Unsplit() functions instead") );
	616
	617	if ( winOld == m_windowTwo )
	618	{
	619	m_windowTwo = winNew;
	620	}
	621	else if ( winOld == m_windowOne )
	622	{
	623	m_windowOne = winNew;
	624	}
	625	else
	626	{
	627	wxFAIL_MSG(_T("splitter: attempt to replace a non-existent window"));
	628
	629	return FALSE;
	630	}
	631
	632	SizeWindows();
	633
	634	return TRUE;
	635	}
	636
	637	void wxSplitterWindow::SetSashPosition(int position, bool redraw)
	638	{
	639	m_sashPosition = position;
	640
	641	if ( redraw )
	642	{
	643	SizeWindows();
	644	}
	645	}
	646
	647	bool wxSplitterWindow::OnSashPositionChange(int& newSashPosition)
	648	{
	649	// If within UNSPLIT_THRESHOLD from edge, set to edge to cause closure.
	650	const int UNSPLIT_THRESHOLD = 4;
	651
	652	if (newSashPosition <= UNSPLIT_THRESHOLD) // threshold top / left check
	653	{
	654	newSashPosition = 0;
	655	return TRUE;
	656	}
	657
	658	// Obtain relevant window dimension for bottom / right threshold check
	659	int w, h;
	660	GetClientSize(&w, &h);
	661	int window_size = (m_splitMode == wxSPLIT_VERTICAL) ? w : h ;
	662
	663	if ( newSashPosition >= window_size - UNSPLIT_THRESHOLD )
	664	{
	665	newSashPosition = window_size;
	666	return TRUE;
	667	}
	668
	669	// If resultant pane would be too small, enlarge it.
	670
	671	// Check upper / left pane
	672	if ( newSashPosition < m_minimumPaneSize )
	673	newSashPosition = m_minimumPaneSize; // NB: don't return just yet
	674
	675	// Check lower / right pane (check even if sash was just adjusted)
	676	if ( newSashPosition > window_size - m_minimumPaneSize )
	677	newSashPosition = window_size - m_minimumPaneSize;
	678
	679	// If the result is out of bounds it means minimum size is too big, so
	680	// split window in half as best compromise.
	681	if (newSashPosition < 0 \|\| newSashPosition > window_size)
	682	newSashPosition = window_size / 2;
	683	return TRUE;
	684	}
	685
	686	// Called when the sash is double-clicked.
	687	// The default behaviour is to remove the sash if the
	688	// minimum pane size is zero.
	689	void wxSplitterWindow::OnDoubleClickSash(int WXUNUSED(x), int WXUNUSED(y) )
	690	{
	691	if ( GetMinimumPaneSize() == 0 )
	692	{
	693	Unsplit();
	694	}
	695	}
	696
	697	// Initialize colours
	698	void wxSplitterWindow::InitColours()
	699	{
	700	wxDELETE( m_facePen );
	701	wxDELETE( m_faceBrush );
	702	wxDELETE( m_mediumShadowPen );
	703	wxDELETE( m_darkShadowPen );
	704	wxDELETE( m_lightShadowPen );
	705	wxDELETE( m_hilightPen );
	706
	707	// Shadow colours
	708	#if defined(__WIN95__)
	709	wxColour faceColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
	710	m_facePen = new wxPen(faceColour, 1, wxSOLID);
	711	m_faceBrush = new wxBrush(faceColour, wxSOLID);
	712
	713	wxColour mediumShadowColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DSHADOW));
	714	m_mediumShadowPen = new wxPen(mediumShadowColour, 1, wxSOLID);
	715
	716	wxColour darkShadowColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DDKSHADOW));
	717	m_darkShadowPen = new wxPen(darkShadowColour, 1, wxSOLID);
	718
	719	wxColour lightShadowColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DLIGHT));
	720	m_lightShadowPen = new wxPen(lightShadowColour, 1, wxSOLID);
	721
	722	wxColour hilightColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DHILIGHT));
	723	m_hilightPen = new wxPen(hilightColour, 1, wxSOLID);
	724	#else // !Win32
	725	m_facePen = new wxPen("LIGHT GREY", 1, wxSOLID);
	726	m_faceBrush = new wxBrush("LIGHT GREY", wxSOLID);
	727	m_mediumShadowPen = new wxPen("GREY", 1, wxSOLID);
	728	m_darkShadowPen = new wxPen("BLACK", 1, wxSOLID);
	729	m_lightShadowPen = new wxPen("LIGHT GREY", 1, wxSOLID);
	730	m_hilightPen = new wxPen("WHITE", 1, wxSOLID);
	731	#endif // Win32/!Win32
	732	}
	733