GUI: Added the wx_aui files
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4054 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
John Peterson
parent
97e3db2eb9
commit
3b84e35e38
|
|
@ -0,0 +1,684 @@
|
|||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/aui/toolbar.h
|
||||
// Purpose: wxaui: wx advanced user interface - docking window manager
|
||||
// Author: Benjamin I. Williams
|
||||
// Modified by:
|
||||
// Created: 2008-08-04
|
||||
// RCS-ID: $Id: auibar.h 55522 2008-09-08 09:54:28Z BIW $
|
||||
// Copyright: (C) Copyright 2005, Kirix Corporation, All Rights Reserved.
|
||||
// Licence: wxWindows Library Licence, Version 3.1
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_AUIBAR_H_
|
||||
#define _WX_AUIBAR_H_
|
||||
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_AUI
|
||||
|
||||
#if wxABI_VERSION >= 20809
|
||||
|
||||
#include "wx/control.h"
|
||||
|
||||
enum wxAuiToolBarStyle
|
||||
{
|
||||
wxAUI_TB_TEXT = 1 << 0,
|
||||
wxAUI_TB_NO_TOOLTIPS = 1 << 1,
|
||||
wxAUI_TB_NO_AUTORESIZE = 1 << 2,
|
||||
wxAUI_TB_GRIPPER = 1 << 3,
|
||||
wxAUI_TB_OVERFLOW = 1 << 4,
|
||||
wxAUI_TB_VERTICAL = 1 << 5,
|
||||
wxAUI_TB_HORZ_LAYOUT = 1 << 6,
|
||||
wxAUI_TB_HORZ_TEXT = (wxAUI_TB_HORZ_LAYOUT | wxAUI_TB_TEXT),
|
||||
wxAUI_TB_DEFAULT_STYLE = 0
|
||||
};
|
||||
|
||||
enum wxAuiToolBarArtSetting
|
||||
{
|
||||
wxAUI_TBART_SEPARATOR_SIZE = 0,
|
||||
wxAUI_TBART_GRIPPER_SIZE = 1,
|
||||
wxAUI_TBART_OVERFLOW_SIZE = 2
|
||||
};
|
||||
|
||||
enum wxAuiToolBarToolTextOrientation
|
||||
{
|
||||
wxAUI_TBTOOL_TEXT_LEFT = 0, // unused/unimplemented
|
||||
wxAUI_TBTOOL_TEXT_RIGHT = 1,
|
||||
wxAUI_TBTOOL_TEXT_TOP = 2, // unused/unimplemented
|
||||
wxAUI_TBTOOL_TEXT_BOTTOM = 3
|
||||
};
|
||||
|
||||
|
||||
// aui toolbar event class
|
||||
|
||||
class WXDLLIMPEXP_AUI wxAuiToolBarEvent : public wxNotifyEvent
|
||||
{
|
||||
public:
|
||||
wxAuiToolBarEvent(wxEventType command_type = wxEVT_NULL,
|
||||
int win_id = 0)
|
||||
: wxNotifyEvent(command_type, win_id)
|
||||
{
|
||||
is_dropdown_clicked = false;
|
||||
click_pt = wxPoint(-1, -1);
|
||||
rect = wxRect(-1,-1, 0, 0);
|
||||
tool_id = -1;
|
||||
}
|
||||
#ifndef SWIG
|
||||
wxAuiToolBarEvent(const wxAuiToolBarEvent& c) : wxNotifyEvent(c)
|
||||
{
|
||||
is_dropdown_clicked = c.is_dropdown_clicked;
|
||||
click_pt = c.click_pt;
|
||||
rect = c.rect;
|
||||
tool_id = c.tool_id;
|
||||
}
|
||||
#endif
|
||||
wxEvent *Clone() const { return new wxAuiToolBarEvent(*this); }
|
||||
|
||||
bool IsDropDownClicked() const { return is_dropdown_clicked; }
|
||||
void SetDropDownClicked(bool c) { is_dropdown_clicked = c; }
|
||||
|
||||
wxPoint GetClickPoint() const { return click_pt; }
|
||||
void SetClickPoint(const wxPoint& p) { click_pt = p; }
|
||||
|
||||
wxRect GetItemRect() const { return rect; }
|
||||
void SetItemRect(const wxRect& r) { rect = r; }
|
||||
|
||||
int GetToolId() const { return tool_id; }
|
||||
void SetToolId(int id) { tool_id = id; }
|
||||
|
||||
private:
|
||||
|
||||
bool is_dropdown_clicked;
|
||||
wxPoint click_pt;
|
||||
wxRect rect;
|
||||
int tool_id;
|
||||
|
||||
#ifndef SWIG
|
||||
private:
|
||||
DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxAuiToolBarEvent)
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
class WXDLLIMPEXP_AUI wxAuiToolBarItem
|
||||
{
|
||||
friend class wxAuiToolBar;
|
||||
|
||||
public:
|
||||
|
||||
wxAuiToolBarItem()
|
||||
{
|
||||
window = NULL;
|
||||
sizer_item = NULL;
|
||||
spacer_pixels = 0;
|
||||
id = 0;
|
||||
kind = wxITEM_NORMAL;
|
||||
state = 0; // normal, enabled
|
||||
proportion = 0;
|
||||
active = true;
|
||||
dropdown = true;
|
||||
sticky = true;
|
||||
user_data = 0;
|
||||
}
|
||||
|
||||
wxAuiToolBarItem(const wxAuiToolBarItem& c)
|
||||
{
|
||||
Assign(c);
|
||||
}
|
||||
|
||||
wxAuiToolBarItem& operator=(const wxAuiToolBarItem& c)
|
||||
{
|
||||
Assign(c);
|
||||
return *this;
|
||||
}
|
||||
|
||||
void Assign(const wxAuiToolBarItem& c)
|
||||
{
|
||||
window = c.window;
|
||||
label = c.label;
|
||||
bitmap = c.bitmap;
|
||||
disabled_bitmap = c.disabled_bitmap;
|
||||
hover_bitmap = c.hover_bitmap;
|
||||
short_help = c.short_help;
|
||||
long_help = c.long_help;
|
||||
sizer_item = c.sizer_item;
|
||||
min_size = c.min_size;
|
||||
spacer_pixels = c.spacer_pixels;
|
||||
id = c.id;
|
||||
kind = c.kind;
|
||||
state = c.state;
|
||||
proportion = c.proportion;
|
||||
active = c.active;
|
||||
dropdown = c.dropdown;
|
||||
sticky = c.sticky;
|
||||
user_data = c.user_data;
|
||||
}
|
||||
|
||||
|
||||
void SetWindow(wxWindow* w) { window = w; }
|
||||
wxWindow* GetWindow() { return window; }
|
||||
|
||||
void SetId(int new_id) { id = new_id; }
|
||||
int GetId() const { return id; }
|
||||
|
||||
void SetKind(int new_kind) { kind = new_kind; }
|
||||
int GetKind() const { return kind; }
|
||||
|
||||
void SetState(int new_state) { state = new_state; }
|
||||
int GetState() const { return state; }
|
||||
|
||||
void SetSizerItem(wxSizerItem* s) { sizer_item = s; }
|
||||
wxSizerItem* GetSizerItem() const { return sizer_item; }
|
||||
|
||||
void SetLabel(const wxString& s) { label = s; }
|
||||
const wxString& GetLabel() const { return label; }
|
||||
|
||||
void SetBitmap(const wxBitmap& bmp) { bitmap = bmp; }
|
||||
const wxBitmap& GetBitmap() const { return bitmap; }
|
||||
|
||||
void SetDisabledBitmap(const wxBitmap& bmp) { disabled_bitmap = bmp; }
|
||||
const wxBitmap& GetDisabledBitmap() const { return disabled_bitmap; }
|
||||
|
||||
void SetHoverBitmap(const wxBitmap& bmp) { hover_bitmap = bmp; }
|
||||
const wxBitmap& GetHoverBitmap() const { return hover_bitmap; }
|
||||
|
||||
void SetShortHelp(const wxString& s) { short_help = s; }
|
||||
const wxString& GetShortHelp() const { return short_help; }
|
||||
|
||||
void SetLongHelp(const wxString& s) { long_help = s; }
|
||||
const wxString& GetLongHelp() const { return long_help; }
|
||||
|
||||
void SetMinSize(const wxSize& s) { min_size = s; }
|
||||
const wxSize& GetMinSize() const { return min_size; }
|
||||
|
||||
void SetSpacerPixels(int s) { spacer_pixels = s; }
|
||||
int GetSpacerPixels() const { return spacer_pixels; }
|
||||
|
||||
void SetProportion(int p) { proportion = p; }
|
||||
int GetProportion() const { return proportion; }
|
||||
|
||||
void SetActive(bool b) { active = b; }
|
||||
bool IsActive() const { return active; }
|
||||
|
||||
void SetHasDropDown(bool b) { dropdown = b; }
|
||||
bool HasDropDown() const { return dropdown; }
|
||||
|
||||
void SetSticky(bool b) { sticky = b; }
|
||||
bool IsSticky() const { return sticky; }
|
||||
|
||||
void SetUserData(long l) { user_data = l; }
|
||||
long GetUserData() const { return user_data; }
|
||||
|
||||
private:
|
||||
|
||||
wxWindow* window; // item's associated window
|
||||
wxString label; // label displayed on the item
|
||||
wxBitmap bitmap; // item's bitmap
|
||||
wxBitmap disabled_bitmap; // item's disabled bitmap
|
||||
wxBitmap hover_bitmap; // item's hover bitmap
|
||||
wxString short_help; // short help (for tooltip)
|
||||
wxString long_help; // long help (for status bar)
|
||||
wxSizerItem* sizer_item; // sizer item
|
||||
wxSize min_size; // item's minimum size
|
||||
int spacer_pixels; // size of a spacer
|
||||
int id; // item's id
|
||||
int kind; // item's kind
|
||||
int state; // state
|
||||
int proportion; // proportion
|
||||
bool active; // true if the item is currently active
|
||||
bool dropdown; // true if the item has a dropdown button
|
||||
bool sticky; // overrides button states if true (always active)
|
||||
long user_data; // user-specified data
|
||||
};
|
||||
|
||||
#ifndef SWIG
|
||||
WX_DECLARE_USER_EXPORTED_OBJARRAY(wxAuiToolBarItem, wxAuiToolBarItemArray, WXDLLIMPEXP_AUI);
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
// tab art class
|
||||
|
||||
class WXDLLIMPEXP_AUI wxAuiToolBarArt
|
||||
{
|
||||
public:
|
||||
|
||||
wxAuiToolBarArt() { }
|
||||
virtual ~wxAuiToolBarArt() { }
|
||||
|
||||
virtual wxAuiToolBarArt* Clone() = 0;
|
||||
virtual void SetFlags(unsigned int flags) = 0;
|
||||
virtual void SetFont(const wxFont& font) = 0;
|
||||
virtual void SetTextOrientation(int orientation) = 0;
|
||||
|
||||
virtual void DrawBackground(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxRect& rect) = 0;
|
||||
|
||||
virtual void DrawLabel(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxAuiToolBarItem& item,
|
||||
const wxRect& rect) = 0;
|
||||
|
||||
virtual void DrawButton(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxAuiToolBarItem& item,
|
||||
const wxRect& rect) = 0;
|
||||
|
||||
virtual void DrawDropDownButton(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxAuiToolBarItem& item,
|
||||
const wxRect& rect) = 0;
|
||||
|
||||
virtual void DrawControlLabel(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxAuiToolBarItem& item,
|
||||
const wxRect& rect) = 0;
|
||||
|
||||
virtual void DrawSeparator(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxRect& rect) = 0;
|
||||
|
||||
virtual void DrawGripper(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxRect& rect) = 0;
|
||||
|
||||
virtual void DrawOverflowButton(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxRect& rect,
|
||||
int state) = 0;
|
||||
|
||||
virtual wxSize GetLabelSize(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxAuiToolBarItem& item) = 0;
|
||||
|
||||
virtual wxSize GetToolSize(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxAuiToolBarItem& item) = 0;
|
||||
|
||||
virtual int GetElementSize(int element_id) = 0;
|
||||
virtual void SetElementSize(int element_id, int size) = 0;
|
||||
|
||||
virtual int ShowDropDown(
|
||||
wxWindow* wnd,
|
||||
const wxAuiToolBarItemArray& items) = 0;
|
||||
};
|
||||
|
||||
|
||||
|
||||
class WXDLLIMPEXP_AUI wxAuiDefaultToolBarArt : public wxAuiToolBarArt
|
||||
{
|
||||
|
||||
public:
|
||||
|
||||
wxAuiDefaultToolBarArt();
|
||||
virtual ~wxAuiDefaultToolBarArt();
|
||||
|
||||
virtual wxAuiToolBarArt* Clone();
|
||||
virtual void SetFlags(unsigned int flags);
|
||||
virtual void SetFont(const wxFont& font);
|
||||
virtual void SetTextOrientation(int orientation);
|
||||
|
||||
virtual void DrawBackground(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxRect& rect);
|
||||
|
||||
virtual void DrawLabel(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxAuiToolBarItem& item,
|
||||
const wxRect& rect);
|
||||
|
||||
virtual void DrawButton(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxAuiToolBarItem& item,
|
||||
const wxRect& rect);
|
||||
|
||||
virtual void DrawDropDownButton(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxAuiToolBarItem& item,
|
||||
const wxRect& rect);
|
||||
|
||||
virtual void DrawControlLabel(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxAuiToolBarItem& item,
|
||||
const wxRect& rect);
|
||||
|
||||
virtual void DrawSeparator(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxRect& rect);
|
||||
|
||||
virtual void DrawGripper(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxRect& rect);
|
||||
|
||||
virtual void DrawOverflowButton(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxRect& rect,
|
||||
int state);
|
||||
|
||||
virtual wxSize GetLabelSize(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxAuiToolBarItem& item);
|
||||
|
||||
virtual wxSize GetToolSize(
|
||||
wxDC& dc,
|
||||
wxWindow* wnd,
|
||||
const wxAuiToolBarItem& item);
|
||||
|
||||
virtual int GetElementSize(int element);
|
||||
virtual void SetElementSize(int element_id, int size);
|
||||
|
||||
virtual int ShowDropDown(wxWindow* wnd,
|
||||
const wxAuiToolBarItemArray& items);
|
||||
|
||||
protected:
|
||||
|
||||
wxBitmap m_button_dropdown_bmp;
|
||||
wxBitmap m_disabled_button_dropdown_bmp;
|
||||
wxBitmap m_overflow_bmp;
|
||||
wxBitmap m_disabled_overflow_bmp;
|
||||
wxColour m_base_colour;
|
||||
wxColour m_highlight_colour;
|
||||
wxFont m_font;
|
||||
unsigned int m_flags;
|
||||
int m_text_orientation;
|
||||
|
||||
wxPen m_gripper_pen1;
|
||||
wxPen m_gripper_pen2;
|
||||
wxPen m_gripper_pen3;
|
||||
|
||||
int m_separator_size;
|
||||
int m_gripper_size;
|
||||
int m_overflow_size;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
class WXDLLIMPEXP_AUI wxAuiToolBar : public wxControl
|
||||
{
|
||||
public:
|
||||
|
||||
wxAuiToolBar(wxWindow* parent,
|
||||
wxWindowID id = -1,
|
||||
const wxPoint& position = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize,
|
||||
long style = wxAUI_TB_DEFAULT_STYLE);
|
||||
~wxAuiToolBar();
|
||||
|
||||
void SetWindowStyleFlag(long style);
|
||||
|
||||
void SetArtProvider(wxAuiToolBarArt* art);
|
||||
wxAuiToolBarArt* GetArtProvider() const;
|
||||
|
||||
bool SetFont(const wxFont& font);
|
||||
|
||||
|
||||
void AddTool(int tool_id,
|
||||
const wxString& label,
|
||||
const wxBitmap& bitmap,
|
||||
const wxString& short_help_string = wxEmptyString,
|
||||
wxItemKind kind = wxITEM_NORMAL);
|
||||
|
||||
void AddTool(int tool_id,
|
||||
const wxString& label,
|
||||
const wxBitmap& bitmap,
|
||||
const wxBitmap& disabled_bitmap,
|
||||
wxItemKind kind,
|
||||
const wxString& short_help_string,
|
||||
const wxString& long_help_string,
|
||||
wxObject* client_data);
|
||||
|
||||
void AddTool(int tool_id,
|
||||
const wxBitmap& bitmap,
|
||||
const wxBitmap& disabled_bitmap,
|
||||
bool toggle = false,
|
||||
wxObject* client_data = NULL,
|
||||
const wxString& short_help_string = wxEmptyString,
|
||||
const wxString& long_help_string = wxEmptyString)
|
||||
{
|
||||
AddTool(tool_id,
|
||||
wxEmptyString,
|
||||
bitmap,
|
||||
disabled_bitmap,
|
||||
toggle ? wxITEM_CHECK : wxITEM_NORMAL,
|
||||
short_help_string,
|
||||
long_help_string,
|
||||
client_data);
|
||||
}
|
||||
|
||||
void AddLabel(int tool_id,
|
||||
const wxString& label = wxEmptyString,
|
||||
const int width = -1);
|
||||
void AddControl(wxControl* control,
|
||||
const wxString& label = wxEmptyString);
|
||||
void AddSeparator();
|
||||
void AddSpacer(int pixels);
|
||||
void AddStretchSpacer(int proportion = 1);
|
||||
|
||||
bool Realize();
|
||||
|
||||
wxControl* FindControl(int window_id);
|
||||
wxAuiToolBarItem* FindToolByPosition(wxCoord x, wxCoord y) const;
|
||||
wxAuiToolBarItem* FindToolByIndex(int idx) const;
|
||||
wxAuiToolBarItem* FindTool(int tool_id) const;
|
||||
|
||||
void ClearTools() { Clear() ; }
|
||||
void Clear();
|
||||
bool DeleteTool(int tool_id);
|
||||
bool DeleteByIndex(int tool_id);
|
||||
|
||||
size_t GetToolCount() const;
|
||||
int GetToolPos(int tool_id) const { return GetToolIndex(tool_id); }
|
||||
int GetToolIndex(int tool_id) const;
|
||||
bool GetToolFits(int tool_id) const;
|
||||
wxRect GetToolRect(int tool_id) const;
|
||||
bool GetToolFitsByIndex(int tool_id) const;
|
||||
bool GetToolBarFits() const;
|
||||
|
||||
void SetMargins(const wxSize& size) { SetMargins(size.x, size.x, size.y, size.y); }
|
||||
void SetMargins(int x, int y) { SetMargins(x, x, y, y); }
|
||||
void SetMargins(int left, int right, int top, int bottom);
|
||||
|
||||
void SetToolBitmapSize(const wxSize& size);
|
||||
wxSize GetToolBitmapSize() const;
|
||||
|
||||
bool GetOverflowVisible() const;
|
||||
void SetOverflowVisible(bool visible);
|
||||
|
||||
bool GetGripperVisible() const;
|
||||
void SetGripperVisible(bool visible);
|
||||
|
||||
void ToggleTool(int tool_id, bool state);
|
||||
bool GetToolToggled(int tool_id) const;
|
||||
|
||||
void EnableTool(int tool_id, bool state);
|
||||
bool GetToolEnabled(int tool_id) const;
|
||||
|
||||
void SetToolDropDown(int tool_id, bool dropdown);
|
||||
bool GetToolDropDown(int tool_id) const;
|
||||
|
||||
void SetToolBorderPadding(int padding);
|
||||
int GetToolBorderPadding() const;
|
||||
|
||||
void SetToolTextOrientation(int orientation);
|
||||
int GetToolTextOrientation() const;
|
||||
|
||||
void SetToolPacking(int packing);
|
||||
int GetToolPacking() const;
|
||||
|
||||
void SetToolProportion(int tool_id, int proportion);
|
||||
int GetToolProportion(int tool_id) const;
|
||||
|
||||
void SetToolSeparation(int separation);
|
||||
int GetToolSeparation() const;
|
||||
|
||||
void SetToolSticky(int tool_id, bool sticky);
|
||||
bool GetToolSticky(int tool_id) const;
|
||||
|
||||
wxString GetToolLabel(int tool_id) const;
|
||||
void SetToolLabel(int tool_id, const wxString& label);
|
||||
|
||||
wxBitmap GetToolBitmap(int tool_id) const;
|
||||
void SetToolBitmap(int tool_id, const wxBitmap& bitmap);
|
||||
|
||||
wxString GetToolShortHelp(int tool_id) const;
|
||||
void SetToolShortHelp(int tool_id, const wxString& help_string);
|
||||
|
||||
wxString GetToolLongHelp(int tool_id) const;
|
||||
void SetToolLongHelp(int tool_id, const wxString& help_string);
|
||||
|
||||
void SetCustomOverflowItems(const wxAuiToolBarItemArray& prepend,
|
||||
const wxAuiToolBarItemArray& append);
|
||||
|
||||
protected:
|
||||
|
||||
virtual void OnCustomRender(wxDC& WXUNUSED(dc),
|
||||
const wxAuiToolBarItem& WXUNUSED(item),
|
||||
const wxRect& WXUNUSED(rect)) { }
|
||||
|
||||
protected:
|
||||
|
||||
void DoIdleUpdate();
|
||||
void SetOrientation(int orientation);
|
||||
void SetHoverItem(wxAuiToolBarItem* item);
|
||||
void SetPressedItem(wxAuiToolBarItem* item);
|
||||
void RefreshOverflowState();
|
||||
|
||||
int GetOverflowState() const;
|
||||
wxRect GetOverflowRect() const;
|
||||
wxSize GetLabelSize(const wxString& label);
|
||||
wxAuiToolBarItem* FindToolByPositionWithPacking(wxCoord x, wxCoord y) const;
|
||||
|
||||
void DoSetSize(int x,
|
||||
int y,
|
||||
int width,
|
||||
int height,
|
||||
int sizeFlags = wxSIZE_AUTO);
|
||||
|
||||
protected: // handlers
|
||||
|
||||
void OnSize(wxSizeEvent& evt);
|
||||
void OnIdle(wxIdleEvent& evt);
|
||||
void OnPaint(wxPaintEvent& evt);
|
||||
void OnEraseBackground(wxEraseEvent& evt);
|
||||
void OnLeftDown(wxMouseEvent& evt);
|
||||
void OnLeftUp(wxMouseEvent& evt);
|
||||
void OnRightDown(wxMouseEvent& evt);
|
||||
void OnRightUp(wxMouseEvent& evt);
|
||||
void OnMiddleDown(wxMouseEvent& evt);
|
||||
void OnMiddleUp(wxMouseEvent& evt);
|
||||
void OnMotion(wxMouseEvent& evt);
|
||||
void OnLeaveWindow(wxMouseEvent& evt);
|
||||
void OnSetCursor(wxSetCursorEvent& evt);
|
||||
|
||||
protected:
|
||||
|
||||
wxAuiToolBarItemArray m_items; // array of toolbar items
|
||||
wxAuiToolBarArt* m_art; // art provider
|
||||
wxBoxSizer* m_sizer; // main sizer for toolbar
|
||||
wxAuiToolBarItem* m_action_item; // item that's being acted upon (pressed)
|
||||
wxAuiToolBarItem* m_tip_item; // item that has its tooltip shown
|
||||
wxBitmap m_bitmap; // double-buffer bitmap
|
||||
wxSizerItem* m_gripper_sizer_item;
|
||||
wxSizerItem* m_overflow_sizer_item;
|
||||
wxSize m_absolute_min_size;
|
||||
wxPoint m_action_pos; // position of left-mouse down
|
||||
wxAuiToolBarItemArray m_custom_overflow_prepend;
|
||||
wxAuiToolBarItemArray m_custom_overflow_append;
|
||||
|
||||
int m_button_width;
|
||||
int m_button_height;
|
||||
int m_sizer_element_count;
|
||||
int m_left_padding;
|
||||
int m_right_padding;
|
||||
int m_top_padding;
|
||||
int m_bottom_padding;
|
||||
int m_tool_packing;
|
||||
int m_tool_border_padding;
|
||||
int m_tool_text_orientation;
|
||||
int m_overflow_state;
|
||||
bool m_dragging;
|
||||
bool m_gripper_visible;
|
||||
bool m_overflow_visible;
|
||||
long m_style;
|
||||
|
||||
DECLARE_EVENT_TABLE()
|
||||
DECLARE_CLASS(wxAuiToolBar)
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
// wx event machinery
|
||||
|
||||
#ifndef SWIG
|
||||
|
||||
BEGIN_DECLARE_EVENT_TYPES()
|
||||
DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_AUI, wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN, 0)
|
||||
DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_AUI, wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK, 0)
|
||||
DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_AUI, wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, 0)
|
||||
DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_AUI, wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK, 0)
|
||||
DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_AUI, wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG, 0)
|
||||
END_DECLARE_EVENT_TYPES()
|
||||
|
||||
typedef void (wxEvtHandler::*wxAuiToolBarEventFunction)(wxAuiToolBarEvent&);
|
||||
|
||||
#define wxAuiToolBarEventHandler(func) \
|
||||
(wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxAuiToolBarEventFunction, &func)
|
||||
|
||||
#define EVT_AUITOOLBAR_TOOL_DROPDOWN(winid, fn) \
|
||||
wx__DECLARE_EVT1(wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN, winid, wxAuiToolBarEventHandler(fn))
|
||||
#define EVT_AUITOOLBAR_OVERFLOW_CLICK(winid, fn) \
|
||||
wx__DECLARE_EVT1(wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK, winid, wxAuiToolBarEventHandler(fn))
|
||||
#define EVT_AUITOOLBAR_RIGHT_CLICK(winid, fn) \
|
||||
wx__DECLARE_EVT1(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, winid, wxAuiToolBarEventHandler(fn))
|
||||
#define EVT_AUITOOLBAR_MIDDLE_CLICK(winid, fn) \
|
||||
wx__DECLARE_EVT1(wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK, winid, wxAuiToolBarEventHandler(fn))
|
||||
#define EVT_AUITOOLBAR_BEGIN_DRAG(winid, fn) \
|
||||
wx__DECLARE_EVT1(wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG, winid, wxAuiToolBarEventHandler(fn))
|
||||
|
||||
#else
|
||||
|
||||
// wxpython/swig event work
|
||||
%constant wxEventType wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN;
|
||||
%constant wxEventType wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK;
|
||||
%constant wxEventType wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK;
|
||||
%constant wxEventType wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK;
|
||||
%constant wxEventType wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG;
|
||||
|
||||
%pythoncode {
|
||||
EVT_AUITOOLBAR_TOOL_DROPDOWN = wx.PyEventBinder( wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN, 1 )
|
||||
EVT_AUITOOLBAR_OVERFLOW_CLICK = wx.PyEventBinder( wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK, 1 )
|
||||
EVT_AUITOOLBAR_RIGHT_CLICK = wx.PyEventBinder( wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, 1 )
|
||||
EVT_AUITOOLBAR_MIDDLE_CLICK = wx.PyEventBinder( wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK, 1 )
|
||||
EVT_AUITOOLBAR_BEGIN_DRAG = wx.PyEventBinder( wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG, 1 )
|
||||
}
|
||||
#endif // SWIG
|
||||
|
||||
#endif // wxABI_VERSION >= 20809
|
||||
|
||||
#endif // wxUSE_AUI
|
||||
|
||||
#endif // _WX_AUIBAR_H_
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,771 @@
|
|||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: src/aui/dockart.cpp
|
||||
// Purpose: wxaui: wx advanced user interface - docking window manager
|
||||
// Author: Benjamin I. Williams
|
||||
// Modified by:
|
||||
// Created: 2005-05-17
|
||||
// RCS-ID: $Id: dockart.cpp 55210 2008-08-23 18:17:49Z VZ $
|
||||
// Copyright: (C) Copyright 2005-2006, Kirix Corporation, All Rights Reserved
|
||||
// Licence: wxWindows Library Licence, Version 3.1
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// ============================================================================
|
||||
// declarations
|
||||
// ============================================================================
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#include "wx/wxprec.h"
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma hdrstop
|
||||
#endif
|
||||
|
||||
#if wxUSE_AUI
|
||||
|
||||
#include "wx/aui/framemanager.h"
|
||||
#include "wx/aui/dockart.h"
|
||||
|
||||
#ifndef WX_PRECOMP
|
||||
#include "wx/settings.h"
|
||||
#include "wx/dcclient.h"
|
||||
#include "wx/image.h"
|
||||
#endif
|
||||
|
||||
#ifdef __WXMAC__
|
||||
#include "wx/mac/private.h"
|
||||
#include "wx/graphics.h"
|
||||
#endif
|
||||
|
||||
#ifdef __WXGTK__
|
||||
#include <gtk/gtk.h>
|
||||
#include "wx/gtk/win_gtk.h"
|
||||
#include "wx/renderer.h"
|
||||
#endif
|
||||
|
||||
|
||||
// -- wxAuiDefaultDockArt class implementation --
|
||||
|
||||
// wxAuiDefaultDockArt is an art provider class which does all of the drawing for
|
||||
// wxAuiManager. This allows the library caller to customize the dock art
|
||||
// (probably by deriving from this class), or to completely replace all drawing
|
||||
// with custom dock art (probably by writing a new stand-alone class derived
|
||||
// from the wxAuiDockArt base class). The active dock art class can be set via
|
||||
// wxAuiManager::SetDockArt()
|
||||
|
||||
|
||||
// wxAuiBlendColour is used by wxAuiStepColour
|
||||
unsigned char wxAuiBlendColour(unsigned char fg, unsigned char bg, double alpha)
|
||||
{
|
||||
double result = bg + (alpha * (fg - bg));
|
||||
if (result < 0.0)
|
||||
result = 0.0;
|
||||
if (result > 255)
|
||||
result = 255;
|
||||
return (unsigned char)result;
|
||||
}
|
||||
|
||||
// wxAuiStepColour() it a utility function that simply darkens
|
||||
// or lightens a color, based on the specified percentage
|
||||
// ialpha of 0 would be completely black, 100 completely white
|
||||
// an ialpha of 100 returns the same colour
|
||||
wxColor wxAuiStepColour(const wxColor& c, int ialpha)
|
||||
{
|
||||
if (ialpha == 100)
|
||||
return c;
|
||||
|
||||
unsigned char r = c.Red(),
|
||||
g = c.Green(),
|
||||
b = c.Blue();
|
||||
unsigned char bg;
|
||||
|
||||
// ialpha is 0..200 where 0 is completely black
|
||||
// and 200 is completely white and 100 is the same
|
||||
// convert that to normal alpha 0.0 - 1.0
|
||||
ialpha = wxMin(ialpha, 200);
|
||||
ialpha = wxMax(ialpha, 0);
|
||||
double alpha = ((double)(ialpha - 100.0))/100.0;
|
||||
|
||||
if (ialpha > 100)
|
||||
{
|
||||
// blend with white
|
||||
bg = 255;
|
||||
alpha = 1.0 - alpha; // 0 = transparent fg; 1 = opaque fg
|
||||
}
|
||||
else
|
||||
{
|
||||
// blend with black
|
||||
bg = 0;
|
||||
alpha += 1.0; // 0 = transparent fg; 1 = opaque fg
|
||||
}
|
||||
|
||||
r = wxAuiBlendColour(r, bg, alpha);
|
||||
g = wxAuiBlendColour(g, bg, alpha);
|
||||
b = wxAuiBlendColour(b, bg, alpha);
|
||||
|
||||
return wxColour(r, g, b);
|
||||
}
|
||||
|
||||
|
||||
wxColor wxAuiLightContrastColour(const wxColour& c)
|
||||
{
|
||||
int amount = 120;
|
||||
|
||||
// if the color is especially dark, then
|
||||
// make the contrast even lighter
|
||||
if (c.Red() < 128 && c.Green() < 128 && c.Blue() < 128)
|
||||
amount = 160;
|
||||
|
||||
return wxAuiStepColour(c, amount);
|
||||
}
|
||||
|
||||
// wxAuiBitmapFromBits() is a utility function that creates a
|
||||
// masked bitmap from raw bits (XBM format)
|
||||
wxBitmap wxAuiBitmapFromBits(const unsigned char bits[], int w, int h,
|
||||
const wxColour& color)
|
||||
{
|
||||
wxImage img = wxBitmap((const char*)bits, w, h).ConvertToImage();
|
||||
img.Replace(0,0,0,123,123,123);
|
||||
img.Replace(255,255,255,color.Red(),color.Green(),color.Blue());
|
||||
img.SetMaskColour(123,123,123);
|
||||
return wxBitmap(img);
|
||||
}
|
||||
|
||||
|
||||
static void DrawGradientRectangle(wxDC& dc,
|
||||
const wxRect& rect,
|
||||
const wxColour& start_color,
|
||||
const wxColour& end_color,
|
||||
int direction)
|
||||
{
|
||||
int rd, gd, bd, high = 0;
|
||||
rd = end_color.Red() - start_color.Red();
|
||||
gd = end_color.Green() - start_color.Green();
|
||||
bd = end_color.Blue() - start_color.Blue();
|
||||
|
||||
if (direction == wxAUI_GRADIENT_VERTICAL)
|
||||
high = rect.GetHeight()-1;
|
||||
else
|
||||
high = rect.GetWidth()-1;
|
||||
|
||||
for (int i = 0; i <= high; ++i)
|
||||
{
|
||||
int r,g,b;
|
||||
|
||||
|
||||
r = start_color.Red() + (high <= 0 ? 0 : (((i*rd*100)/high)/100));
|
||||
g = start_color.Green() + (high <= 0 ? 0 : (((i*gd*100)/high)/100));
|
||||
b = start_color.Blue() + (high <= 0 ? 0 : (((i*bd*100)/high)/100));
|
||||
|
||||
wxPen p(wxColor((unsigned char)r,
|
||||
(unsigned char)g,
|
||||
(unsigned char)b));
|
||||
dc.SetPen(p);
|
||||
|
||||
if (direction == wxAUI_GRADIENT_VERTICAL)
|
||||
dc.DrawLine(rect.x, rect.y+i, rect.x+rect.width, rect.y+i);
|
||||
else
|
||||
dc.DrawLine(rect.x+i, rect.y, rect.x+i, rect.y+rect.height);
|
||||
}
|
||||
}
|
||||
|
||||
wxString wxAuiChopText(wxDC& dc, const wxString& text, int max_size)
|
||||
{
|
||||
wxCoord x,y;
|
||||
|
||||
// first check if the text fits with no problems
|
||||
dc.GetTextExtent(text, &x, &y);
|
||||
if (x <= max_size)
|
||||
return text;
|
||||
|
||||
size_t i, len = text.Length();
|
||||
size_t last_good_length = 0;
|
||||
for (i = 0; i < len; ++i)
|
||||
{
|
||||
wxString s = text.Left(i);
|
||||
s += wxT("...");
|
||||
|
||||
dc.GetTextExtent(s, &x, &y);
|
||||
if (x > max_size)
|
||||
break;
|
||||
|
||||
last_good_length = i;
|
||||
}
|
||||
|
||||
wxString ret = text.Left(last_good_length);
|
||||
ret += wxT("...");
|
||||
return ret;
|
||||
}
|
||||
|
||||
wxAuiDefaultDockArt::wxAuiDefaultDockArt()
|
||||
{
|
||||
#ifdef __WXMAC__
|
||||
wxBrush toolbarbrush;
|
||||
toolbarbrush.MacSetTheme( kThemeBrushToolbarBackground );
|
||||
wxColor base_colour = toolbarbrush.GetColour();
|
||||
#else
|
||||
wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
|
||||
#endif
|
||||
|
||||
// the base_colour is too pale to use as our base colour,
|
||||
// so darken it a bit --
|
||||
if ((255-base_colour.Red()) +
|
||||
(255-base_colour.Green()) +
|
||||
(255-base_colour.Blue()) < 60)
|
||||
{
|
||||
base_colour = wxAuiStepColour(base_colour, 92);
|
||||
}
|
||||
|
||||
m_base_colour = base_colour;
|
||||
wxColor darker1_colour = wxAuiStepColour(base_colour, 85);
|
||||
wxColor darker2_colour = wxAuiStepColour(base_colour, 75);
|
||||
wxColor darker3_colour = wxAuiStepColour(base_colour, 60);
|
||||
wxColor darker4_colour = wxAuiStepColour(base_colour, 50);
|
||||
wxColor darker5_colour = wxAuiStepColour(base_colour, 40);
|
||||
|
||||
m_active_caption_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
|
||||
m_active_caption_gradient_colour = wxAuiLightContrastColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
|
||||
m_active_caption_text_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
|
||||
m_inactive_caption_colour = darker1_colour;
|
||||
m_inactive_caption_gradient_colour = wxAuiStepColour(base_colour, 97);
|
||||
m_inactive_caption_text_colour = *wxBLACK;
|
||||
|
||||
#ifdef __WXMAC__
|
||||
m_sash_brush = toolbarbrush;
|
||||
m_background_brush = toolbarbrush;
|
||||
m_gripper_brush = toolbarbrush;
|
||||
#else
|
||||
m_sash_brush = wxBrush(base_colour);
|
||||
m_background_brush = wxBrush(base_colour);
|
||||
m_gripper_brush = wxBrush(base_colour);
|
||||
#endif
|
||||
m_border_pen = wxPen(darker2_colour);
|
||||
m_gripper_pen1 = wxPen(darker5_colour);
|
||||
m_gripper_pen2 = wxPen(darker3_colour);
|
||||
m_gripper_pen3 = *wxWHITE_PEN;
|
||||
|
||||
#ifdef __WXMAC__
|
||||
m_caption_font = *wxSMALL_FONT;
|
||||
#else
|
||||
m_caption_font = wxFont(8, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE);
|
||||
#endif
|
||||
|
||||
// some built in bitmaps
|
||||
#if defined( __WXMAC__ )
|
||||
static unsigned char close_bits[]={
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
|
||||
0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
|
||||
0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };
|
||||
#elif defined( __WXGTK__)
|
||||
static unsigned char close_bits[]={
|
||||
0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
|
||||
0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
|
||||
0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
|
||||
#else
|
||||
static unsigned char close_bits[]={
|
||||
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xf3, 0xcf, 0xf9,
|
||||
0x9f, 0xfc, 0x3f, 0xfe, 0x3f, 0xfe, 0x9f, 0xfc, 0xcf, 0xf9, 0xe7, 0xf3,
|
||||
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
|
||||
#endif
|
||||
|
||||
static unsigned char maximize_bits[] = {
|
||||
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xf7, 0xf7, 0x07, 0xf0,
|
||||
0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0x07, 0xf0,
|
||||
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
|
||||
|
||||
static unsigned char restore_bits[]={
|
||||
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xf0, 0x1f, 0xf0, 0xdf, 0xf7,
|
||||
0x07, 0xf4, 0x07, 0xf4, 0xf7, 0xf5, 0xf7, 0xf1, 0xf7, 0xfd, 0xf7, 0xfd,
|
||||
0x07, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
|
||||
|
||||
static unsigned char pin_bits[]={
|
||||
0xff,0xff,0xff,0xff,0xff,0xff,0x1f,0xfc,0xdf,0xfc,0xdf,0xfc,
|
||||
0xdf,0xfc,0xdf,0xfc,0xdf,0xfc,0x0f,0xf8,0x7f,0xff,0x7f,0xff,
|
||||
0x7f,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
|
||||
|
||||
#ifdef __WXMAC__
|
||||
m_inactive_close_bitmap = wxAuiBitmapFromBits(close_bits, 16, 16, *wxWHITE);
|
||||
m_active_close_bitmap = wxAuiBitmapFromBits(close_bits, 16, 16, *wxWHITE );
|
||||
#else
|
||||
m_inactive_close_bitmap = wxAuiBitmapFromBits(close_bits, 16, 16, m_inactive_caption_text_colour);
|
||||
m_active_close_bitmap = wxAuiBitmapFromBits(close_bits, 16, 16, m_active_caption_text_colour);
|
||||
#endif
|
||||
|
||||
#ifdef __WXMAC__
|
||||
m_inactive_maximize_bitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, *wxWHITE);
|
||||
m_active_maximize_bitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, *wxWHITE );
|
||||
#else
|
||||
m_inactive_maximize_bitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, m_inactive_caption_text_colour);
|
||||
m_active_maximize_bitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, m_active_caption_text_colour);
|
||||
#endif
|
||||
|
||||
#ifdef __WXMAC__
|
||||
m_inactive_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE);
|
||||
m_active_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE );
|
||||
#else
|
||||
m_inactive_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, m_inactive_caption_text_colour);
|
||||
m_active_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, m_active_caption_text_colour);
|
||||
#endif
|
||||
|
||||
m_inactive_pin_bitmap = wxAuiBitmapFromBits(pin_bits, 16, 16, m_inactive_caption_text_colour);
|
||||
m_active_pin_bitmap = wxAuiBitmapFromBits(pin_bits, 16, 16, m_active_caption_text_colour);
|
||||
|
||||
// default metric values
|
||||
#if defined(__WXMAC__)
|
||||
SInt32 height;
|
||||
GetThemeMetric( kThemeMetricSmallPaneSplitterHeight , &height );
|
||||
m_sash_size = height;
|
||||
#elif defined(__WXGTK__)
|
||||
m_sash_size = wxRendererNative::Get().GetSplitterParams(NULL).widthSash;
|
||||
#else
|
||||
m_sash_size = 4;
|
||||
#endif
|
||||
m_caption_size = 17;
|
||||
m_border_size = 1;
|
||||
m_button_size = 14;
|
||||
m_gripper_size = 9;
|
||||
m_gradient_type = wxAUI_GRADIENT_VERTICAL;
|
||||
}
|
||||
|
||||
int wxAuiDefaultDockArt::GetMetric(int id)
|
||||
{
|
||||
switch (id)
|
||||
{
|
||||
case wxAUI_DOCKART_SASH_SIZE: return m_sash_size;
|
||||
case wxAUI_DOCKART_CAPTION_SIZE: return m_caption_size;
|
||||
case wxAUI_DOCKART_GRIPPER_SIZE: return m_gripper_size;
|
||||
case wxAUI_DOCKART_PANE_BORDER_SIZE: return m_border_size;
|
||||
case wxAUI_DOCKART_PANE_BUTTON_SIZE: return m_button_size;
|
||||
case wxAUI_DOCKART_GRADIENT_TYPE: return m_gradient_type;
|
||||
default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void wxAuiDefaultDockArt::SetMetric(int id, int new_val)
|
||||
{
|
||||
switch (id)
|
||||
{
|
||||
case wxAUI_DOCKART_SASH_SIZE: m_sash_size = new_val; break;
|
||||
case wxAUI_DOCKART_CAPTION_SIZE: m_caption_size = new_val; break;
|
||||
case wxAUI_DOCKART_GRIPPER_SIZE: m_gripper_size = new_val; break;
|
||||
case wxAUI_DOCKART_PANE_BORDER_SIZE: m_border_size = new_val; break;
|
||||
case wxAUI_DOCKART_PANE_BUTTON_SIZE: m_button_size = new_val; break;
|
||||
case wxAUI_DOCKART_GRADIENT_TYPE: m_gradient_type = new_val; break;
|
||||
default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
|
||||
}
|
||||
}
|
||||
|
||||
wxColour wxAuiDefaultDockArt::GetColour(int id)
|
||||
{
|
||||
switch (id)
|
||||
{
|
||||
case wxAUI_DOCKART_BACKGROUND_COLOUR: return m_background_brush.GetColour();
|
||||
case wxAUI_DOCKART_SASH_COLOUR: return m_sash_brush.GetColour();
|
||||
case wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR: return m_inactive_caption_colour;
|
||||
case wxAUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR: return m_inactive_caption_gradient_colour;
|
||||
case wxAUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR: return m_inactive_caption_text_colour;
|
||||
case wxAUI_DOCKART_ACTIVE_CAPTION_COLOUR: return m_active_caption_colour;
|
||||
case wxAUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR: return m_active_caption_gradient_colour;
|
||||
case wxAUI_DOCKART_ACTIVE_CAPTION_TEXT_COLOUR: return m_active_caption_text_colour;
|
||||
case wxAUI_DOCKART_BORDER_COLOUR: return m_border_pen.GetColour();
|
||||
case wxAUI_DOCKART_GRIPPER_COLOUR: return m_gripper_brush.GetColour();
|
||||
default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
|
||||
}
|
||||
|
||||
return wxColour();
|
||||
}
|
||||
|
||||
void wxAuiDefaultDockArt::SetColour(int id, const wxColor& colour)
|
||||
{
|
||||
switch (id)
|
||||
{
|
||||
case wxAUI_DOCKART_BACKGROUND_COLOUR: m_background_brush.SetColour(colour); break;
|
||||
case wxAUI_DOCKART_SASH_COLOUR: m_sash_brush.SetColour(colour); break;
|
||||
case wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR: m_inactive_caption_colour = colour; break;
|
||||
case wxAUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR: m_inactive_caption_gradient_colour = colour; break;
|
||||
case wxAUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR: m_inactive_caption_text_colour = colour; break;
|
||||
case wxAUI_DOCKART_ACTIVE_CAPTION_COLOUR: m_active_caption_colour = colour; break;
|
||||
case wxAUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR: m_active_caption_gradient_colour = colour; break;
|
||||
case wxAUI_DOCKART_ACTIVE_CAPTION_TEXT_COLOUR: m_active_caption_text_colour = colour; break;
|
||||
case wxAUI_DOCKART_BORDER_COLOUR: m_border_pen.SetColour(colour); break;
|
||||
case wxAUI_DOCKART_GRIPPER_COLOUR:
|
||||
m_gripper_brush.SetColour(colour);
|
||||
m_gripper_pen1.SetColour(wxAuiStepColour(colour, 40));
|
||||
m_gripper_pen2.SetColour(wxAuiStepColour(colour, 60));
|
||||
break;
|
||||
default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
|
||||
}
|
||||
}
|
||||
|
||||
void wxAuiDefaultDockArt::SetFont(int id, const wxFont& font)
|
||||
{
|
||||
if (id == wxAUI_DOCKART_CAPTION_FONT)
|
||||
m_caption_font = font;
|
||||
}
|
||||
|
||||
wxFont wxAuiDefaultDockArt::GetFont(int id)
|
||||
{
|
||||
if (id == wxAUI_DOCKART_CAPTION_FONT)
|
||||
return m_caption_font;
|
||||
return wxNullFont;
|
||||
}
|
||||
|
||||
void wxAuiDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation, const wxRect& rect)
|
||||
{
|
||||
#if defined(__WXMAC__)
|
||||
HIRect splitterRect = CGRectMake( rect.x , rect.y , rect.width , rect.height );
|
||||
CGContextRef cgContext ;
|
||||
#if wxMAC_USE_CORE_GRAPHICS
|
||||
cgContext = (CGContextRef) dc.GetGraphicsContext()->GetNativeContext() ;
|
||||
#else
|
||||
Rect bounds ;
|
||||
GetPortBounds( (CGrafPtr) dc.m_macPort , &bounds ) ;
|
||||
QDBeginCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ;
|
||||
CGContextTranslateCTM( cgContext , 0 , bounds.bottom - bounds.top ) ;
|
||||
CGContextScaleCTM( cgContext , 1 , -1 ) ;
|
||||
|
||||
if ( window )
|
||||
{
|
||||
wxPoint origin = window->GetClientAreaOrigin();
|
||||
int x, y;
|
||||
x = origin.x;
|
||||
y = origin.y;
|
||||
window->MacWindowToRootWindow( &x , &y );
|
||||
CGContextTranslateCTM( cgContext, x, y);
|
||||
}
|
||||
#endif
|
||||
|
||||
HIThemeSplitterDrawInfo drawInfo ;
|
||||
drawInfo.version = 0 ;
|
||||
drawInfo.state = kThemeStateActive ;
|
||||
drawInfo.adornment = kHIThemeSplitterAdornmentNone ;
|
||||
HIThemeDrawPaneSplitter( &splitterRect , &drawInfo , cgContext , kHIThemeOrientationNormal ) ;
|
||||
|
||||
#if wxMAC_USE_CORE_GRAPHICS
|
||||
#else
|
||||
QDEndCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ;
|
||||
#endif
|
||||
|
||||
#elif defined(__WXGTK__)
|
||||
// clear out the rectangle first
|
||||
dc.SetPen(*wxTRANSPARENT_PEN);
|
||||
dc.SetBrush(m_sash_brush);
|
||||
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
|
||||
|
||||
GdkRectangle gdk_rect;
|
||||
if (orientation == wxVERTICAL )
|
||||
{
|
||||
gdk_rect.x = rect.x;
|
||||
gdk_rect.y = rect.y;
|
||||
gdk_rect.width = m_sash_size;
|
||||
gdk_rect.height = rect.height;
|
||||
}
|
||||
else
|
||||
{
|
||||
gdk_rect.x = rect.x;
|
||||
gdk_rect.y = rect.y;
|
||||
gdk_rect.width = rect.width;
|
||||
gdk_rect.height = m_sash_size;
|
||||
}
|
||||
|
||||
if (!window) return;
|
||||
if (!window->m_wxwindow) return;
|
||||
if (!GTK_PIZZA(window->m_wxwindow)->bin_window) return;
|
||||
|
||||
gtk_paint_handle
|
||||
(
|
||||
window->m_wxwindow->style,
|
||||
GTK_PIZZA(window->m_wxwindow)->bin_window,
|
||||
// flags & wxCONTROL_CURRENT ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
|
||||
GTK_STATE_NORMAL,
|
||||
GTK_SHADOW_NONE,
|
||||
NULL /* no clipping */,
|
||||
window->m_wxwindow,
|
||||
"paned",
|
||||
rect.x,
|
||||
rect.y,
|
||||
rect.width,
|
||||
rect.height,
|
||||
(orientation == wxVERTICAL) ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL
|
||||
);
|
||||
|
||||
#else
|
||||
wxUnusedVar(window);
|
||||
wxUnusedVar(orientation);
|
||||
dc.SetPen(*wxTRANSPARENT_PEN);
|
||||
dc.SetBrush(m_sash_brush);
|
||||
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void wxAuiDefaultDockArt::DrawBackground(wxDC& dc, wxWindow *WXUNUSED(window), int, const wxRect& rect)
|
||||
{
|
||||
dc.SetPen(*wxTRANSPARENT_PEN);
|
||||
#ifdef __WXMAC__
|
||||
// we have to clear first, otherwise we are drawing a light striped pattern
|
||||
// over an already darker striped background
|
||||
dc.SetBrush(*wxWHITE_BRUSH) ;
|
||||
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
|
||||
#endif
|
||||
dc.SetBrush(m_background_brush);
|
||||
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
|
||||
}
|
||||
|
||||
void wxAuiDefaultDockArt::DrawBorder(wxDC& dc, wxWindow *WXUNUSED(window), const wxRect& _rect,
|
||||
wxAuiPaneInfo& pane)
|
||||
{
|
||||
dc.SetPen(m_border_pen);
|
||||
dc.SetBrush(*wxTRANSPARENT_BRUSH);
|
||||
|
||||
wxRect rect = _rect;
|
||||
int i, border_width = GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
|
||||
|
||||
if (pane.IsToolbar())
|
||||
{
|
||||
for (i = 0; i < border_width; ++i)
|
||||
{
|
||||
dc.SetPen(*wxWHITE_PEN);
|
||||
dc.DrawLine(rect.x, rect.y, rect.x+rect.width, rect.y);
|
||||
dc.DrawLine(rect.x, rect.y, rect.x, rect.y+rect.height);
|
||||
dc.SetPen(m_border_pen);
|
||||
dc.DrawLine(rect.x, rect.y+rect.height-1,
|
||||
rect.x+rect.width, rect.y+rect.height-1);
|
||||
dc.DrawLine(rect.x+rect.width-1, rect.y,
|
||||
rect.x+rect.width-1, rect.y+rect.height);
|
||||
rect.Deflate(1);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i = 0; i < border_width; ++i)
|
||||
{
|
||||
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
|
||||
rect.Deflate(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void wxAuiDefaultDockArt::DrawCaptionBackground(wxDC& dc, const wxRect& rect, bool active)
|
||||
{
|
||||
if (m_gradient_type == wxAUI_GRADIENT_NONE)
|
||||
{
|
||||
if (active)
|
||||
dc.SetBrush(wxBrush(m_active_caption_colour));
|
||||
else
|
||||
dc.SetBrush(wxBrush(m_inactive_caption_colour));
|
||||
|
||||
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (active)
|
||||
{
|
||||
// on mac the gradients are expected to become darker from the top
|
||||
#ifdef __WXMAC__
|
||||
DrawGradientRectangle(dc, rect,
|
||||
m_active_caption_colour,
|
||||
m_active_caption_gradient_colour,
|
||||
m_gradient_type);
|
||||
#else
|
||||
// on other platforms, active gradients become lighter at the top
|
||||
DrawGradientRectangle(dc, rect,
|
||||
m_active_caption_gradient_colour,
|
||||
m_active_caption_colour,
|
||||
m_gradient_type);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef __WXMAC__
|
||||
// on mac the gradients are expected to become darker from the top
|
||||
DrawGradientRectangle(dc, rect,
|
||||
m_inactive_caption_gradient_colour,
|
||||
m_inactive_caption_colour,
|
||||
m_gradient_type);
|
||||
#else
|
||||
// on other platforms, inactive gradients become lighter at the bottom
|
||||
DrawGradientRectangle(dc, rect,
|
||||
m_inactive_caption_colour,
|
||||
m_inactive_caption_gradient_colour,
|
||||
m_gradient_type);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void wxAuiDefaultDockArt::DrawCaption(wxDC& dc, wxWindow *WXUNUSED(window),
|
||||
const wxString& text,
|
||||
const wxRect& rect,
|
||||
wxAuiPaneInfo& pane)
|
||||
{
|
||||
dc.SetPen(*wxTRANSPARENT_PEN);
|
||||
dc.SetFont(m_caption_font);
|
||||
|
||||
DrawCaptionBackground(dc, rect,
|
||||
(pane.state & wxAuiPaneInfo::optionActive)?true:false);
|
||||
|
||||
if (pane.state & wxAuiPaneInfo::optionActive)
|
||||
dc.SetTextForeground(m_active_caption_text_colour);
|
||||
else
|
||||
dc.SetTextForeground(m_inactive_caption_text_colour);
|
||||
|
||||
|
||||
wxCoord w,h;
|
||||
dc.GetTextExtent(wxT("ABCDEFHXfgkj"), &w, &h);
|
||||
|
||||
wxRect clip_rect = rect;
|
||||
clip_rect.width -= 3; // text offset
|
||||
clip_rect.width -= 2; // button padding
|
||||
if (pane.HasCloseButton())
|
||||
clip_rect.width -= m_button_size;
|
||||
if (pane.HasPinButton())
|
||||
clip_rect.width -= m_button_size;
|
||||
if (pane.HasMaximizeButton())
|
||||
clip_rect.width -= m_button_size;
|
||||
|
||||
wxString draw_text = wxAuiChopText(dc, text, clip_rect.width);
|
||||
|
||||
dc.SetClippingRegion(clip_rect);
|
||||
dc.DrawText(draw_text, rect.x+3, rect.y+(rect.height/2)-(h/2)-1);
|
||||
dc.DestroyClippingRegion();
|
||||
}
|
||||
|
||||
void wxAuiDefaultDockArt::DrawGripper(wxDC& dc, wxWindow *WXUNUSED(window),
|
||||
const wxRect& rect,
|
||||
wxAuiPaneInfo& pane)
|
||||
{
|
||||
dc.SetPen(*wxTRANSPARENT_PEN);
|
||||
dc.SetBrush(m_gripper_brush);
|
||||
|
||||
dc.DrawRectangle(rect.x, rect.y, rect.width,rect.height);
|
||||
|
||||
if (!pane.HasGripperTop())
|
||||
{
|
||||
int y = 5;
|
||||
while (1)
|
||||
{
|
||||
dc.SetPen(m_gripper_pen1);
|
||||
dc.DrawPoint(rect.x+3, rect.y+y);
|
||||
dc.SetPen(m_gripper_pen2);
|
||||
dc.DrawPoint(rect.x+3, rect.y+y+1);
|
||||
dc.DrawPoint(rect.x+4, rect.y+y);
|
||||
dc.SetPen(m_gripper_pen3);
|
||||
dc.DrawPoint(rect.x+5, rect.y+y+1);
|
||||
dc.DrawPoint(rect.x+5, rect.y+y+2);
|
||||
dc.DrawPoint(rect.x+4, rect.y+y+2);
|
||||
|
||||
y += 4;
|
||||
if (y > rect.GetHeight()-5)
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int x = 5;
|
||||
while (1)
|
||||
{
|
||||
dc.SetPen(m_gripper_pen1);
|
||||
dc.DrawPoint(rect.x+x, rect.y+3);
|
||||
dc.SetPen(m_gripper_pen2);
|
||||
dc.DrawPoint(rect.x+x+1, rect.y+3);
|
||||
dc.DrawPoint(rect.x+x, rect.y+4);
|
||||
dc.SetPen(m_gripper_pen3);
|
||||
dc.DrawPoint(rect.x+x+1, rect.y+5);
|
||||
dc.DrawPoint(rect.x+x+2, rect.y+5);
|
||||
dc.DrawPoint(rect.x+x+2, rect.y+4);
|
||||
|
||||
x += 4;
|
||||
if (x > rect.GetWidth()-5)
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void wxAuiDefaultDockArt::DrawPaneButton(wxDC& dc, wxWindow *WXUNUSED(window),
|
||||
int button,
|
||||
int button_state,
|
||||
const wxRect& _rect,
|
||||
wxAuiPaneInfo& pane)
|
||||
{
|
||||
wxBitmap bmp;
|
||||
if (!(&pane))
|
||||
return;
|
||||
switch (button)
|
||||
{
|
||||
default:
|
||||
case wxAUI_BUTTON_CLOSE:
|
||||
if (pane.state & wxAuiPaneInfo::optionActive)
|
||||
bmp = m_active_close_bitmap;
|
||||
else
|
||||
bmp = m_inactive_close_bitmap;
|
||||
break;
|
||||
case wxAUI_BUTTON_PIN:
|
||||
if (pane.state & wxAuiPaneInfo::optionActive)
|
||||
bmp = m_active_pin_bitmap;
|
||||
else
|
||||
bmp = m_inactive_pin_bitmap;
|
||||
break;
|
||||
case wxAUI_BUTTON_MAXIMIZE_RESTORE:
|
||||
if (pane.IsMaximized())
|
||||
{
|
||||
if (pane.state & wxAuiPaneInfo::optionActive)
|
||||
bmp = m_active_restore_bitmap;
|
||||
else
|
||||
bmp = m_inactive_restore_bitmap;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (pane.state & wxAuiPaneInfo::optionActive)
|
||||
bmp = m_active_maximize_bitmap;
|
||||
else
|
||||
bmp = m_inactive_maximize_bitmap;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
wxRect rect = _rect;
|
||||
|
||||
int old_y = rect.y;
|
||||
rect.y = rect.y + (rect.height/2) - (bmp.GetHeight()/2);
|
||||
rect.height = old_y + rect.height - rect.y - 1;
|
||||
|
||||
|
||||
if (button_state == wxAUI_BUTTON_STATE_PRESSED)
|
||||
{
|
||||
rect.x++;
|
||||
rect.y++;
|
||||
}
|
||||
|
||||
if (button_state == wxAUI_BUTTON_STATE_HOVER ||
|
||||
button_state == wxAUI_BUTTON_STATE_PRESSED)
|
||||
{
|
||||
if (pane.state & wxAuiPaneInfo::optionActive)
|
||||
{
|
||||
dc.SetBrush(wxBrush(wxAuiStepColour(m_active_caption_colour, 120)));
|
||||
dc.SetPen(wxPen(wxAuiStepColour(m_active_caption_colour, 70)));
|
||||
}
|
||||
else
|
||||
{
|
||||
dc.SetBrush(wxBrush(wxAuiStepColour(m_inactive_caption_colour, 120)));
|
||||
dc.SetPen(wxPen(wxAuiStepColour(m_inactive_caption_colour, 70)));
|
||||
}
|
||||
|
||||
// draw the background behind the button
|
||||
dc.DrawRectangle(rect.x, rect.y, 15, 15);
|
||||
}
|
||||
|
||||
|
||||
// draw the button itself
|
||||
dc.DrawBitmap(bmp, rect.x, rect.y, true);
|
||||
}
|
||||
|
||||
|
||||
#endif // wxUSE_AUI
|
||||
|
|
@ -0,0 +1,323 @@
|
|||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: src/aui/floatpane.cpp
|
||||
// Purpose: wxaui: wx advanced user interface - docking window manager
|
||||
// Author: Benjamin I. Williams
|
||||
// Modified by:
|
||||
// Created: 2005-05-17
|
||||
// RCS-ID: $Id: floatpane.cpp 54904 2008-08-01 16:07:46Z BIW $
|
||||
// Copyright: (C) Copyright 2005-2006, Kirix Corporation, All Rights Reserved
|
||||
// Licence: wxWindows Library Licence, Version 3.1
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// ============================================================================
|
||||
// declarations
|
||||
// ============================================================================
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#include "wx/wxprec.h"
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma hdrstop
|
||||
#endif
|
||||
|
||||
#if wxUSE_AUI
|
||||
|
||||
#include "wx/aui/framemanager.h"
|
||||
#include "wx/aui/floatpane.h"
|
||||
#include "wx/aui/dockart.h"
|
||||
|
||||
#ifndef WX_PRECOMP
|
||||
#endif
|
||||
|
||||
#ifdef __WXMSW__
|
||||
#include "wx/msw/private.h"
|
||||
#endif
|
||||
|
||||
IMPLEMENT_CLASS(wxAuiFloatingFrame, wxAuiFloatingFrameBaseClass)
|
||||
|
||||
wxAuiFloatingFrame::wxAuiFloatingFrame(wxWindow* parent,
|
||||
wxAuiManager* owner_mgr,
|
||||
const wxAuiPaneInfo& pane,
|
||||
wxWindowID id /*= wxID_ANY*/,
|
||||
long style /*=wxRESIZE_BORDER | wxSYSTEM_MENU | wxCAPTION |
|
||||
wxFRAME_NO_TASKBAR | wxFRAME_FLOAT_ON_PARENT |
|
||||
wxCLIP_CHILDREN
|
||||
*/)
|
||||
: wxAuiFloatingFrameBaseClass(parent, id, wxEmptyString,
|
||||
pane.floating_pos, pane.floating_size,
|
||||
style |
|
||||
(pane.HasCloseButton()?wxCLOSE_BOX:0) |
|
||||
(pane.HasMaximizeButton()?wxMAXIMIZE_BOX:0) |
|
||||
(pane.IsFixed()?0:wxRESIZE_BORDER)
|
||||
)
|
||||
{
|
||||
m_owner_mgr = owner_mgr;
|
||||
m_moving = false;
|
||||
m_mgr.SetManagedWindow(this);
|
||||
m_solid_drag = true;
|
||||
|
||||
// find out if the system supports solid window drag.
|
||||
// on non-msw systems, this is assumed to be the case
|
||||
#ifdef __WXMSW__
|
||||
BOOL b = TRUE;
|
||||
SystemParametersInfo(38 /*SPI_GETDRAGFULLWINDOWS*/, 0, &b, 0);
|
||||
m_solid_drag = b ? true : false;
|
||||
#endif
|
||||
|
||||
SetExtraStyle(wxWS_EX_PROCESS_IDLE);
|
||||
}
|
||||
|
||||
wxAuiFloatingFrame::~wxAuiFloatingFrame()
|
||||
{
|
||||
// if we do not do this, then we can crash...
|
||||
if(m_owner_mgr && m_owner_mgr->m_action_window == this)
|
||||
{
|
||||
m_owner_mgr->m_action_window = NULL;
|
||||
}
|
||||
m_mgr.UnInit();
|
||||
}
|
||||
|
||||
void wxAuiFloatingFrame::SetPaneWindow(const wxAuiPaneInfo& pane)
|
||||
{
|
||||
m_pane_window = pane.window;
|
||||
m_pane_window->Reparent(this);
|
||||
|
||||
wxAuiPaneInfo contained_pane = pane;
|
||||
contained_pane.Dock().Center().Show().
|
||||
CaptionVisible(false).
|
||||
PaneBorder(false).
|
||||
Layer(0).Row(0).Position(0);
|
||||
|
||||
// Carry over the minimum size
|
||||
wxSize pane_min_size = pane.window->GetMinSize();
|
||||
|
||||
// if the frame window's max size is greater than the min size
|
||||
// then set the max size to the min size as well
|
||||
wxSize cur_max_size = GetMaxSize();
|
||||
if (cur_max_size.IsFullySpecified() &&
|
||||
(cur_max_size.x < pane.min_size.x ||
|
||||
cur_max_size.y < pane.min_size.y)
|
||||
)
|
||||
{
|
||||
SetMaxSize(pane_min_size);
|
||||
}
|
||||
|
||||
SetMinSize(pane.window->GetMinSize());
|
||||
|
||||
m_mgr.AddPane(m_pane_window, contained_pane);
|
||||
m_mgr.Update();
|
||||
|
||||
if (pane.min_size.IsFullySpecified())
|
||||
{
|
||||
// because SetSizeHints() calls Fit() too (which sets the window
|
||||
// size to its minimum allowed), we keep the size before calling
|
||||
// SetSizeHints() and reset it afterwards...
|
||||
wxSize tmp = GetSize();
|
||||
GetSizer()->SetSizeHints(this);
|
||||
SetSize(tmp);
|
||||
}
|
||||
|
||||
SetTitle(pane.caption);
|
||||
|
||||
if (pane.floating_size != wxDefaultSize)
|
||||
{
|
||||
SetSize(pane.floating_size);
|
||||
}
|
||||
else
|
||||
{
|
||||
wxSize size = pane.best_size;
|
||||
if (size == wxDefaultSize)
|
||||
size = pane.min_size;
|
||||
if (size == wxDefaultSize)
|
||||
size = m_pane_window->GetSize();
|
||||
if (pane.HasGripper())
|
||||
{
|
||||
if (pane.HasGripperTop())
|
||||
size.y += m_owner_mgr->m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);
|
||||
else
|
||||
size.x += m_owner_mgr->m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);
|
||||
}
|
||||
|
||||
SetClientSize(size);
|
||||
}
|
||||
|
||||
if (pane.IsFixed())
|
||||
{
|
||||
SetWindowStyleFlag(GetWindowStyleFlag() & ~wxRESIZE_BORDER);
|
||||
}
|
||||
}
|
||||
|
||||
wxAuiManager* wxAuiFloatingFrame::GetOwnerManager() const
|
||||
{
|
||||
return m_owner_mgr;
|
||||
}
|
||||
|
||||
|
||||
void wxAuiFloatingFrame::OnSize(wxSizeEvent& event)
|
||||
{
|
||||
m_owner_mgr->OnFloatingPaneResized(m_pane_window, event.GetSize());
|
||||
}
|
||||
|
||||
void wxAuiFloatingFrame::OnClose(wxCloseEvent& evt)
|
||||
{
|
||||
m_owner_mgr->OnFloatingPaneClosed(m_pane_window, evt);
|
||||
if (!evt.GetVeto()) {
|
||||
m_mgr.DetachPane(m_pane_window);
|
||||
Destroy();
|
||||
}
|
||||
}
|
||||
|
||||
void wxAuiFloatingFrame::OnMoveEvent(wxMoveEvent& event)
|
||||
{
|
||||
if (!m_solid_drag)
|
||||
{
|
||||
// systems without solid window dragging need to be
|
||||
// handled slightly differently, due to the lack of
|
||||
// the constant stream of EVT_MOVING events
|
||||
if (!isMouseDown())
|
||||
return;
|
||||
OnMoveStart();
|
||||
OnMoving(event.GetRect(), wxNORTH);
|
||||
m_moving = true;
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
wxRect win_rect = GetRect();
|
||||
|
||||
if (win_rect == m_last_rect)
|
||||
return;
|
||||
|
||||
// skip the first move event
|
||||
if (m_last_rect.IsEmpty())
|
||||
{
|
||||
m_last_rect = win_rect;
|
||||
return;
|
||||
}
|
||||
|
||||
// skip if moving too fast to avoid massive redraws and
|
||||
// jumping hint windows
|
||||
if ((abs(win_rect.x - m_last_rect.x) > 3) ||
|
||||
(abs(win_rect.y - m_last_rect.y) > 3))
|
||||
{
|
||||
m_last3_rect = m_last2_rect;
|
||||
m_last2_rect = m_last_rect;
|
||||
m_last_rect = win_rect;
|
||||
return;
|
||||
}
|
||||
|
||||
// prevent frame redocking during resize
|
||||
if (m_last_rect.GetSize() != win_rect.GetSize())
|
||||
{
|
||||
m_last3_rect = m_last2_rect;
|
||||
m_last2_rect = m_last_rect;
|
||||
m_last_rect = win_rect;
|
||||
return;
|
||||
}
|
||||
|
||||
wxDirection dir = wxALL;
|
||||
|
||||
int horiz_dist = abs(win_rect.x - m_last3_rect.x);
|
||||
int vert_dist = abs(win_rect.y - m_last3_rect.y);
|
||||
|
||||
if (vert_dist >= horiz_dist)
|
||||
{
|
||||
if (win_rect.y < m_last3_rect.y)
|
||||
dir = wxNORTH;
|
||||
else
|
||||
dir = wxSOUTH;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (win_rect.x < m_last3_rect.x)
|
||||
dir = wxWEST;
|
||||
else
|
||||
dir = wxEAST;
|
||||
}
|
||||
|
||||
m_last3_rect = m_last2_rect;
|
||||
m_last2_rect = m_last_rect;
|
||||
m_last_rect = win_rect;
|
||||
|
||||
if (!isMouseDown())
|
||||
return;
|
||||
|
||||
if (!m_moving)
|
||||
{
|
||||
OnMoveStart();
|
||||
m_moving = true;
|
||||
}
|
||||
|
||||
if (m_last3_rect.IsEmpty())
|
||||
return;
|
||||
|
||||
OnMoving(event.GetRect(), dir);
|
||||
}
|
||||
|
||||
void wxAuiFloatingFrame::OnIdle(wxIdleEvent& event)
|
||||
{
|
||||
if (m_moving)
|
||||
{
|
||||
if (!isMouseDown())
|
||||
{
|
||||
m_moving = false;
|
||||
OnMoveFinished();
|
||||
}
|
||||
else
|
||||
{
|
||||
event.RequestMore();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void wxAuiFloatingFrame::OnMoveStart()
|
||||
{
|
||||
// notify the owner manager that the pane has started to move
|
||||
m_owner_mgr->OnFloatingPaneMoveStart(m_pane_window);
|
||||
}
|
||||
|
||||
void wxAuiFloatingFrame::OnMoving(const wxRect& WXUNUSED(window_rect), wxDirection dir)
|
||||
{
|
||||
// notify the owner manager that the pane is moving
|
||||
m_owner_mgr->OnFloatingPaneMoving(m_pane_window, dir);
|
||||
m_lastDirection = dir;
|
||||
}
|
||||
|
||||
void wxAuiFloatingFrame::OnMoveFinished()
|
||||
{
|
||||
// notify the owner manager that the pane has finished moving
|
||||
m_owner_mgr->OnFloatingPaneMoved(m_pane_window, m_lastDirection);
|
||||
}
|
||||
|
||||
void wxAuiFloatingFrame::OnActivate(wxActivateEvent& event)
|
||||
{
|
||||
if (event.GetActive())
|
||||
{
|
||||
m_owner_mgr->OnFloatingPaneActivated(m_pane_window);
|
||||
}
|
||||
}
|
||||
|
||||
// utility function which determines the state of the mouse button
|
||||
// (independant of having a wxMouseEvent handy) - utimately a better
|
||||
// mechanism for this should be found (possibly by adding the
|
||||
// functionality to wxWidgets itself)
|
||||
bool wxAuiFloatingFrame::isMouseDown()
|
||||
{
|
||||
return wxGetMouseState().LeftDown();
|
||||
}
|
||||
|
||||
|
||||
BEGIN_EVENT_TABLE(wxAuiFloatingFrame, wxAuiFloatingFrameBaseClass)
|
||||
EVT_SIZE(wxAuiFloatingFrame::OnSize)
|
||||
EVT_MOVE(wxAuiFloatingFrame::OnMoveEvent)
|
||||
EVT_MOVING(wxAuiFloatingFrame::OnMoveEvent)
|
||||
EVT_CLOSE(wxAuiFloatingFrame::OnClose)
|
||||
EVT_IDLE(wxAuiFloatingFrame::OnIdle)
|
||||
EVT_ACTIVATE(wxAuiFloatingFrame::OnActivate)
|
||||
END_EVENT_TABLE()
|
||||
|
||||
|
||||
#endif // wxUSE_AUI
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,837 @@
|
|||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: src/aui/tabmdi.cpp
|
||||
// Purpose: Generic MDI (Multiple Document Interface) classes
|
||||
// Author: Hans Van Leemputten
|
||||
// Modified by: Benjamin I. Williams / Kirix Corporation
|
||||
// Created: 29/07/2002
|
||||
// RCS-ID: $Id: tabmdi.cpp 55206 2008-08-23 16:19:16Z VZ $
|
||||
// Copyright: (c) Hans Van Leemputten
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// ===========================================================================
|
||||
// declarations
|
||||
// ===========================================================================
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// headers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// For compilers that support precompilation, includes "wx.h".
|
||||
#include "wx/wxprec.h"
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma hdrstop
|
||||
#endif
|
||||
|
||||
#if wxUSE_AUI
|
||||
#if wxUSE_MDI
|
||||
|
||||
#include "wx/aui/tabmdi.h"
|
||||
|
||||
#ifndef WX_PRECOMP
|
||||
#include "wx/panel.h"
|
||||
#include "wx/menu.h"
|
||||
#include "wx/intl.h"
|
||||
#include "wx/log.h"
|
||||
#include "wx/settings.h"
|
||||
#endif //WX_PRECOMP
|
||||
|
||||
#include "wx/stockitem.h"
|
||||
|
||||
enum MDI_MENU_ID
|
||||
{
|
||||
wxWINDOWCLOSE = 4001,
|
||||
wxWINDOWCLOSEALL,
|
||||
wxWINDOWNEXT,
|
||||
wxWINDOWPREV
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// wxAuiMDIParentFrame
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
IMPLEMENT_DYNAMIC_CLASS(wxAuiMDIParentFrame, wxFrame)
|
||||
|
||||
BEGIN_EVENT_TABLE(wxAuiMDIParentFrame, wxFrame)
|
||||
#if wxUSE_MENUS
|
||||
EVT_MENU (wxID_ANY, wxAuiMDIParentFrame::DoHandleMenu)
|
||||
#endif
|
||||
END_EVENT_TABLE()
|
||||
|
||||
wxAuiMDIParentFrame::wxAuiMDIParentFrame()
|
||||
{
|
||||
Init();
|
||||
}
|
||||
|
||||
wxAuiMDIParentFrame::wxAuiMDIParentFrame(wxWindow *parent,
|
||||
wxWindowID id,
|
||||
const wxString& title,
|
||||
const wxPoint& pos,
|
||||
const wxSize& size,
|
||||
long style,
|
||||
const wxString& name)
|
||||
{
|
||||
Init();
|
||||
(void)Create(parent, id, title, pos, size, style, name);
|
||||
}
|
||||
|
||||
wxAuiMDIParentFrame::~wxAuiMDIParentFrame()
|
||||
{
|
||||
// Make sure the client window is destructed before the menu bars are!
|
||||
wxDELETE(m_pClientWindow);
|
||||
|
||||
#if wxUSE_MENUS
|
||||
wxDELETE(m_pMyMenuBar);
|
||||
RemoveWindowMenu(GetMenuBar());
|
||||
wxDELETE(m_pWindowMenu);
|
||||
#endif // wxUSE_MENUS
|
||||
}
|
||||
|
||||
bool wxAuiMDIParentFrame::Create(wxWindow *parent,
|
||||
wxWindowID id,
|
||||
const wxString& title,
|
||||
const wxPoint& pos,
|
||||
const wxSize& size,
|
||||
long style,
|
||||
const wxString& name)
|
||||
{
|
||||
#if wxUSE_MENUS
|
||||
// this style can be used to prevent a window from having the standard MDI
|
||||
// "Window" menu
|
||||
if (!(style & wxFRAME_NO_WINDOW_MENU))
|
||||
{
|
||||
m_pWindowMenu = new wxMenu;
|
||||
m_pWindowMenu->Append(wxWINDOWCLOSE, _("Cl&ose"));
|
||||
m_pWindowMenu->Append(wxWINDOWCLOSEALL, _("Close All"));
|
||||
m_pWindowMenu->AppendSeparator();
|
||||
m_pWindowMenu->Append(wxWINDOWNEXT, _("&Next"));
|
||||
m_pWindowMenu->Append(wxWINDOWPREV, _("&Previous"));
|
||||
}
|
||||
#endif // wxUSE_MENUS
|
||||
|
||||
wxFrame::Create(parent, id, title, pos, size, style, name);
|
||||
OnCreateClient();
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void wxAuiMDIParentFrame::SetArtProvider(wxAuiTabArt* provider)
|
||||
{
|
||||
if (m_pClientWindow)
|
||||
{
|
||||
m_pClientWindow->SetArtProvider(provider);
|
||||
}
|
||||
}
|
||||
|
||||
wxAuiTabArt* wxAuiMDIParentFrame::GetArtProvider()
|
||||
{
|
||||
if (!m_pClientWindow)
|
||||
return NULL;
|
||||
|
||||
return m_pClientWindow->GetArtProvider();
|
||||
}
|
||||
|
||||
wxAuiNotebook* wxAuiMDIParentFrame::GetNotebook() const
|
||||
{
|
||||
return wx_static_cast(wxAuiNotebook*, m_pClientWindow);
|
||||
}
|
||||
|
||||
|
||||
|
||||
#if wxUSE_MENUS
|
||||
void wxAuiMDIParentFrame::SetWindowMenu(wxMenu* pMenu)
|
||||
{
|
||||
// Replace the window menu from the currently loaded menu bar.
|
||||
wxMenuBar *pMenuBar = GetMenuBar();
|
||||
|
||||
if (m_pWindowMenu)
|
||||
{
|
||||
RemoveWindowMenu(pMenuBar);
|
||||
wxDELETE(m_pWindowMenu);
|
||||
}
|
||||
|
||||
if (pMenu)
|
||||
{
|
||||
m_pWindowMenu = pMenu;
|
||||
AddWindowMenu(pMenuBar);
|
||||
}
|
||||
}
|
||||
|
||||
void wxAuiMDIParentFrame::SetMenuBar(wxMenuBar* pMenuBar)
|
||||
{
|
||||
// Remove the Window menu from the old menu bar
|
||||
RemoveWindowMenu(GetMenuBar());
|
||||
|
||||
// Add the Window menu to the new menu bar.
|
||||
AddWindowMenu(pMenuBar);
|
||||
|
||||
wxFrame::SetMenuBar(pMenuBar);
|
||||
//m_pMyMenuBar = GetMenuBar();
|
||||
}
|
||||
#endif // wxUSE_MENUS
|
||||
|
||||
void wxAuiMDIParentFrame::SetChildMenuBar(wxAuiMDIChildFrame* pChild)
|
||||
{
|
||||
#if wxUSE_MENUS
|
||||
if (!pChild)
|
||||
{
|
||||
// No Child, set Our menu bar back.
|
||||
if (m_pMyMenuBar)
|
||||
SetMenuBar(m_pMyMenuBar);
|
||||
else
|
||||
SetMenuBar(GetMenuBar());
|
||||
|
||||
// Make sure we know our menu bar is in use
|
||||
m_pMyMenuBar = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (pChild->GetMenuBar() == NULL)
|
||||
return;
|
||||
|
||||
// Do we need to save the current bar?
|
||||
if (m_pMyMenuBar == NULL)
|
||||
m_pMyMenuBar = GetMenuBar();
|
||||
|
||||
SetMenuBar(pChild->GetMenuBar());
|
||||
}
|
||||
#endif // wxUSE_MENUS
|
||||
}
|
||||
|
||||
bool wxAuiMDIParentFrame::ProcessEvent(wxEvent& event)
|
||||
{
|
||||
// stops the same event being processed repeatedly
|
||||
if (m_pLastEvt == &event)
|
||||
return false;
|
||||
m_pLastEvt = &event;
|
||||
|
||||
// let the active child (if any) process the event first.
|
||||
bool res = false;
|
||||
if (m_pActiveChild &&
|
||||
event.IsCommandEvent() &&
|
||||
event.GetEventObject() != m_pClientWindow &&
|
||||
!(event.GetEventType() == wxEVT_ACTIVATE ||
|
||||
event.GetEventType() == wxEVT_SET_FOCUS ||
|
||||
event.GetEventType() == wxEVT_KILL_FOCUS ||
|
||||
event.GetEventType() == wxEVT_CHILD_FOCUS ||
|
||||
event.GetEventType() == wxEVT_COMMAND_SET_FOCUS ||
|
||||
event.GetEventType() == wxEVT_COMMAND_KILL_FOCUS )
|
||||
)
|
||||
{
|
||||
res = m_pActiveChild->GetEventHandler()->ProcessEvent(event);
|
||||
}
|
||||
|
||||
if (!res)
|
||||
{
|
||||
// if the event was not handled this frame will handle it,
|
||||
// which is why we need the protection code at the beginning
|
||||
// of this method
|
||||
res = wxEvtHandler::ProcessEvent(event);
|
||||
}
|
||||
|
||||
m_pLastEvt = NULL;
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
wxAuiMDIChildFrame *wxAuiMDIParentFrame::GetActiveChild() const
|
||||
{
|
||||
return m_pActiveChild;
|
||||
}
|
||||
|
||||
void wxAuiMDIParentFrame::SetActiveChild(wxAuiMDIChildFrame* pChildFrame)
|
||||
{
|
||||
m_pActiveChild = pChildFrame;
|
||||
}
|
||||
|
||||
wxAuiMDIClientWindow *wxAuiMDIParentFrame::GetClientWindow() const
|
||||
{
|
||||
return m_pClientWindow;
|
||||
}
|
||||
|
||||
wxAuiMDIClientWindow *wxAuiMDIParentFrame::OnCreateClient()
|
||||
{
|
||||
m_pClientWindow = new wxAuiMDIClientWindow( this );
|
||||
return m_pClientWindow;
|
||||
}
|
||||
|
||||
void wxAuiMDIParentFrame::ActivateNext()
|
||||
{
|
||||
if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
|
||||
{
|
||||
size_t active = m_pClientWindow->GetSelection() + 1;
|
||||
if (active >= m_pClientWindow->GetPageCount())
|
||||
active = 0;
|
||||
|
||||
m_pClientWindow->SetSelection(active);
|
||||
}
|
||||
}
|
||||
|
||||
void wxAuiMDIParentFrame::ActivatePrevious()
|
||||
{
|
||||
if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
|
||||
{
|
||||
int active = m_pClientWindow->GetSelection() - 1;
|
||||
if (active < 0)
|
||||
active = m_pClientWindow->GetPageCount() - 1;
|
||||
|
||||
m_pClientWindow->SetSelection(active);
|
||||
}
|
||||
}
|
||||
|
||||
void wxAuiMDIParentFrame::Init()
|
||||
{
|
||||
m_pLastEvt = NULL;
|
||||
m_pClientWindow = NULL;
|
||||
m_pActiveChild = NULL;
|
||||
#if wxUSE_MENUS
|
||||
m_pWindowMenu = NULL;
|
||||
m_pMyMenuBar = NULL;
|
||||
#endif // wxUSE_MENUS
|
||||
}
|
||||
|
||||
#if wxUSE_MENUS
|
||||
void wxAuiMDIParentFrame::RemoveWindowMenu(wxMenuBar* pMenuBar)
|
||||
{
|
||||
if (pMenuBar && m_pWindowMenu)
|
||||
{
|
||||
// Remove old window menu
|
||||
int pos = pMenuBar->FindMenu(_("&Window"));
|
||||
if (pos != wxNOT_FOUND)
|
||||
{
|
||||
// DBG:: We're going to delete the wrong menu!!!
|
||||
wxASSERT(m_pWindowMenu == pMenuBar->GetMenu(pos));
|
||||
pMenuBar->Remove(pos);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void wxAuiMDIParentFrame::AddWindowMenu(wxMenuBar *pMenuBar)
|
||||
{
|
||||
if (pMenuBar && m_pWindowMenu)
|
||||
{
|
||||
int pos = pMenuBar->FindMenu(wxGetStockLabel(wxID_HELP,wxSTOCK_NOFLAGS));
|
||||
if (pos == wxNOT_FOUND)
|
||||
pMenuBar->Append(m_pWindowMenu, _("&Window"));
|
||||
else
|
||||
pMenuBar->Insert(pos, m_pWindowMenu, _("&Window"));
|
||||
}
|
||||
}
|
||||
|
||||
void wxAuiMDIParentFrame::DoHandleMenu(wxCommandEvent& event)
|
||||
{
|
||||
switch (event.GetId())
|
||||
{
|
||||
case wxWINDOWCLOSE:
|
||||
if (m_pActiveChild)
|
||||
m_pActiveChild->Close();
|
||||
break;
|
||||
case wxWINDOWCLOSEALL:
|
||||
while (m_pActiveChild)
|
||||
{
|
||||
if (!m_pActiveChild->Close())
|
||||
{
|
||||
return; // failure
|
||||
}
|
||||
}
|
||||
break;
|
||||
case wxWINDOWNEXT:
|
||||
ActivateNext();
|
||||
break;
|
||||
case wxWINDOWPREV:
|
||||
ActivatePrevious();
|
||||
break;
|
||||
default:
|
||||
event.Skip();
|
||||
}
|
||||
}
|
||||
#endif // wxUSE_MENUS
|
||||
|
||||
void wxAuiMDIParentFrame::DoGetClientSize(int* width, int* height) const
|
||||
{
|
||||
wxFrame::DoGetClientSize(width, height);
|
||||
}
|
||||
|
||||
void wxAuiMDIParentFrame::Tile(wxOrientation orient)
|
||||
{
|
||||
wxAuiMDIClientWindow* client_window = GetClientWindow();
|
||||
wxASSERT_MSG(client_window, wxT("Missing MDI Client Window"));
|
||||
|
||||
int cur_idx = client_window->GetSelection();
|
||||
if (cur_idx == -1)
|
||||
return;
|
||||
|
||||
if (orient == wxVERTICAL)
|
||||
{
|
||||
client_window->Split(cur_idx, wxLEFT);
|
||||
}
|
||||
else if (orient == wxHORIZONTAL)
|
||||
{
|
||||
client_window->Split(cur_idx, wxTOP);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// wxAuiMDIChildFrame
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
IMPLEMENT_DYNAMIC_CLASS(wxAuiMDIChildFrame, wxPanel)
|
||||
|
||||
BEGIN_EVENT_TABLE(wxAuiMDIChildFrame, wxPanel)
|
||||
EVT_MENU_HIGHLIGHT_ALL(wxAuiMDIChildFrame::OnMenuHighlight)
|
||||
EVT_ACTIVATE(wxAuiMDIChildFrame::OnActivate)
|
||||
EVT_CLOSE(wxAuiMDIChildFrame::OnCloseWindow)
|
||||
END_EVENT_TABLE()
|
||||
|
||||
wxAuiMDIChildFrame::wxAuiMDIChildFrame()
|
||||
{
|
||||
Init();
|
||||
}
|
||||
|
||||
wxAuiMDIChildFrame::wxAuiMDIChildFrame(wxAuiMDIParentFrame *parent,
|
||||
wxWindowID id,
|
||||
const wxString& title,
|
||||
const wxPoint& WXUNUSED(pos),
|
||||
const wxSize& size,
|
||||
long style,
|
||||
const wxString& name)
|
||||
{
|
||||
Init();
|
||||
|
||||
// There are two ways to create an tabbed mdi child fram without
|
||||
// making it the active document. Either Show(false) can be called
|
||||
// before Create() (as is customary on some ports with wxFrame-type
|
||||
// windows), or wxMINIMIZE can be passed in the style flags. Note that
|
||||
// wxAuiMDIChildFrame is not really derived from wxFrame, as wxMDIChildFrame
|
||||
// is, but those are the expected symantics. No style flag is passed
|
||||
// onto the panel underneath.
|
||||
if (style & wxMINIMIZE)
|
||||
m_activate_on_create = false;
|
||||
|
||||
Create(parent, id, title, wxDefaultPosition, size, 0, name);
|
||||
}
|
||||
|
||||
wxAuiMDIChildFrame::~wxAuiMDIChildFrame()
|
||||
{
|
||||
wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
|
||||
if (pParentFrame)
|
||||
{
|
||||
if (pParentFrame->GetActiveChild() == this)
|
||||
{
|
||||
pParentFrame->SetActiveChild(NULL);
|
||||
pParentFrame->SetChildMenuBar(NULL);
|
||||
}
|
||||
wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
|
||||
wxASSERT(pClientWindow);
|
||||
int idx = pClientWindow->GetPageIndex(this);
|
||||
if (idx != wxNOT_FOUND)
|
||||
{
|
||||
pClientWindow->RemovePage(idx);
|
||||
}
|
||||
}
|
||||
|
||||
#if wxUSE_MENUS
|
||||
wxDELETE(m_pMenuBar);
|
||||
#endif // wxUSE_MENUS
|
||||
}
|
||||
|
||||
bool wxAuiMDIChildFrame::Create(wxAuiMDIParentFrame* parent,
|
||||
wxWindowID id,
|
||||
const wxString& title,
|
||||
const wxPoint& WXUNUSED(pos),
|
||||
const wxSize& size,
|
||||
long style,
|
||||
const wxString& name)
|
||||
{
|
||||
wxAuiMDIClientWindow* pClientWindow = parent->GetClientWindow();
|
||||
wxASSERT_MSG((pClientWindow != (wxWindow*) NULL), wxT("Missing MDI client window."));
|
||||
|
||||
// see comment in constructor
|
||||
if (style & wxMINIMIZE)
|
||||
m_activate_on_create = false;
|
||||
|
||||
wxSize cli_size = pClientWindow->GetClientSize();
|
||||
|
||||
// create the window off-screen to prevent flicker
|
||||
wxPanel::Create(pClientWindow,
|
||||
id,
|
||||
wxPoint(cli_size.x+1, cli_size.y+1),
|
||||
size,
|
||||
wxNO_BORDER, name);
|
||||
|
||||
DoShow(false);
|
||||
|
||||
SetMDIParentFrame(parent);
|
||||
|
||||
// this is the currently active child
|
||||
parent->SetActiveChild(this);
|
||||
|
||||
m_title = title;
|
||||
|
||||
pClientWindow->AddPage(this, title, m_activate_on_create);
|
||||
pClientWindow->Refresh();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool wxAuiMDIChildFrame::Destroy()
|
||||
{
|
||||
wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
|
||||
wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
|
||||
|
||||
wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
|
||||
wxASSERT_MSG(pClientWindow, wxT("Missing MDI Client Window"));
|
||||
|
||||
if (pParentFrame->GetActiveChild() == this)
|
||||
{
|
||||
// deactivate ourself
|
||||
wxActivateEvent event(wxEVT_ACTIVATE, false, GetId());
|
||||
event.SetEventObject(this);
|
||||
GetEventHandler()->ProcessEvent(event);
|
||||
|
||||
pParentFrame->SetActiveChild(NULL);
|
||||
pParentFrame->SetChildMenuBar(NULL);
|
||||
}
|
||||
|
||||
size_t page_count = pClientWindow->GetPageCount();
|
||||
for (size_t pos = 0; pos < page_count; pos++)
|
||||
{
|
||||
if (pClientWindow->GetPage(pos) == this)
|
||||
return pClientWindow->DeletePage(pos);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
#if wxUSE_MENUS
|
||||
void wxAuiMDIChildFrame::SetMenuBar(wxMenuBar *menu_bar)
|
||||
{
|
||||
wxMenuBar *pOldMenuBar = m_pMenuBar;
|
||||
m_pMenuBar = menu_bar;
|
||||
|
||||
if (m_pMenuBar)
|
||||
{
|
||||
wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
|
||||
wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
|
||||
|
||||
m_pMenuBar->SetParent(pParentFrame);
|
||||
if (pParentFrame->GetActiveChild() == this)
|
||||
{
|
||||
// replace current menu bars
|
||||
if (pOldMenuBar)
|
||||
pParentFrame->SetChildMenuBar(NULL);
|
||||
pParentFrame->SetChildMenuBar(this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
wxMenuBar *wxAuiMDIChildFrame::GetMenuBar() const
|
||||
{
|
||||
return m_pMenuBar;
|
||||
}
|
||||
#endif // wxUSE_MENUS
|
||||
|
||||
void wxAuiMDIChildFrame::SetTitle(const wxString& title)
|
||||
{
|
||||
m_title = title;
|
||||
|
||||
wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
|
||||
wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
|
||||
|
||||
wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
|
||||
if (pClientWindow != NULL)
|
||||
{
|
||||
size_t pos;
|
||||
for (pos = 0; pos < pClientWindow->GetPageCount(); pos++)
|
||||
{
|
||||
if (pClientWindow->GetPage(pos) == this)
|
||||
{
|
||||
pClientWindow->SetPageText(pos, m_title);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
wxString wxAuiMDIChildFrame::GetTitle() const
|
||||
{
|
||||
return m_title;
|
||||
}
|
||||
|
||||
void wxAuiMDIChildFrame::SetIcons(const wxIconBundle& icons)
|
||||
{
|
||||
// get icon with the system icon size
|
||||
SetIcon(icons.GetIcon(-1));
|
||||
m_icon_bundle = icons;
|
||||
}
|
||||
|
||||
const wxIconBundle& wxAuiMDIChildFrame::GetIcons() const
|
||||
{
|
||||
return m_icon_bundle;
|
||||
}
|
||||
|
||||
void wxAuiMDIChildFrame::SetIcon(const wxIcon& icon)
|
||||
{
|
||||
wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
|
||||
wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
|
||||
|
||||
m_icon = icon;
|
||||
|
||||
wxBitmap bmp;
|
||||
bmp.CopyFromIcon(m_icon);
|
||||
|
||||
wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
|
||||
if (pClientWindow != NULL)
|
||||
{
|
||||
int idx = pClientWindow->GetPageIndex(this);
|
||||
|
||||
if (idx != -1)
|
||||
{
|
||||
pClientWindow->SetPageBitmap((size_t)idx, bmp);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const wxIcon& wxAuiMDIChildFrame::GetIcon() const
|
||||
{
|
||||
return m_icon;
|
||||
}
|
||||
|
||||
|
||||
void wxAuiMDIChildFrame::Activate()
|
||||
{
|
||||
wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
|
||||
wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
|
||||
|
||||
wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
|
||||
|
||||
if (pClientWindow != NULL)
|
||||
{
|
||||
size_t pos;
|
||||
for (pos = 0; pos < pClientWindow->GetPageCount(); pos++)
|
||||
{
|
||||
if (pClientWindow->GetPage(pos) == this)
|
||||
{
|
||||
pClientWindow->SetSelection(pos);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void wxAuiMDIChildFrame::OnMenuHighlight(wxMenuEvent& event)
|
||||
{
|
||||
#if wxUSE_STATUSBAR
|
||||
if (m_pMDIParentFrame)
|
||||
{
|
||||
// we don't have any help text for this item,
|
||||
// but may be the MDI frame does?
|
||||
m_pMDIParentFrame->OnMenuHighlight(event);
|
||||
}
|
||||
#else
|
||||
wxUnusedVar(event);
|
||||
#endif // wxUSE_STATUSBAR
|
||||
}
|
||||
|
||||
void wxAuiMDIChildFrame::OnActivate(wxActivateEvent& WXUNUSED(event))
|
||||
{
|
||||
// do nothing
|
||||
}
|
||||
|
||||
void wxAuiMDIChildFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
|
||||
{
|
||||
Destroy();
|
||||
}
|
||||
|
||||
void wxAuiMDIChildFrame::SetMDIParentFrame(wxAuiMDIParentFrame* parentFrame)
|
||||
{
|
||||
m_pMDIParentFrame = parentFrame;
|
||||
}
|
||||
|
||||
wxAuiMDIParentFrame* wxAuiMDIChildFrame::GetMDIParentFrame() const
|
||||
{
|
||||
return m_pMDIParentFrame;
|
||||
}
|
||||
|
||||
void wxAuiMDIChildFrame::Init()
|
||||
{
|
||||
m_activate_on_create = true;
|
||||
m_pMDIParentFrame = NULL;
|
||||
#if wxUSE_MENUS
|
||||
m_pMenuBar = NULL;
|
||||
#endif // wxUSE_MENUS
|
||||
}
|
||||
|
||||
bool wxAuiMDIChildFrame::Show(bool show)
|
||||
{
|
||||
m_activate_on_create = show;
|
||||
|
||||
// do nothing
|
||||
return true;
|
||||
}
|
||||
|
||||
void wxAuiMDIChildFrame::DoShow(bool show)
|
||||
{
|
||||
wxWindow::Show(show);
|
||||
}
|
||||
|
||||
void wxAuiMDIChildFrame::DoSetSize(int x, int y, int width, int height, int sizeFlags)
|
||||
{
|
||||
m_mdi_newrect = wxRect(x, y, width, height);
|
||||
#ifdef __WXGTK__
|
||||
wxPanel::DoSetSize(x,y,width, height, sizeFlags);
|
||||
#else
|
||||
wxUnusedVar(sizeFlags);
|
||||
#endif
|
||||
}
|
||||
|
||||
void wxAuiMDIChildFrame::DoMoveWindow(int x, int y, int width, int height)
|
||||
{
|
||||
m_mdi_newrect = wxRect(x, y, width, height);
|
||||
}
|
||||
|
||||
void wxAuiMDIChildFrame::ApplyMDIChildFrameRect()
|
||||
{
|
||||
if (m_mdi_currect != m_mdi_newrect)
|
||||
{
|
||||
wxPanel::DoMoveWindow(m_mdi_newrect.x, m_mdi_newrect.y,
|
||||
m_mdi_newrect.width, m_mdi_newrect.height);
|
||||
m_mdi_currect = m_mdi_newrect;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// wxAuiMDIClientWindow
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
IMPLEMENT_DYNAMIC_CLASS(wxAuiMDIClientWindow, wxAuiNotebook)
|
||||
|
||||
BEGIN_EVENT_TABLE(wxAuiMDIClientWindow, wxAuiNotebook)
|
||||
EVT_AUINOTEBOOK_PAGE_CHANGED(wxID_ANY, wxAuiMDIClientWindow::OnPageChanged)
|
||||
EVT_AUINOTEBOOK_PAGE_CLOSE(wxID_ANY, wxAuiMDIClientWindow::OnPageClose)
|
||||
EVT_SIZE(wxAuiMDIClientWindow::OnSize)
|
||||
END_EVENT_TABLE()
|
||||
|
||||
wxAuiMDIClientWindow::wxAuiMDIClientWindow()
|
||||
{
|
||||
}
|
||||
|
||||
wxAuiMDIClientWindow::wxAuiMDIClientWindow(wxAuiMDIParentFrame* parent, long style)
|
||||
{
|
||||
CreateClient(parent, style);
|
||||
}
|
||||
|
||||
wxAuiMDIClientWindow::~wxAuiMDIClientWindow()
|
||||
{
|
||||
}
|
||||
|
||||
bool wxAuiMDIClientWindow::CreateClient(wxAuiMDIParentFrame* parent, long style)
|
||||
{
|
||||
SetWindowStyleFlag(style);
|
||||
|
||||
wxSize caption_icon_size =
|
||||
wxSize(wxSystemSettings::GetMetric(wxSYS_SMALLICON_X),
|
||||
wxSystemSettings::GetMetric(wxSYS_SMALLICON_Y));
|
||||
SetUniformBitmapSize(caption_icon_size);
|
||||
|
||||
if (!wxAuiNotebook::Create(parent,
|
||||
wxID_ANY,
|
||||
wxPoint(0,0),
|
||||
wxSize(100, 100),
|
||||
wxAUI_NB_DEFAULT_STYLE | wxNO_BORDER))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
wxColour bkcolour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
|
||||
SetOwnBackgroundColour(bkcolour);
|
||||
|
||||
m_mgr.GetArtProvider()->SetColour(wxAUI_DOCKART_BACKGROUND_COLOUR, bkcolour);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
int wxAuiMDIClientWindow::SetSelection(size_t nPage)
|
||||
{
|
||||
return wxAuiNotebook::SetSelection(nPage);
|
||||
}
|
||||
|
||||
void wxAuiMDIClientWindow::PageChanged(int old_selection, int new_selection)
|
||||
{
|
||||
// don't do anything if the page doesn't actually change
|
||||
if (old_selection == new_selection)
|
||||
return;
|
||||
|
||||
/*
|
||||
// don't do anything if the new page is already active
|
||||
if (new_selection != -1)
|
||||
{
|
||||
wxAuiMDIChildFrame* child = (wxAuiMDIChildFrame*)GetPage(new_selection);
|
||||
if (child->GetMDIParentFrame()->GetActiveChild() == child)
|
||||
return;
|
||||
}*/
|
||||
|
||||
|
||||
// notify old active child that it has been deactivated
|
||||
if ((old_selection != -1) && (old_selection < (int)GetPageCount()))
|
||||
{
|
||||
wxAuiMDIChildFrame* old_child = (wxAuiMDIChildFrame*)GetPage(old_selection);
|
||||
wxASSERT_MSG(old_child, wxT("wxAuiMDIClientWindow::PageChanged - null page pointer"));
|
||||
|
||||
wxActivateEvent event(wxEVT_ACTIVATE, false, old_child->GetId());
|
||||
event.SetEventObject(old_child);
|
||||
old_child->GetEventHandler()->ProcessEvent(event);
|
||||
}
|
||||
|
||||
// notify new active child that it has been activated
|
||||
if (new_selection != -1)
|
||||
{
|
||||
wxAuiMDIChildFrame* active_child = (wxAuiMDIChildFrame*)GetPage(new_selection);
|
||||
wxASSERT_MSG(active_child, wxT("wxAuiMDIClientWindow::PageChanged - null page pointer"));
|
||||
|
||||
wxActivateEvent event(wxEVT_ACTIVATE, true, active_child->GetId());
|
||||
event.SetEventObject(active_child);
|
||||
active_child->GetEventHandler()->ProcessEvent(event);
|
||||
|
||||
if (active_child->GetMDIParentFrame())
|
||||
{
|
||||
active_child->GetMDIParentFrame()->SetActiveChild(active_child);
|
||||
active_child->GetMDIParentFrame()->SetChildMenuBar(active_child);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
void wxAuiMDIClientWindow::OnPageClose(wxAuiNotebookEvent& evt)
|
||||
{
|
||||
wxAuiMDIChildFrame*
|
||||
wnd = wx_static_cast(wxAuiMDIChildFrame*, GetPage(evt.GetSelection()));
|
||||
|
||||
wnd->Close();
|
||||
|
||||
// regardless of the result of wnd->Close(), we've
|
||||
// already taken care of the close operations, so
|
||||
// suppress further processing
|
||||
evt.Veto();
|
||||
}
|
||||
|
||||
void wxAuiMDIClientWindow::OnPageChanged(wxAuiNotebookEvent& evt)
|
||||
{
|
||||
PageChanged(evt.GetOldSelection(), evt.GetSelection());
|
||||
}
|
||||
|
||||
void wxAuiMDIClientWindow::OnSize(wxSizeEvent& evt)
|
||||
{
|
||||
wxAuiNotebook::OnSize(evt);
|
||||
|
||||
for (size_t pos = 0; pos < GetPageCount(); pos++)
|
||||
((wxAuiMDIChildFrame *)GetPage(pos))->ApplyMDIChildFrameRect();
|
||||
}
|
||||
|
||||
#endif // wxUSE_MDI
|
||||
|
||||
#endif // wxUSE_AUI
|
||||
Loading…
Reference in New Issue