// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
+// For compilers that support precompilation, includes "wx/wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+ #pragma hdrstop
+#endif
+
+// for all others, include the necessary headers (this file is usually all you
+// need because it includes almost all "standard" wxWidgets headers)
+#ifndef WX_PRECOMP
+ #include "wx/wx.h"
+#endif
+
+#ifdef __WXMSW__
+#include "wx/mdi.h"
+#endif
+
#include "wx/gizmos/dynamicsash.h"
+
+const wxChar* wxDynamicSashWindowNameStr = wxT("dynamicSashWindow");
+
+
/*
wxDynamicSashWindow works by internally storing a tree of Implementation
objects (wxDynamicSsahWindowImpl) and Leaf objects
*/
-#include <wx/dcmemory.h>
-#include <wx/dcscreen.h>
-#include <wx/layout.h>
-#include <wx/scrolbar.h>
-#include <wx/settings.h>
+#include "wx/dcmemory.h"
+#include "wx/dcscreen.h"
+#include "wx/layout.h"
+#include "wx/scrolbar.h"
+#include "wx/settings.h"
-#define wxEVT_DYNAMIC_SASH_PRIVATE (wxEVT_DYNAMIC_SASH_BASE + 8)
-#define wxEVT_DYNAMIC_SASH_REPARENT (wxEVT_DYNAMIC_SASH_PRIVATE + 1)
+const wxEventType wxEVT_DYNAMIC_SASH_SPLIT = wxNewEventType();
+const wxEventType wxEVT_DYNAMIC_SASH_UNIFY = wxNewEventType();
+const wxEventType wxEVT_DYNAMIC_SASH_REPARENT = wxNewEventType();
+
+enum DynamicSashRegion
+{
+ DSR_NONE,
+ DSR_VERTICAL_TAB,
+ DSR_HORIZONTAL_TAB,
+ DSR_CORNER,
+ DSR_LEFT_EDGE,
+ DSR_TOP_EDGE,
+ DSR_RIGHT_EDGE,
+ DSR_BOTTOM_EDGE
+};
/*
class. Instead, we queue up this event, and the window is actually
reparented the next time we process events in the idle loop.
*/
-class wxDynamicSashReparentEvent : public wxEvent {
+class wxDynamicSashReparentEvent : public wxEvent
+{
public:
wxDynamicSashReparentEvent();
wxDynamicSashReparentEvent(wxObject *object);
+ wxDynamicSashReparentEvent(const wxDynamicSashReparentEvent& evt);
- DECLARE_DYNAMIC_CLASS(wxDynamicSashReparentEvent);
-};
+ virtual wxEvent* Clone() const { return new wxDynamicSashReparentEvent(*this); }
-
-enum DynamicSashRegion {
- DSR_NONE,
- DSR_VERTICAL_TAB,
- DSR_HORIZONTAL_TAB,
- DSR_CORNER,
- DSR_LEFT_EDGE,
- DSR_TOP_EDGE,
- DSR_RIGHT_EDGE,
- DSR_BOTTOM_EDGE
+ DECLARE_DYNAMIC_CLASS(wxDynamicSashReparentEvent)
};
-class wxDynamicSashWindowImpl : public wxEvtHandler {
+class wxDynamicSashWindowImpl : public wxEvtHandler
+{
public:
wxDynamicSashWindowImpl(wxDynamicSashWindow *window);
~wxDynamicSashWindowImpl();
int m_drag_x, m_drag_y;
};
-class wxDynamicSashWindowLeaf : public wxEvtHandler {
+class wxDynamicSashWindowLeaf : public wxEvtHandler
+{
public:
wxDynamicSashWindowLeaf(wxDynamicSashWindowImpl *impl);
~wxDynamicSashWindowLeaf();
bool Create();
void AddChild(wxWindow *window);
DynamicSashRegion GetRegion(int x, int y);
- void ResizeChild(wxSize size);
+ void ResizeChild(const wxSize& size);
wxScrollBar *FindScrollBar(const wxWindow *child, int vert) const;
void OnSize(wxSizeEvent &event);
+ void OnViewSize(wxSizeEvent &event);
void OnPaint(wxPaintEvent &event);
void OnScroll(wxScrollEvent &event);
void OnFocus(wxFocusEvent &event);
wxDynamicSashWindowImpl *m_impl;
- wxScrollBar *m_vscroll, *m_hscroll;
+ wxScrollBar *m_vscroll,
+ *m_hscroll;
/* m_child is the window provided to us by the application developer.
m_viewport is a window we've created, and it is the immediately
parent of m_child. We scroll m_child by moving it around within
m_viewport. */
- wxWindow *m_viewport, *m_child;
+ wxWindow *m_viewport,
+ *m_child;
};
-// wxDynamicSashWindow //////////////////////////////////////////////////////
-wxDynamicSashWindow::wxDynamicSashWindow() {
+// ============================================================================
+// wxDynamicSashWindow
+// ============================================================================
+
+wxDynamicSashWindow::wxDynamicSashWindow()
+{
m_impl = NULL;
}
-wxDynamicSashWindow::wxDynamicSashWindow(wxWindow *parent, wxWindowID id,
- const wxPoint& pos, const wxSize& size,
- long style, const wxString& name) {
+wxDynamicSashWindow::wxDynamicSashWindow(wxWindow *parent,
+ wxWindowID id,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
+{
m_impl = NULL;
Create(parent, id, pos, size, style, name);
}
-wxDynamicSashWindow::~wxDynamicSashWindow() {
+wxDynamicSashWindow::~wxDynamicSashWindow()
+{
SetEventHandler(this);
delete m_impl;
}
-bool wxDynamicSashWindow::Create(wxWindow *parent, wxWindowID id,
- const wxPoint& pos, const wxSize& size,
- long style, const wxString& name) {
+bool wxDynamicSashWindow::Create(wxWindow *parent,
+ wxWindowID id,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
+{
if (m_impl)
- return FALSE;
+ return false;
if (!wxWindow::Create(parent, id, pos, size, style, name))
- return FALSE;
+ return false;
m_impl = new wxDynamicSashWindowImpl(this);
if (!m_impl)
- return FALSE;
+ return false;
- if (!m_impl->Create()) {
+ if (!m_impl->Create())
+ {
delete m_impl;
m_impl = NULL;
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
-void wxDynamicSashWindow::AddChild(wxWindowBase *child) {
+void wxDynamicSashWindow::AddChild(wxWindowBase *child)
+{
wxWindow::AddChild(child);
m_impl->AddChild(wxDynamicCast(child, wxWindow));
}
-wxScrollBar *wxDynamicSashWindow::GetHScrollBar(const wxWindow *child) const {
+wxScrollBar *wxDynamicSashWindow::GetHScrollBar(const wxWindow *child) const
+{
return m_impl->FindScrollBar(child, 0);
}
-wxScrollBar *wxDynamicSashWindow::GetVScrollBar(const wxWindow *child) const {
+wxScrollBar *wxDynamicSashWindow::GetVScrollBar(const wxWindow *child) const
+{
return m_impl->FindScrollBar(child, 1);
}
IMPLEMENT_DYNAMIC_CLASS(wxDynamicSashWindow, wxWindow)
-// wxDynamicSashWindowImpl //////////////////////////////////////////////////
-wxDynamicSashWindowImpl::wxDynamicSashWindowImpl(wxDynamicSashWindow *window) {
+// ============================================================================
+// wxDynamicSashWindowImpl
+// ============================================================================
+
+wxDynamicSashWindowImpl::wxDynamicSashWindowImpl(wxDynamicSashWindow *window)
+{
m_window = window;
m_add_child_target = this;
m_container = NULL;
m_parent = NULL;
m_top = this;
- m_child[0] = m_child[1] = NULL;
+ m_child[0] =
+ m_child[1] = NULL;
m_leaf = NULL;
m_dragging = DSR_NONE;
m_split = DSR_NONE;
}
-wxDynamicSashWindowImpl::~wxDynamicSashWindowImpl() {
+wxDynamicSashWindowImpl::~wxDynamicSashWindowImpl()
+{
delete m_leaf;
delete m_child[0];
m_child[0] = NULL;
m_child[1] = NULL;
m_leaf = NULL;
- if (m_container != m_window && m_container) {
+ if (m_container != m_window && m_container)
+ {
m_container->SetEventHandler(m_container);
m_container->Destroy();
}
}
-bool wxDynamicSashWindowImpl::Create() {
- if (!m_container) {
+bool wxDynamicSashWindowImpl::Create()
+{
+ if (!m_container)
m_container = m_window;
- }
wxCursor cursor(wxCURSOR_ARROW);
m_container->SetCursor(cursor);
m_leaf = new wxDynamicSashWindowLeaf(this);
if (!m_leaf)
- return FALSE;
+ return false;
- if (!m_leaf->Create()) {
+ if (!m_leaf->Create())
+ {
delete m_leaf;
m_leaf = NULL;
- return FALSE;
+ return false;
}
m_container->SetEventHandler(this);
- Connect(-1, wxEVT_SIZE, (wxObjectEventFunction)&wxDynamicSashWindowImpl::OnSize);
- Connect(-1, wxEVT_PAINT, (wxObjectEventFunction)&wxDynamicSashWindowImpl::OnPaint);
- Connect(-1, wxEVT_MOTION, (wxObjectEventFunction)&wxDynamicSashWindowImpl::OnMouseMove);
- Connect(-1, wxEVT_ENTER_WINDOW, (wxObjectEventFunction)&wxDynamicSashWindowImpl::OnMouseMove);
- Connect(-1, wxEVT_LEAVE_WINDOW, (wxObjectEventFunction)&wxDynamicSashWindowImpl::OnLeave);
- Connect(-1, wxEVT_LEFT_DOWN, (wxObjectEventFunction)&wxDynamicSashWindowImpl::OnPress);
- Connect(-1, wxEVT_LEFT_UP, (wxObjectEventFunction)&wxDynamicSashWindowImpl::OnRelease);
-
- return TRUE;
+ Connect(wxEVT_SIZE, wxSizeEventHandler(wxDynamicSashWindowImpl::OnSize));
+ Connect(wxEVT_PAINT, wxPaintEventHandler(wxDynamicSashWindowImpl::OnPaint));
+ Connect(wxEVT_MOTION,
+ wxMouseEventHandler(wxDynamicSashWindowImpl::OnMouseMove));
+ Connect(wxEVT_ENTER_WINDOW,
+ wxMouseEventHandler(wxDynamicSashWindowImpl::OnMouseMove));
+ Connect(wxEVT_LEAVE_WINDOW,
+ wxMouseEventHandler(wxDynamicSashWindowImpl::OnLeave));
+ Connect(wxEVT_LEFT_DOWN,
+ wxMouseEventHandler(wxDynamicSashWindowImpl::OnPress));
+ Connect(wxEVT_LEFT_UP,
+ wxMouseEventHandler(wxDynamicSashWindowImpl::OnRelease));
+
+ return true;
}
-void wxDynamicSashWindowImpl::AddChild(wxWindow *window) {
- if (m_add_child_target && m_add_child_target->m_leaf) {
+void wxDynamicSashWindowImpl::AddChild(wxWindow *window)
+{
+ if (m_add_child_target && m_add_child_target->m_leaf)
m_add_child_target->m_leaf->AddChild(window);
- }
}
-void wxDynamicSashWindowImpl::DrawSash(int x, int y) const {
+void wxDynamicSashWindowImpl::DrawSash(int x, int y) const
+{
int i, j;
wxScreenDC dc;
wxMemoryDC bdc;
bdc.SelectObject(bmp);
bdc.DrawRectangle(-1, -1, 10, 10);
- for (i = 0; i < 8; i++) {
- for (j = 0; j < 8; j++) {
- if ((i + j) & 1) {
+ for (i = 0; i < 8; i++)
+ {
+ for (j = 0; j < 8; j++)
+ {
+ if ((i + j) & 1)
bdc.DrawPoint(i, j);
- }
}
}
dc.SetBrush(brush);
dc.SetLogicalFunction(wxXOR);
- if (m_dragging == DSR_CORNER) {
+ if ((m_dragging == DSR_CORNER) &&
+ (m_window->GetWindowStyle() & wxDS_DRAG_CORNER) != 0)
+ {
int cx = 0;
int cy = 0;
m_container->ClientToScreen(&cx, &cy);
m_container->ClientToScreen(&x, &y);
- if (cx < x && cy < y) {
+ if (cx < x && cy < y)
+ {
dc.DrawRectangle(cx - 2, cy - 2, x - cx + 4, 4);
dc.DrawRectangle(x - 2, cy + 2, 4, y - cy);
dc.DrawRectangle(cx - 2, cy + 2, 4, y - cy);
dc.DrawRectangle(cx + 2, y - 2, x - cx - 4, 4);
}
- } else {
+ }
+ else
+ {
int body_w, body_h;
m_container->GetClientSize(&body_w, &body_h);
dc.EndDrawingOnTop();
}
-wxDynamicSashWindowImpl *wxDynamicSashWindowImpl::FindParent(DynamicSashRegion side) const {
- if (m_parent == NULL) {
+wxDynamicSashWindowImpl *
+wxDynamicSashWindowImpl::FindParent(DynamicSashRegion side) const
+{
+ if (m_parent == NULL)
return NULL;
- }
- if (m_parent->m_split == DSR_HORIZONTAL_TAB) {
+ if (m_parent->m_split == DSR_HORIZONTAL_TAB)
+ {
if (side == DSR_TOP_EDGE && m_parent->m_child[1] == this)
return m_parent;
if (side == DSR_BOTTOM_EDGE && m_parent->m_child[0] == this)
return m_parent;
- } else if (m_parent->m_split == DSR_VERTICAL_TAB) {
+ }
+ else if (m_parent->m_split == DSR_VERTICAL_TAB)
+ {
if (side == DSR_LEFT_EDGE && m_parent->m_child[1] == this)
return m_parent;
if (side == DSR_RIGHT_EDGE && m_parent->m_child[0] == this)
return m_parent->FindParent(side);
}
-wxDynamicSashWindowImpl *wxDynamicSashWindowImpl::FindUpperParent(wxDynamicSashWindowImpl *sash_a,
- wxDynamicSashWindowImpl *sash_b) const {
+wxDynamicSashWindowImpl *
+wxDynamicSashWindowImpl::FindUpperParent(wxDynamicSashWindowImpl *sash_a,
+ wxDynamicSashWindowImpl *sash_b) const
+{
wxWindow *win;
win = sash_a->m_container->GetParent();
- while (win && !win->IsTopLevel()) {
- if (win == sash_b->m_container) {
+ while (win && !win->IsTopLevel())
+ {
+ if (win == sash_b->m_container)
return sash_b;
- }
win = win->GetParent();
}
}
-wxWindow *wxDynamicSashWindowImpl::FindFrame() const {
+wxWindow *wxDynamicSashWindowImpl::FindFrame() const
+{
wxWindow *win;
win = m_window->GetParent();
- while (win && !win->IsTopLevel()) {
+ while (win && !win->IsTopLevel()
+#ifdef __WXMSW__
+ && ! wxIsKindOf(win, wxMDIChildFrame) // not top-level but still a frame
+#endif
+ )
+ {
win = win->GetParent();
}
return win;
}
-wxScrollBar *wxDynamicSashWindowImpl::FindScrollBar(const wxWindow *child, int vert) const {
- if (m_child[0] == NULL && m_leaf == NULL) {
+wxScrollBar *
+wxDynamicSashWindowImpl::FindScrollBar(const wxWindow *child, int vert) const
+{
+ if (m_child[0] == NULL && m_leaf == NULL)
return NULL;
- }
- if (!m_child[0]) {
+ if (!m_child[0])
+ {
return m_leaf->FindScrollBar(child, vert);
- } else {
- wxScrollBar *ret = m_child[0]->FindScrollBar(child, vert);
- if (!ret) {
- ret = m_child[1]->FindScrollBar(child, vert);
- }
-
- return ret;
}
+
+ wxScrollBar *ret = m_child[0]->FindScrollBar(child, vert);
+ if (!ret)
+ ret = m_child[1]->FindScrollBar(child, vert);
+
+ return ret;
}
-void wxDynamicSashWindowImpl::ConstrainChildren(int px, int py) {
+void wxDynamicSashWindowImpl::ConstrainChildren(int px, int py)
+{
wxLayoutConstraints *layout = new wxLayoutConstraints();
layout->left.SameAs(m_container, wxLeft);
layout->top.SameAs(m_container, wxTop);
- if (m_split == DSR_HORIZONTAL_TAB) {
+ if (m_split == DSR_HORIZONTAL_TAB)
+ {
layout->right.SameAs(m_container, wxRight);
layout->height.PercentOf(m_container, wxHeight, py);
- } else {
+ }
+ else
+ {
layout->bottom.SameAs(m_container, wxBottom);
layout->width.PercentOf(m_container, wxWidth, px);
}
layout = new wxLayoutConstraints();
layout->right.SameAs(m_container, wxRight);
layout->bottom.SameAs(m_container, wxBottom);
- if (m_split == DSR_HORIZONTAL_TAB) {
+ if (m_split == DSR_HORIZONTAL_TAB)
+ {
layout->top.Below(m_child[0]->m_container, 1);
layout->left.SameAs(m_container, wxLeft);
- } else {
+ }
+ else
+ {
layout->left.RightOf(m_child[0]->m_container, 1);
layout->top.SameAs(m_container, wxTop);
}
m_child[1]->m_container->SetConstraints(layout);
}
-void wxDynamicSashWindowImpl::Unify(int panel) {
- int other = 0;
- if (panel == 0) {
- other = 1;
- }
+void wxDynamicSashWindowImpl::Unify(int panel)
+{
+ int other = panel == 0 ? 1 : 0;
- if (m_child[panel]->m_leaf) {
+ if (m_child[panel]->m_leaf)
+ {
wxDynamicSashWindowImpl *child[2];
child[0] = m_child[0];
wxDynamicSashUnifyEvent unify(m_leaf->m_child);
m_leaf->m_child->ProcessEvent(unify);
- } else {
+ }
+ else
+ {
m_split = m_child[panel]->m_split;
delete m_child[other];
}
}
-void wxDynamicSashWindowImpl::Split(int px, int py) {
- m_window->Hide();
+void wxDynamicSashWindowImpl::Split(int px, int py)
+{
m_add_child_target = NULL;
m_child[0] = new wxDynamicSashWindowImpl(m_window);
- m_child[0]->m_container = new wxWindow(m_container, -1);
+ m_child[0]->m_container = new wxWindow(m_container, wxID_ANY);
m_child[0]->m_parent = this;
m_child[0]->m_top = m_top;
m_child[0]->Create();
- if (m_leaf->m_child) {
+ if (m_leaf->m_child)
+ {
m_leaf->m_child->Reparent(m_container);
m_child[0]->AddChild(m_leaf->m_child);
}
m_child[1] = new wxDynamicSashWindowImpl(m_window);
- m_child[1]->m_container = new wxWindow(m_container, -1);
+ m_child[1]->m_container = new wxWindow(m_container, wxID_ANY);
m_child[1]->m_parent = this;
m_child[1]->m_top = m_top;
m_child[1]->Create();
m_leaf = NULL;
m_container->Layout();
-
- m_window->Show();
}
+
/* This code is called when you finish resizing a view by dragging the
corner tab, but I think this implementation is lousy and will surprise
the user more often than it will do what they are trying to do. What
by destroying the neighbors.
But this will do for now. */
-void wxDynamicSashWindowImpl::Resize(int x, int y) {
+void wxDynamicSashWindowImpl::Resize(int x, int y)
+{
wxDynamicSashWindowImpl *h_parent = FindParent(DSR_BOTTOM_EDGE);
wxDynamicSashWindowImpl *v_parent = FindParent(DSR_RIGHT_EDGE);
int h_unify = -1;
int v_unify = -1;
wxWindow *frame = FindFrame();
- if (x < 0) {
+ if (x < 0)
x = 0;
- }
- if (y < 0) {
+ if (y < 0)
y = 0;
- }
- if (h_parent) {
+ if (h_parent)
+ {
m_container->ClientToScreen(NULL, &y);
h_parent->m_container->ScreenToClient(NULL, &y);
int py = (int)((y * 100) / h_parent->m_container->GetSize().GetHeight() + 0.5);
- if (py < 10) {
+ if (py < 10)
+ {
wxDynamicSashWindowImpl *ho_parent = FindParent(DSR_TOP_EDGE);
- if (ho_parent) {
- if (FindUpperParent(h_parent, ho_parent) == ho_parent) {
+ if (ho_parent)
+ {
+ if (FindUpperParent(h_parent, ho_parent) == ho_parent)
+ {
h_unify = 1;
- } else {
+ }
+ else
+ {
py = (int)((ho_parent->m_child[0]->m_container->GetSize().GetHeight() * 100)
/ h_parent->m_container->GetSize().GetHeight() + 0.5);
h_parent->m_child[0]->m_container->GetConstraints()->height.PercentOf(
h_parent = ho_parent;
h_unify = 0;
}
- } else {
+ }
+ else
+ {
h_unify = 1;
}
- } else if (py > 90) {
+ }
+ else if (py > 90)
+ {
h_unify = 0;
- } else {
+ }
+ else
+ {
h_parent->m_child[0]->m_container->GetConstraints()->height.PercentOf(
h_parent->m_container, wxHeight, py);
h_parent->m_container->Layout();
}
- } else {
+ }
+ else
+ {
int do_resize = 1;
h_parent = FindParent(DSR_TOP_EDGE);
- if (h_parent) {
+ if (h_parent)
+ {
int py = (int)((y * 100) /
(h_parent->m_container->GetSize().GetHeight() +
y - m_container->GetSize().GetHeight()) + 0.5);
- if (py < 10) {
+ if (py < 10)
h_unify = 0;
- }
- } else if (y < 64) {
+ }
+ else if (y < 64)
+ {
do_resize = 0;
}
- if (do_resize) {
+ if (do_resize)
+ {
wxSize size = frame->GetSize();
frame->SetSize(size.GetWidth(), size.GetHeight() + y - m_container->GetSize().GetHeight());
}
}
- if (v_parent) {
+ if (v_parent)
+ {
m_container->ClientToScreen(&x, NULL);
v_parent->m_container->ScreenToClient(&x, NULL);
int px = (int)((x * 100) / v_parent->m_container->GetSize().GetWidth() + 0.5);
- if (px < 10) {
+ if (px < 10)
+ {
wxDynamicSashWindowImpl *vo_parent = FindParent(DSR_LEFT_EDGE);
- if (vo_parent) {
- if (FindUpperParent(v_parent, vo_parent) == vo_parent) {
+ if (vo_parent)
+ {
+ if (FindUpperParent(v_parent, vo_parent) == vo_parent)
+ {
v_unify = 1;
- } else {
+ }
+ else
+ {
px = (int)((vo_parent->m_child[0]->m_container->GetSize().GetWidth() * 100)
/ v_parent->m_container->GetSize().GetWidth() + 0.5);
v_parent->m_child[0]->m_container->GetConstraints()->width.PercentOf(
v_parent = vo_parent;
v_unify = 0;
}
- } else {
+ }
+ else
+ {
v_unify = 1;
}
- } else if (px > 90) {
+ }
+ else if (px > 90)
+ {
v_unify = 0;
- } else {
+ }
+ else
+ {
v_parent->m_child[0]->m_container->GetConstraints()->width.PercentOf(
v_parent->m_container, wxWidth, px);
v_parent->m_container->Layout();
}
- } else {
+ }
+ else
+ {
int do_resize = 1;
v_parent = FindParent(DSR_LEFT_EDGE);
- if (v_parent) {
+ if (v_parent)
+ {
int px = (int)((x * 100) /
(v_parent->m_container->GetSize().GetWidth() +
x - m_container->GetSize().GetWidth()) + 0.5);
- if (px < 10) {
+ if (px < 10)
v_unify = 0;
- }
- } else if (x < 64) {
+ }
+ else if (x < 64)
+ {
do_resize = 0;
}
- if (do_resize) {
+ if (do_resize)
+ {
wxSize size = frame->GetSize();
frame->SetSize(size.GetWidth() + x - m_container->GetSize().GetWidth(), size.GetHeight());
}
}
- if (h_unify != -1 && v_unify != -1) {
+ if (h_unify != -1 && v_unify != -1)
+ {
wxDynamicSashWindowImpl *parent = FindUpperParent(h_parent, v_parent);
- if (parent == h_parent) {
+ if (parent == h_parent)
+ {
h_parent->Unify(h_unify);
- } else {
+ }
+ else
+ {
v_parent->Unify(v_unify);
}
- } else if (h_unify != -1) {
+ }
+ else if (h_unify != -1)
+ {
h_parent->Unify(h_unify);
- } else if (v_unify != -1) {
+ }
+ else if (v_unify != -1)
+ {
v_parent->Unify(v_unify);
}
}
-void wxDynamicSashWindowImpl::OnSize(wxSizeEvent &event) {
+void wxDynamicSashWindowImpl::OnSize(wxSizeEvent &event)
+{
m_container->Layout();
if (m_leaf)
m_leaf->OnSize(event);
}
-void wxDynamicSashWindowImpl::OnPaint(wxPaintEvent &event) {
+void wxDynamicSashWindowImpl::OnPaint(wxPaintEvent &event)
+{
if (m_leaf)
m_leaf->OnPaint(event);
- else {
+ else
+ {
wxPaintDC dc(m_container);
dc.SetBackground(wxBrush(m_container->GetBackgroundColour(), wxSOLID));
dc.Clear();
}
}
-void wxDynamicSashWindowImpl::OnMouseMove(wxMouseEvent &event) {
- if (m_dragging) {
+void wxDynamicSashWindowImpl::OnMouseMove(wxMouseEvent &event)
+{
+ if (m_dragging)
+ {
DrawSash(m_drag_x, m_drag_y);
m_drag_x = event.m_x; m_drag_y = event.m_y;
DrawSash(m_drag_x, m_drag_y);
- } else if (m_leaf) {
+ }
+ else if (m_leaf)
+ {
m_leaf->OnMouseMove(event);
}
}
-void wxDynamicSashWindowImpl::OnLeave(wxMouseEvent &event) {
- if (m_leaf) {
+void wxDynamicSashWindowImpl::OnLeave(wxMouseEvent &event)
+{
+ if (m_leaf)
m_leaf->OnLeave(event);
- }
}
-void wxDynamicSashWindowImpl::OnPress(wxMouseEvent &event) {
- if (m_leaf) {
+void wxDynamicSashWindowImpl::OnPress(wxMouseEvent &event)
+{
+ if (m_leaf)
+ {
m_leaf->OnPress(event);
- } else {
+ }
+ else
+ {
m_dragging = m_split;
m_drag_x = event.m_x;
m_drag_y = event.m_y;
}
}
-void wxDynamicSashWindowImpl::OnRelease(wxMouseEvent &event) {
- if (m_dragging == DSR_CORNER) {
+void wxDynamicSashWindowImpl::OnRelease(wxMouseEvent &event)
+{
+ if ((m_dragging == DSR_CORNER) &&
+ (m_window->GetWindowStyle() & wxDS_DRAG_CORNER) != 0)
+ {
DrawSash(m_drag_x, m_drag_y);
m_container->ReleaseMouse();
Resize(event.m_x, event.m_y);
m_dragging = DSR_NONE;
- } else if (m_dragging) {
+ }
+ else if (m_dragging)
+ {
DrawSash(m_drag_x, m_drag_y);
m_container->ReleaseMouse();
int py = (int)((event.m_y * 100) / size.GetHeight() + 0.5);
if ((m_dragging == DSR_HORIZONTAL_TAB && py >= 10 && py <= 90)
- || (m_dragging == DSR_VERTICAL_TAB && px >= 10 && px <= 90)) {
- if (m_child[0] == NULL) {
+ || (m_dragging == DSR_VERTICAL_TAB && px >= 10 && px <= 90))
+ {
+ if (m_child[0] == NULL)
+ {
Split(px, py);
- } else {
+ }
+ else
+ {
/* It would be nice if moving *this* sash didn't implicitly move
the sashes of our children (if any). But this will do. */
wxLayoutConstraints *layout = m_child[0]->m_container->GetConstraints();
- if (m_split == DSR_HORIZONTAL_TAB) {
+ if (m_split == DSR_HORIZONTAL_TAB)
+ {
layout->height.PercentOf(m_container, wxHeight, py);
- } else {
+ }
+ else
+ {
layout->width.PercentOf(m_container, wxWidth, px);
}
m_container->Layout();
}
- } else {
- if (m_child[0] != NULL) {
+ }
+ else
+ {
+ if (m_child[0] != NULL)
+ {
if ((m_dragging == DSR_HORIZONTAL_TAB && py <= 10)
- || (m_dragging == DSR_VERTICAL_TAB && px <= 10)) {
+ || (m_dragging == DSR_VERTICAL_TAB && px <= 10))
+ {
Unify(1);
- } else {
+ }
+ else
+ {
Unify(0);
}
}
}
- wxCursor cursor(wxCURSOR_ARROW);
- if (m_split == DSR_HORIZONTAL_TAB) {
+ wxCursor cursor;
+ if (m_split == DSR_HORIZONTAL_TAB)
cursor = wxCursor(wxCURSOR_SIZENS);
- } else if (m_split == DSR_VERTICAL_TAB) {
+ else if (m_split == DSR_VERTICAL_TAB)
cursor = wxCursor(wxCURSOR_SIZEWE);
- }
+ else
+ cursor = wxCursor(wxCURSOR_ARROW);
+
m_container->SetCursor(cursor);
m_dragging = DSR_NONE;
- } else if (m_leaf) {
+ }
+ else if (m_leaf)
+ {
m_leaf->OnRelease(event);
}
}
-// wxDynamicSashWindowLeaf //////////////////////////////////////////////////
+// ============================================================================
+// wxDynamicSashWindowLeaf
+// ============================================================================
-wxDynamicSashWindowLeaf::wxDynamicSashWindowLeaf(wxDynamicSashWindowImpl *impl) {
+wxDynamicSashWindowLeaf::wxDynamicSashWindowLeaf(wxDynamicSashWindowImpl *impl)
+{
m_impl = impl;
- m_hscroll = m_vscroll = NULL;
+ m_hscroll =
+ m_vscroll = NULL;
+
m_child = NULL;
}
-wxDynamicSashWindowLeaf::~wxDynamicSashWindowLeaf() {
+wxDynamicSashWindowLeaf::~wxDynamicSashWindowLeaf()
+{
m_hscroll->SetEventHandler(m_hscroll);
m_vscroll->SetEventHandler(m_vscroll);
- m_viewport->SetEventHandler(m_viewport);
m_hscroll->Destroy();
m_vscroll->Destroy();
m_viewport->Destroy();
}
-bool wxDynamicSashWindowLeaf::Create() {
- bool success;
-
+bool wxDynamicSashWindowLeaf::Create()
+{
m_hscroll = new wxScrollBar();
m_vscroll = new wxScrollBar();
m_viewport = new wxWindow();
- if (!m_hscroll || !m_vscroll || !m_viewport) {
- return FALSE;
- }
-
wxDynamicSashWindowImpl *add_child_target = m_impl->m_add_child_target;
m_impl->m_add_child_target = NULL;
- success = m_hscroll->Create(m_impl->m_container, -1, wxDefaultPosition, wxDefaultSize,
- wxSB_HORIZONTAL);
- success = success && m_vscroll->Create(m_impl->m_container, -1, wxDefaultPosition, wxDefaultSize,
- wxSB_VERTICAL);
- success = success && m_viewport->Create(m_impl->m_container, -1);
+
+ bool success = m_hscroll->Create(m_impl->m_container, wxID_ANY,
+ wxDefaultPosition, wxDefaultSize,
+ wxSB_HORIZONTAL);
+ if ( success )
+ success = m_vscroll->Create(m_impl->m_container, wxID_ANY,
+ wxDefaultPosition, wxDefaultSize,
+ wxSB_VERTICAL);
+ if ( success )
+ success = m_viewport->Create(m_impl->m_container, wxID_ANY);
+ if ( !success )
+ return false;
+
m_impl->m_add_child_target = add_child_target;
wxCursor cursor(wxCURSOR_ARROW);
m_vscroll->SetCursor(cursor);
m_viewport->SetCursor(cursor);
- m_viewport->SetEventHandler(this);
- Connect(-1, wxEVT_DYNAMIC_SASH_REPARENT, (wxObjectEventFunction)&wxDynamicSashWindowLeaf::OnReparent);
+ // the viewport must resize its child when it is itself resized, but it's
+ // more convenient to do it in our own method instead of deriving a new
+ // class just for this: this is why we pass this as last Connect() argument
+ m_viewport->Connect(wxEVT_SIZE,
+ wxSizeEventHandler(wxDynamicSashWindowLeaf::OnViewSize),
+ NULL, this);
- if (m_impl->m_window->GetWindowStyle() & wxMANAGE_SCROLLBARS) {
+ Connect(wxEVT_DYNAMIC_SASH_REPARENT,
+ wxEventHandler(wxDynamicSashWindowLeaf::OnReparent));
+
+ if (m_impl->m_window->GetWindowStyle() & wxDS_MANAGE_SCROLLBARS)
+ {
m_hscroll->SetEventHandler(this);
m_vscroll->SetEventHandler(this);
- Connect(-1, wxEVT_SET_FOCUS, (wxObjectEventFunction)&wxDynamicSashWindowLeaf::OnFocus);
- Connect(-1, wxEVT_SCROLL_TOP, (wxObjectEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
- Connect(-1, wxEVT_SCROLL_BOTTOM, (wxObjectEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
- Connect(-1, wxEVT_SCROLL_LINEUP, (wxObjectEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
- Connect(-1, wxEVT_SCROLL_LINEDOWN, (wxObjectEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
- Connect(-1, wxEVT_SCROLL_PAGEUP, (wxObjectEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
- Connect(-1, wxEVT_SCROLL_PAGEDOWN, (wxObjectEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
- Connect(-1, wxEVT_SCROLL_THUMBTRACK, (wxObjectEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
- Connect(-1, wxEVT_SCROLL_THUMBRELEASE, (wxObjectEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
+ Connect(wxEVT_SET_FOCUS,
+ wxFocusEventHandler(wxDynamicSashWindowLeaf::OnFocus));
+ Connect(wxEVT_SCROLL_TOP,
+ wxScrollEventHandler(wxDynamicSashWindowLeaf::OnScroll));
+ Connect(wxEVT_SCROLL_BOTTOM,
+ wxScrollEventHandler(wxDynamicSashWindowLeaf::OnScroll));
+ Connect(wxEVT_SCROLL_LINEUP,
+ wxScrollEventHandler(wxDynamicSashWindowLeaf::OnScroll));
+ Connect(wxEVT_SCROLL_LINEDOWN,
+ wxScrollEventHandler(wxDynamicSashWindowLeaf::OnScroll));
+ Connect(wxEVT_SCROLL_PAGEUP,
+ wxScrollEventHandler(wxDynamicSashWindowLeaf::OnScroll));
+ Connect(wxEVT_SCROLL_PAGEDOWN,
+ wxScrollEventHandler(wxDynamicSashWindowLeaf::OnScroll));
+ Connect(wxEVT_SCROLL_THUMBTRACK,
+ wxScrollEventHandler(wxDynamicSashWindowLeaf::OnScroll));
+ Connect(wxEVT_SCROLL_THUMBRELEASE,
+ wxScrollEventHandler(wxDynamicSashWindowLeaf::OnScroll));
}
wxLayoutConstraints *layout = new wxLayoutConstraints();
if (!layout)
- return FALSE;
+ return false;
+
wxSize size = m_hscroll->GetBestSize();
-#ifdef __WXMSW__
- size = m_hscroll->GetSize();
-#endif
layout->left.SameAs(m_impl->m_container, wxLeft, 10);
layout->right.LeftOf(m_vscroll);
layout = new wxLayoutConstraints();
if (!layout)
- return FALSE;
- size = size = m_vscroll->GetBestSize();
-#ifdef __WXMSW__
- size = m_vscroll->GetSize();
-#endif
+ return false;
+
+ size = m_vscroll->GetBestSize();
layout->top.SameAs(m_impl->m_container, wxTop, 10);
layout->bottom.Above(m_hscroll);
layout = new wxLayoutConstraints();
if (!layout)
- return FALSE;
+ return false;
layout->left.SameAs(m_impl->m_container, wxLeft, 3);
layout->right.LeftOf(m_vscroll);
layout->top.SameAs(m_impl->m_container, wxTop, 3);
m_impl->m_container->Layout();
- return success;
+ return true;
}
-void wxDynamicSashWindowLeaf::AddChild(wxWindow *window) {
- if (m_child) {
+void wxDynamicSashWindowLeaf::AddChild(wxWindow *window)
+{
+ if (m_child)
m_child->Destroy();
- }
m_child = window;
AddPendingEvent(event);
}
-DynamicSashRegion wxDynamicSashWindowLeaf::GetRegion(int x, int y) {
+DynamicSashRegion wxDynamicSashWindowLeaf::GetRegion(int x, int y)
+{
wxSize size = m_impl->m_container->GetSize();
int w = size.GetWidth();
int h = size.GetHeight();
return DSR_NONE;
}
-void wxDynamicSashWindowLeaf::ResizeChild(wxSize size) {
- if (m_child) {
- if (m_impl->m_window->GetWindowStyle() & wxMANAGE_SCROLLBARS) {
- m_child->SetSize(size);
+void wxDynamicSashWindowLeaf::ResizeChild(const wxSize& size)
+{
+ if (m_child)
+ {
+ if (m_impl->m_window->HasFlag(wxDS_MANAGE_SCROLLBARS))
+ {
wxSize best_size = m_child->GetBestSize();
- if (best_size.GetWidth() < size.GetWidth()) {
+ if (best_size.GetWidth() < size.GetWidth())
best_size.SetWidth(size.GetWidth());
- }
- if (best_size.GetHeight() < size.GetHeight()) {
+ if (best_size.GetHeight() < size.GetHeight())
best_size.SetHeight(size.GetHeight());
- }
m_child->SetSize(best_size);
int hpos = m_hscroll->GetThumbPosition();
int vpos = m_vscroll->GetThumbPosition();
- if (hpos < 0) {
+ if (hpos < 0)
hpos = 0;
- }
- if (vpos < 0) {
+ if (vpos < 0)
vpos = 0;
- }
- if (hpos > best_size.GetWidth() - size.GetWidth()) {
+ if (hpos > best_size.GetWidth() - size.GetWidth())
hpos = best_size.GetWidth() - size.GetWidth();
- }
- if (vpos > best_size.GetHeight() - size.GetHeight()) {
+ if (vpos > best_size.GetHeight() - size.GetHeight())
vpos = best_size.GetHeight() - size.GetHeight();
- }
m_hscroll->SetScrollbar(hpos, size.GetWidth(),
best_size.GetWidth(), size.GetWidth());
wxPoint pos = m_child->GetPosition();
m_viewport->ScrollWindow(-hpos - pos.x, -vpos - pos.y);
- } else {
+ }
+ else // !wxDS_MANAGE_SCROLLBARS
+ {
m_child->SetSize(size);
}
}
}
-wxScrollBar *wxDynamicSashWindowLeaf::FindScrollBar(const wxWindow *child, int vert) const {
- if (m_child == child) {
- if (vert) {
- return m_vscroll;
- } else {
- return m_hscroll;
- }
+wxScrollBar *
+wxDynamicSashWindowLeaf::FindScrollBar(const wxWindow *child, int vert) const
+{
+ if (m_child == child)
+ {
+ return vert ? m_vscroll : m_hscroll;
}
return NULL;
}
-void wxDynamicSashWindowLeaf::OnSize(wxSizeEvent &event) {
+void wxDynamicSashWindowLeaf::OnSize(wxSizeEvent &WXUNUSED(event))
+{
m_impl->m_container->Refresh();
- ResizeChild(m_viewport->GetSize());
}
-void wxDynamicSashWindowLeaf::OnPaint(wxPaintEvent &event) {
+void wxDynamicSashWindowLeaf::OnViewSize(wxSizeEvent &WXUNUSED(event))
+{
+ if ( m_viewport )
+ ResizeChild(m_viewport->GetSize());
+}
+
+void wxDynamicSashWindowLeaf::OnPaint(wxPaintEvent &WXUNUSED(event))
+{
wxPaintDC dc(m_impl->m_container);
dc.SetBackground(wxBrush(m_impl->m_container->GetBackgroundColour(), wxSOLID));
dc.Clear();
- wxPen highlight(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNHIGHLIGHT), 1, wxSOLID);
- wxPen shadow(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNSHADOW), 1, wxSOLID);
+ wxPen highlight(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNHIGHLIGHT), 1, wxSOLID);
+ wxPen shadow(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNSHADOW), 1, wxSOLID);
wxPen black(*wxBLACK, 1, wxSOLID);
wxSize size = m_impl->m_container->GetSize();
dc.DrawLine(9, h - sh - 3, 9, h - 4);
dc.DrawLine(9, h - 4, 3, h - 4);
-
int cy = (h - sh + h - 6) / 2 + 1;
int cx = (w - sw + w - 6) / 2 + 1;
int sy = cy;
sx -= 4;
int x, y;
- for (y = sy; y < h - 2; y += 4) {
- for (x = sx; x < w - 2; x += 4) {
- if (x - cx >= -(y - cy)) {
+ for (y = sy; y < h - 2; y += 4)
+ {
+ for (x = sx; x < w - 2; x += 4)
+ {
+ if (x - cx >= -(y - cy))
+ {
dc.SetPen(highlight);
dc.DrawPoint(x, y);
dc.SetPen(shadow);
}
}
-void wxDynamicSashWindowLeaf::OnScroll(wxScrollEvent &event) {
+void wxDynamicSashWindowLeaf::OnScroll(wxScrollEvent &WXUNUSED(event))
+{
int nx = -m_hscroll->GetThumbPosition();
int ny = -m_vscroll->GetThumbPosition();
- if (m_child) {
+ if (m_child)
+ {
wxPoint pos = m_child->GetPosition();
m_viewport->ScrollWindow(nx - pos.x, ny - pos.y);
}
}
-void wxDynamicSashWindowLeaf::OnFocus(wxFocusEvent &event) {
- if (event.m_eventObject == m_hscroll || event.m_eventObject == m_vscroll) {
+void wxDynamicSashWindowLeaf::OnFocus(wxFocusEvent &event)
+{
+ if ( event.GetEventObject() == m_hscroll ||
+ event.GetEventObject() == m_vscroll )
+ {
m_child->SetFocus();
}
}
-void wxDynamicSashWindowLeaf::OnMouseMove(wxMouseEvent &event) {
- if (m_impl->m_dragging) {
+void wxDynamicSashWindowLeaf::OnMouseMove(wxMouseEvent &event)
+{
+ if (m_impl->m_dragging)
return;
- }
DynamicSashRegion region = GetRegion(event.m_x, event.m_y);
wxCursor cursor(wxCURSOR_ARROW);
- if (region == DSR_HORIZONTAL_TAB) {
+ if (region == DSR_HORIZONTAL_TAB)
+ {
cursor = wxCursor(wxCURSOR_SIZENS);
- } else if (region == DSR_VERTICAL_TAB) {
+ }
+ else if (region == DSR_VERTICAL_TAB)
+ {
cursor = wxCursor(wxCURSOR_SIZEWE);
- } else if (region == DSR_CORNER) {
+ }
+ else if ((region == DSR_CORNER) &&
+ (m_impl->m_window->GetWindowStyle() & wxDS_DRAG_CORNER) != 0)
+ {
cursor = wxCursor(wxCURSOR_SIZENWSE);
- } else if (region == DSR_LEFT_EDGE || region == DSR_TOP_EDGE
- || region == DSR_RIGHT_EDGE || region == DSR_BOTTOM_EDGE) {
- if (m_impl->FindParent(region)) {
- if (region == DSR_LEFT_EDGE || region == DSR_RIGHT_EDGE) {
+ }
+ else if (region == DSR_LEFT_EDGE || region == DSR_TOP_EDGE
+ || region == DSR_RIGHT_EDGE || region == DSR_BOTTOM_EDGE)
+ {
+ if (m_impl->FindParent(region))
+ {
+ if (region == DSR_LEFT_EDGE || region == DSR_RIGHT_EDGE)
+ {
cursor = wxCursor(wxCURSOR_SIZEWE);
- } else {
+ }
+ else
+ {
cursor = wxCursor(wxCURSOR_SIZENS);
}
}
m_impl->m_container->SetCursor(cursor);
}
-void wxDynamicSashWindowLeaf::OnLeave(wxMouseEvent &event) {
+void wxDynamicSashWindowLeaf::OnLeave(wxMouseEvent &WXUNUSED(event))
+{
wxCursor cursor(wxCURSOR_ARROW);
m_impl->m_container->SetCursor(cursor);
}
-void wxDynamicSashWindowLeaf::OnPress(wxMouseEvent &event) {
+void wxDynamicSashWindowLeaf::OnPress(wxMouseEvent &event)
+{
DynamicSashRegion region = GetRegion(event.m_x, event.m_y);
- if (region == DSR_HORIZONTAL_TAB || region == DSR_VERTICAL_TAB || region == DSR_CORNER) {
+ if ((region == DSR_CORNER) && (m_impl->m_window->GetWindowStyle() & wxDS_DRAG_CORNER) == 0)
+ return;
+
+ if (region == DSR_HORIZONTAL_TAB || region == DSR_VERTICAL_TAB || region == DSR_CORNER)
+ {
m_impl->m_dragging = region;
m_impl->m_drag_x = event.m_x;
m_impl->m_drag_y = event.m_y;
m_impl->DrawSash(event.m_x, event.m_y);
m_impl->m_container->CaptureMouse();
- } else if (region == DSR_LEFT_EDGE || region == DSR_TOP_EDGE
- || region == DSR_RIGHT_EDGE || region == DSR_BOTTOM_EDGE) {
+ }
+ else if (region == DSR_LEFT_EDGE || region == DSR_TOP_EDGE
+ || region == DSR_RIGHT_EDGE || region == DSR_BOTTOM_EDGE)
+ {
wxDynamicSashWindowImpl *parent = m_impl->FindParent(region);
- if (parent) {
+ if (parent)
+ {
int x = event.m_x;
int y = event.m_y;
}
}
-void wxDynamicSashWindowLeaf::OnRelease(wxMouseEvent &event) {
+void wxDynamicSashWindowLeaf::OnRelease(wxMouseEvent &WXUNUSED(event))
+{
}
-void wxDynamicSashWindowLeaf::OnReparent(wxEvent &event) {
- if (m_child) {
+void wxDynamicSashWindowLeaf::OnReparent(wxEvent &WXUNUSED(event))
+{
+ if (m_child)
+ {
m_child->Reparent(m_viewport);
}
ResizeChild(m_viewport->GetSize());
}
-// wxDynamicSashSplitEvent //////////////////////////////////////////////////
+// ============================================================================
+// events
+// ============================================================================
-wxDynamicSashSplitEvent::wxDynamicSashSplitEvent() {
+wxDynamicSashSplitEvent::wxDynamicSashSplitEvent()
+{
m_eventObject = NULL;
m_eventType = wxEVT_DYNAMIC_SASH_SPLIT;
}
-wxDynamicSashSplitEvent::wxDynamicSashSplitEvent(wxObject *object) {
+wxDynamicSashSplitEvent::wxDynamicSashSplitEvent(wxObject *object)
+{
m_eventObject = object;
m_eventType = wxEVT_DYNAMIC_SASH_SPLIT;
}
IMPLEMENT_DYNAMIC_CLASS(wxDynamicSashSplitEvent, wxCommandEvent)
-// wxDynamicSashUnifyEvent //////////////////////////////////////////////////
-
-wxDynamicSashUnifyEvent::wxDynamicSashUnifyEvent() {
+wxDynamicSashUnifyEvent::wxDynamicSashUnifyEvent()
+{
m_eventObject = NULL;
m_eventType = wxEVT_DYNAMIC_SASH_UNIFY;
}
-wxDynamicSashUnifyEvent::wxDynamicSashUnifyEvent(wxObject *object) {
+wxDynamicSashUnifyEvent::wxDynamicSashUnifyEvent(wxObject *object)
+{
m_eventObject = object;
m_eventType = wxEVT_DYNAMIC_SASH_UNIFY;
}
IMPLEMENT_DYNAMIC_CLASS(wxDynamicSashUnifyEvent, wxCommandEvent)
-// wxDynamicSsahReparentEvent ///////////////////////////////////////////////
-wxDynamicSashReparentEvent::wxDynamicSashReparentEvent() {
+wxDynamicSashReparentEvent::wxDynamicSashReparentEvent()
+{
m_eventObject = NULL;
m_eventType = wxEVT_DYNAMIC_SASH_REPARENT;
}
-wxDynamicSashReparentEvent::wxDynamicSashReparentEvent(wxObject *object) {
+wxDynamicSashReparentEvent::wxDynamicSashReparentEvent(wxObject *object)
+{
m_eventObject = object;
m_eventType = wxEVT_DYNAMIC_SASH_REPARENT;
}
+wxDynamicSashReparentEvent::wxDynamicSashReparentEvent(const wxDynamicSashReparentEvent& evt)
+ : wxEvent(evt)
+{
+}
+
IMPLEMENT_DYNAMIC_CLASS(wxDynamicSashReparentEvent, wxEvent)
-/////////////////////////////////////////////////////////////////////////////
projects / wxWidgets.git / blobdiff