git.saurik.com Git - wxWidgets.git/blame_incremental

... / ...

Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: wx/aui/framemanager.h
	3	// Purpose: wxaui: wx advanced user interface - docking window manager
	4	// Author: Benjamin I. Williams
	5	// Modified by:
	6	// Created: 2005-05-17
	7	// RCS-ID: $Id$
	8	// Copyright: (C) Copyright 2005, Kirix Corporation, All Rights Reserved.
	9	// Licence: wxWindows Library Licence, Version 3.1
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	#ifndef _WX_FRAMEMANAGER_H_
	13	#define _WX_FRAMEMANAGER_H_
	14
	15	// ----------------------------------------------------------------------------
	16	// headers
	17	// ----------------------------------------------------------------------------
	18
	19	#include "wx/defs.h"
	20
	21	#if wxUSE_AUI
	22
	23	#include "wx/dynarray.h"
	24	#include "wx/gdicmn.h"
	25	#include "wx/window.h"
	26	#include "wx/timer.h"
	27	#include "wx/sizer.h"
	28
	29	enum wxAuiManagerDock
	30	{
	31	wxAUI_DOCK_NONE = 0,
	32	wxAUI_DOCK_TOP = 1,
	33	wxAUI_DOCK_RIGHT = 2,
	34	wxAUI_DOCK_BOTTOM = 3,
	35	wxAUI_DOCK_LEFT = 4,
	36	wxAUI_DOCK_CENTER = 5,
	37	wxAUI_DOCK_CENTRE = wxAUI_DOCK_CENTER
	38	};
	39
	40	enum wxAuiManagerOption
	41	{
	42	wxAUI_MGR_ALLOW_FLOATING = 1 << 0,
	43	wxAUI_MGR_ALLOW_ACTIVE_PANE = 1 << 1,
	44	wxAUI_MGR_TRANSPARENT_DRAG = 1 << 2,
	45	wxAUI_MGR_TRANSPARENT_HINT = 1 << 3,
	46	wxAUI_MGR_VENETIAN_BLINDS_HINT = 1 << 4,
	47	wxAUI_MGR_RECTANGLE_HINT = 1 << 5,
	48	wxAUI_MGR_HINT_FADE = 1 << 6,
	49	wxAUI_MGR_NO_VENETIAN_BLINDS_FADE = 1 << 7,
	50
	51	wxAUI_MGR_DEFAULT = wxAUI_MGR_ALLOW_FLOATING \|
	52	wxAUI_MGR_TRANSPARENT_HINT \|
	53	wxAUI_MGR_HINT_FADE \|
	54	wxAUI_MGR_NO_VENETIAN_BLINDS_FADE
	55	};
	56
	57
	58	enum wxAuiPaneDockArtSetting
	59	{
	60	wxAUI_DOCKART_SASH_SIZE = 0,
	61	wxAUI_DOCKART_CAPTION_SIZE = 1,
	62	wxAUI_DOCKART_GRIPPER_SIZE = 2,
	63	wxAUI_DOCKART_PANE_BORDER_SIZE = 3,
	64	wxAUI_DOCKART_PANE_BUTTON_SIZE = 4,
	65	wxAUI_DOCKART_BACKGROUND_COLOUR = 5,
	66	wxAUI_DOCKART_SASH_COLOUR = 6,
	67	wxAUI_DOCKART_ACTIVE_CAPTION_COLOUR = 7,
	68	wxAUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR = 8,
	69	wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR = 9,
	70	wxAUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR = 10,
	71	wxAUI_DOCKART_ACTIVE_CAPTION_TEXT_COLOUR = 11,
	72	wxAUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR = 12,
	73	wxAUI_DOCKART_BORDER_COLOUR = 13,
	74	wxAUI_DOCKART_GRIPPER_COLOUR = 14,
	75	wxAUI_DOCKART_CAPTION_FONT = 15,
	76	wxAUI_DOCKART_GRADIENT_TYPE = 16
	77	};
	78
	79	enum wxAuiPaneDockArtGradients
	80	{
	81	wxAUI_GRADIENT_NONE = 0,
	82	wxAUI_GRADIENT_VERTICAL = 1,
	83	wxAUI_GRADIENT_HORIZONTAL = 2
	84	};
	85
	86	enum wxAuiPaneButtonState
	87	{
	88	wxAUI_BUTTON_STATE_NORMAL = 0,
	89	wxAUI_BUTTON_STATE_HOVER = 1 << 1,
	90	wxAUI_BUTTON_STATE_PRESSED = 1 << 2,
	91	wxAUI_BUTTON_STATE_DISABLED = 1 << 3,
	92	wxAUI_BUTTON_STATE_HIDDEN = 1 << 4,
	93	wxAUI_BUTTON_STATE_CHECKED = 1 << 5
	94	};
	95
	96	enum wxAuiButtonId
	97	{
	98	wxAUI_BUTTON_CLOSE = 101,
	99	wxAUI_BUTTON_MAXIMIZE_RESTORE = 102,
	100	wxAUI_BUTTON_MINIMIZE = 103,
	101	wxAUI_BUTTON_PIN = 104,
	102	wxAUI_BUTTON_OPTIONS = 105,
	103	wxAUI_BUTTON_WINDOWLIST = 106,
	104	wxAUI_BUTTON_LEFT = 107,
	105	wxAUI_BUTTON_RIGHT = 108,
	106	wxAUI_BUTTON_UP = 109,
	107	wxAUI_BUTTON_DOWN = 110,
	108	wxAUI_BUTTON_CUSTOM1 = 201,
	109	wxAUI_BUTTON_CUSTOM2 = 202,
	110	wxAUI_BUTTON_CUSTOM3 = 203
	111	};
	112
	113	enum wxAuiPaneInsertLevel
	114	{
	115	wxAUI_INSERT_PANE = 0,
	116	wxAUI_INSERT_ROW = 1,
	117	wxAUI_INSERT_DOCK = 2
	118	};
	119
	120
	121
	122
	123	// forwards and array declarations
	124	class wxAuiDockUIPart;
	125	class wxAuiPaneButton;
	126	class wxAuiPaneInfo;
	127	class wxAuiDockInfo;
	128	class wxAuiDockArt;
	129	class wxAuiManagerEvent;
	130
	131	#ifndef SWIG
	132	WX_DECLARE_USER_EXPORTED_OBJARRAY(wxAuiDockInfo, wxAuiDockInfoArray, WXDLLIMPEXP_AUI);
	133	WX_DECLARE_USER_EXPORTED_OBJARRAY(wxAuiDockUIPart, wxAuiDockUIPartArray, WXDLLIMPEXP_AUI);
	134	WX_DECLARE_USER_EXPORTED_OBJARRAY(wxAuiPaneButton, wxAuiPaneButtonArray, WXDLLIMPEXP_AUI);
	135	WX_DECLARE_USER_EXPORTED_OBJARRAY(wxAuiPaneInfo, wxAuiPaneInfoArray, WXDLLIMPEXP_AUI);
	136	WX_DEFINE_USER_EXPORTED_ARRAY_PTR(wxAuiPaneInfo*, wxAuiPaneInfoPtrArray, class WXDLLIMPEXP_AUI);
	137	WX_DEFINE_USER_EXPORTED_ARRAY_PTR(wxAuiDockInfo*, wxAuiDockInfoPtrArray, class WXDLLIMPEXP_AUI);
	138	#endif // SWIG
	139
	140	extern WXDLLIMPEXP_AUI wxAuiDockInfo wxAuiNullDockInfo;
	141	extern WXDLLIMPEXP_AUI wxAuiPaneInfo wxAuiNullPaneInfo;
	142
	143
	144
	145	class WXDLLIMPEXP_AUI wxAuiPaneInfo
	146	{
	147	public:
	148
	149	wxAuiPaneInfo()
	150	{
	151	window = NULL;
	152	frame = NULL;
	153	state = 0;
	154	dock_direction = wxAUI_DOCK_LEFT;
	155	dock_layer = 0;
	156	dock_row = 0;
	157	dock_pos = 0;
	158	floating_pos = wxDefaultPosition;
	159	floating_size = wxDefaultSize;
	160	best_size = wxDefaultSize;
	161	min_size = wxDefaultSize;
	162	max_size = wxDefaultSize;
	163	dock_proportion = 0;
	164
	165	DefaultPane();
	166	}
	167
	168	~wxAuiPaneInfo() {}
	169
	170	#ifndef SWIG
	171	wxAuiPaneInfo(const wxAuiPaneInfo& c)
	172	{
	173	name = c.name;
	174	caption = c.caption;
	175	window = c.window;
	176	frame = c.frame;
	177	state = c.state;
	178	dock_direction = c.dock_direction;
	179	dock_layer = c.dock_layer;
	180	dock_row = c.dock_row;
	181	dock_pos = c.dock_pos;
	182	best_size = c.best_size;
	183	min_size = c.min_size;
	184	max_size = c.max_size;
	185	floating_pos = c.floating_pos;
	186	floating_size = c.floating_size;
	187	dock_proportion = c.dock_proportion;
	188	buttons = c.buttons;
	189	rect = c.rect;
	190	}
	191
	192	wxAuiPaneInfo& operator=(const wxAuiPaneInfo& c)
	193	{
	194	name = c.name;
	195	caption = c.caption;
	196	window = c.window;
	197	frame = c.frame;
	198	state = c.state;
	199	dock_direction = c.dock_direction;
	200	dock_layer = c.dock_layer;
	201	dock_row = c.dock_row;
	202	dock_pos = c.dock_pos;
	203	best_size = c.best_size;
	204	min_size = c.min_size;
	205	max_size = c.max_size;
	206	floating_pos = c.floating_pos;
	207	floating_size = c.floating_size;
	208	dock_proportion = c.dock_proportion;
	209	buttons = c.buttons;
	210	rect = c.rect;
	211	return *this;
	212	}
	213	#endif // SWIG
	214
	215	// Write the safe parts of a newly loaded PaneInfo structure "source" into "this"
	216	// used on loading perspectives etc.
	217	void SafeSet(wxAuiPaneInfo source)
	218	{
	219	// note source is not passed by reference so we can overwrite, to keep the
	220	// unsafe bits of "dest"
	221	source.window = window;
	222	source.frame = frame;
	223	source.buttons = buttons;
	224	// now assign
	225	*this = source;
	226	}
	227
	228	bool IsOk() const { return (window != NULL) ? true : false; }
	229	bool IsFixed() const { return !HasFlag(optionResizable); }
	230	bool IsResizable() const { return HasFlag(optionResizable); }
	231	bool IsShown() const { return !HasFlag(optionHidden); }
	232	bool IsFloating() const { return HasFlag(optionFloating); }
	233	bool IsDocked() const { return !HasFlag(optionFloating); }
	234	bool IsToolbar() const { return HasFlag(optionToolbar); }
	235	bool IsTopDockable() const { return HasFlag(optionTopDockable); }
	236	bool IsBottomDockable() const { return HasFlag(optionBottomDockable); }
	237	bool IsLeftDockable() const { return HasFlag(optionLeftDockable); }
	238	bool IsRightDockable() const { return HasFlag(optionRightDockable); }
	239	bool IsFloatable() const { return HasFlag(optionFloatable); }
	240	bool IsMovable() const { return HasFlag(optionMovable); }
	241	bool IsDestroyOnClose() const { return HasFlag(optionDestroyOnClose); }
	242	bool IsMaximized() const { return HasFlag(optionMaximized); }
	243	bool HasCaption() const { return HasFlag(optionCaption); }
	244	bool HasGripper() const { return HasFlag(optionGripper); }
	245	bool HasBorder() const { return HasFlag(optionPaneBorder); }
	246	bool HasCloseButton() const { return HasFlag(buttonClose); }
	247	bool HasMaximizeButton() const { return HasFlag(buttonMaximize); }
	248	bool HasMinimizeButton() const { return HasFlag(buttonMinimize); }
	249	bool HasPinButton() const { return HasFlag(buttonPin); }
	250	bool HasGripperTop() const { return HasFlag(optionGripperTop); }
	251
	252	#ifdef SWIG
	253	%typemap(out) wxAuiPaneInfo& { $result = $self; Py_INCREF($result); }
	254	#endif
	255	wxAuiPaneInfo& Window(wxWindow* w) { window = w; return *this; }
	256	wxAuiPaneInfo& Name(const wxString& n) { name = n; return *this; }
	257	wxAuiPaneInfo& Caption(const wxString& c) { caption = c; return *this; }
	258	wxAuiPaneInfo& Left() { dock_direction = wxAUI_DOCK_LEFT; return *this; }
	259	wxAuiPaneInfo& Right() { dock_direction = wxAUI_DOCK_RIGHT; return *this; }
	260	wxAuiPaneInfo& Top() { dock_direction = wxAUI_DOCK_TOP; return *this; }
	261	wxAuiPaneInfo& Bottom() { dock_direction = wxAUI_DOCK_BOTTOM; return *this; }
	262	wxAuiPaneInfo& Center() { dock_direction = wxAUI_DOCK_CENTER; return *this; }
	263	wxAuiPaneInfo& Centre() { dock_direction = wxAUI_DOCK_CENTRE; return *this; }
	264	wxAuiPaneInfo& Direction(int direction) { dock_direction = direction; return *this; }
	265	wxAuiPaneInfo& Layer(int layer) { dock_layer = layer; return *this; }
	266	wxAuiPaneInfo& Row(int row) { dock_row = row; return *this; }
	267	wxAuiPaneInfo& Position(int pos) { dock_pos = pos; return *this; }
	268	wxAuiPaneInfo& BestSize(const wxSize& size) { best_size = size; return *this; }
	269	wxAuiPaneInfo& MinSize(const wxSize& size) { min_size = size; return *this; }
	270	wxAuiPaneInfo& MaxSize(const wxSize& size) { max_size = size; return *this; }
	271	wxAuiPaneInfo& BestSize(int x, int y) { best_size.Set(x,y); return *this; }
	272	wxAuiPaneInfo& MinSize(int x, int y) { min_size.Set(x,y); return *this; }
	273	wxAuiPaneInfo& MaxSize(int x, int y) { max_size.Set(x,y); return *this; }
	274	wxAuiPaneInfo& FloatingPosition(const wxPoint& pos) { floating_pos = pos; return *this; }
	275	wxAuiPaneInfo& FloatingPosition(int x, int y) { floating_pos.x = x; floating_pos.y = y; return *this; }
	276	wxAuiPaneInfo& FloatingSize(const wxSize& size) { floating_size = size; return *this; }
	277	wxAuiPaneInfo& FloatingSize(int x, int y) { floating_size.Set(x,y); return *this; }
	278	wxAuiPaneInfo& Fixed() { return SetFlag(optionResizable, false); }
	279	wxAuiPaneInfo& Resizable(bool resizable = true) { return SetFlag(optionResizable, resizable); }
	280	wxAuiPaneInfo& Dock() { return SetFlag(optionFloating, false); }
	281	wxAuiPaneInfo& Float() { return SetFlag(optionFloating, true); }
	282	wxAuiPaneInfo& Hide() { return SetFlag(optionHidden, true); }
	283	wxAuiPaneInfo& Show(bool show = true) { return SetFlag(optionHidden, !show); }
	284	wxAuiPaneInfo& CaptionVisible(bool visible = true) { return SetFlag(optionCaption, visible); }
	285	wxAuiPaneInfo& Maximize() { return SetFlag(optionMaximized, true); }
	286	wxAuiPaneInfo& Restore() { return SetFlag(optionMaximized, false); }
	287	wxAuiPaneInfo& PaneBorder(bool visible = true) { return SetFlag(optionPaneBorder, visible); }
	288	wxAuiPaneInfo& Gripper(bool visible = true) { return SetFlag(optionGripper, visible); }
	289	wxAuiPaneInfo& GripperTop(bool attop = true) { return SetFlag(optionGripperTop, attop); }
	290	wxAuiPaneInfo& CloseButton(bool visible = true) { return SetFlag(buttonClose, visible); }
	291	wxAuiPaneInfo& MaximizeButton(bool visible = true) { return SetFlag(buttonMaximize, visible); }
	292	wxAuiPaneInfo& MinimizeButton(bool visible = true) { return SetFlag(buttonMinimize, visible); }
	293	wxAuiPaneInfo& PinButton(bool visible = true) { return SetFlag(buttonPin, visible); }
	294	wxAuiPaneInfo& DestroyOnClose(bool b = true) { return SetFlag(optionDestroyOnClose, b); }
	295	wxAuiPaneInfo& TopDockable(bool b = true) { return SetFlag(optionTopDockable, b); }
	296	wxAuiPaneInfo& BottomDockable(bool b = true) { return SetFlag(optionBottomDockable, b); }
	297	wxAuiPaneInfo& LeftDockable(bool b = true) { return SetFlag(optionLeftDockable, b); }
	298	wxAuiPaneInfo& RightDockable(bool b = true) { return SetFlag(optionRightDockable, b); }
	299	wxAuiPaneInfo& Floatable(bool b = true) { return SetFlag(optionFloatable, b); }
	300	wxAuiPaneInfo& Movable(bool b = true) { return SetFlag(optionMovable, b); }
	301
	302	wxAuiPaneInfo& Dockable(bool b = true)
	303	{
	304	return TopDockable(b).BottomDockable(b).LeftDockable(b).RightDockable(b);
	305	}
	306
	307	wxAuiPaneInfo& DefaultPane()
	308	{
	309	state \|= optionTopDockable \| optionBottomDockable \|
	310	optionLeftDockable \| optionRightDockable \|
	311	optionFloatable \| optionMovable \| optionResizable \|
	312	optionCaption \| optionPaneBorder \| buttonClose;
	313	return *this;
	314	}
	315
	316	wxAuiPaneInfo& CentrePane() { return CenterPane(); }
	317	wxAuiPaneInfo& CenterPane()
	318	{
	319	state = 0;
	320	return Center().PaneBorder().Resizable();
	321	}
	322
	323	wxAuiPaneInfo& ToolbarPane()
	324	{
	325	DefaultPane();
	326	state \|= (optionToolbar \| optionGripper);
	327	state &= ~(optionResizable \| optionCaption);
	328	if (dock_layer == 0)
	329	dock_layer = 10;
	330	return *this;
	331	}
	332
	333	wxAuiPaneInfo& SetFlag(unsigned int flag, bool option_state)
	334	{
	335	if (option_state)
	336	state \|= flag;
	337	else
	338	state &= ~flag;
	339	return *this;
	340	}
	341
	342	bool HasFlag(unsigned int flag) const
	343	{
	344	return (state & flag) ? true:false;
	345	}
	346
	347	#ifdef SWIG
	348	%typemap(out) wxAuiPaneInfo& ;
	349	#endif
	350
	351	public:
	352
	353	// NOTE: You can add and subtract flags from this list,
	354	// but do not change the values of the flags, because
	355	// they are stored in a binary integer format in the
	356	// perspective string. If you really need to change the
	357	// values around, you'll have to ensure backwards-compatibility
	358	// in the perspective loading code.
	359	enum wxAuiPaneState
	360	{
	361	optionFloating = 1 << 0,
	362	optionHidden = 1 << 1,
	363	optionLeftDockable = 1 << 2,
	364	optionRightDockable = 1 << 3,
	365	optionTopDockable = 1 << 4,
	366	optionBottomDockable = 1 << 5,
	367	optionFloatable = 1 << 6,
	368	optionMovable = 1 << 7,
	369	optionResizable = 1 << 8,
	370	optionPaneBorder = 1 << 9,
	371	optionCaption = 1 << 10,
	372	optionGripper = 1 << 11,
	373	optionDestroyOnClose = 1 << 12,
	374	optionToolbar = 1 << 13,
	375	optionActive = 1 << 14,
	376	optionGripperTop = 1 << 15,
	377	optionMaximized = 1 << 16,
	378
	379	buttonClose = 1 << 21,
	380	buttonMaximize = 1 << 22,
	381	buttonMinimize = 1 << 23,
	382	buttonPin = 1 << 24,
	383
	384	buttonCustom1 = 1 << 26,
	385	buttonCustom2 = 1 << 27,
	386	buttonCustom3 = 1 << 28,
	387
	388	savedHiddenState = 1 << 30, // used internally
	389	actionPane = 1 << 31 // used internally
	390	};
	391
	392	public:
	393	wxString name; // name of the pane
	394	wxString caption; // caption displayed on the window
	395
	396	wxWindow* window; // window that is in this pane
	397	wxFrame* frame; // floating frame window that holds the pane
	398	unsigned int state; // a combination of wxPaneState values
	399
	400	int dock_direction; // dock direction (top, bottom, left, right, center)
	401	int dock_layer; // layer number (0 = innermost layer)
	402	int dock_row; // row number on the docking bar (0 = first row)
	403	int dock_pos; // position inside the row (0 = first position)
	404
	405	wxSize best_size; // size that the layout engine will prefer
	406	wxSize min_size; // minimum size the pane window can tolerate
	407	wxSize max_size; // maximum size the pane window can tolerate
	408
	409	wxPoint floating_pos; // position while floating
	410	wxSize floating_size; // size while floating
	411	int dock_proportion; // proportion while docked
	412
	413	wxAuiPaneButtonArray buttons; // buttons on the pane
	414
	415	wxRect rect; // current rectangle (populated by wxAUI)
	416	};
	417
	418
	419
	420	class WXDLLIMPEXP_AUI wxAuiFloatingFrame;
	421
	422	class WXDLLIMPEXP_AUI wxAuiManager : public wxEvtHandler
	423	{
	424	friend class wxAuiFloatingFrame;
	425
	426	public:
	427
	428	wxAuiManager(wxWindow* managed_wnd = NULL,
	429	unsigned int flags = wxAUI_MGR_DEFAULT);
	430	virtual ~wxAuiManager();
	431	void UnInit();
	432
	433	void SetFlags(unsigned int flags);
	434	unsigned int GetFlags() const;
	435
	436	void SetManagedWindow(wxWindow* managed_wnd);
	437	wxWindow* GetManagedWindow() const;
	438
	439	static wxAuiManager* GetManager(wxWindow* window);
	440
	441	#ifdef SWIG
	442	%disownarg( wxAuiDockArt* art_provider );
	443	#endif
	444	void SetArtProvider(wxAuiDockArt* art_provider);
	445	wxAuiDockArt* GetArtProvider() const;
	446
	447	wxAuiPaneInfo& GetPane(wxWindow* window);
	448	wxAuiPaneInfo& GetPane(const wxString& name);
	449	wxAuiPaneInfoArray& GetAllPanes();
	450
	451	bool AddPane(wxWindow* window,
	452	const wxAuiPaneInfo& pane_info);
	453
	454	bool AddPane(wxWindow* window,
	455	const wxAuiPaneInfo& pane_info,
	456	const wxPoint& drop_pos);
	457
	458	bool AddPane(wxWindow* window,
	459	int direction = wxLEFT,
	460	const wxString& caption = wxEmptyString);
	461
	462	bool InsertPane(wxWindow* window,
	463	const wxAuiPaneInfo& insert_location,
	464	int insert_level = wxAUI_INSERT_PANE);
	465
	466	bool DetachPane(wxWindow* window);
	467
	468	void Update();
	469
	470	wxString SavePaneInfo(wxAuiPaneInfo& pane);
	471	void LoadPaneInfo(wxString pane_part, wxAuiPaneInfo &pane);
	472	wxString SavePerspective();
	473	bool LoadPerspective(const wxString& perspective, bool update = true);
	474
	475	void SetDockSizeConstraint(double width_pct, double height_pct);
	476	void GetDockSizeConstraint(double* width_pct, double* height_pct) const;
	477
	478	void ClosePane(wxAuiPaneInfo& pane_info);
	479	void MaximizePane(wxAuiPaneInfo& pane_info);
	480	void RestorePane(wxAuiPaneInfo& pane_info);
	481	void RestoreMaximizedPane();
	482
	483	public:
	484
	485	virtual wxAuiFloatingFrame* CreateFloatingFrame(wxWindow* parent, const wxAuiPaneInfo& p);
	486
	487	void StartPaneDrag(
	488	wxWindow* pane_window,
	489	const wxPoint& offset);
	490
	491	wxRect CalculateHintRect(
	492	wxWindow* pane_window,
	493	const wxPoint& pt,
	494	const wxPoint& offset);
	495
	496	void DrawHintRect(
	497	wxWindow* pane_window,
	498	const wxPoint& pt,
	499	const wxPoint& offset);
	500
	501	virtual void ShowHint(const wxRect& rect);
	502	virtual void HideHint();
	503
	504	public:
	505
	506	// deprecated -- please use SetManagedWindow() and
	507	// and GetManagedWindow() instead
	508
	509	wxDEPRECATED( void SetFrame(wxFrame* frame) );
	510	wxDEPRECATED( wxFrame* GetFrame() const );
	511
	512	protected:
	513
	514	void UpdateHintWindowConfig();
	515
	516	void DoFrameLayout();
	517
	518	void LayoutAddPane(wxSizer* container,
	519	wxAuiDockInfo& dock,
	520	wxAuiPaneInfo& pane,
	521	wxAuiDockUIPartArray& uiparts,
	522	bool spacer_only);
	523
	524	void LayoutAddDock(wxSizer* container,
	525	wxAuiDockInfo& dock,
	526	wxAuiDockUIPartArray& uiparts,
	527	bool spacer_only);
	528
	529	wxSizer* LayoutAll(wxAuiPaneInfoArray& panes,
	530	wxAuiDockInfoArray& docks,
	531	wxAuiDockUIPartArray& uiparts,
	532	bool spacer_only = false);
	533
	534	virtual bool ProcessDockResult(wxAuiPaneInfo& target,
	535	const wxAuiPaneInfo& new_pos);
	536
	537	bool DoDrop(wxAuiDockInfoArray& docks,
	538	wxAuiPaneInfoArray& panes,
	539	wxAuiPaneInfo& drop,
	540	const wxPoint& pt,
	541	const wxPoint& action_offset = wxPoint(0,0));
	542
	543	wxAuiDockUIPart* HitTest(int x, int y);
	544	wxAuiDockUIPart* GetPanePart(wxWindow* pane);
	545	int GetDockPixelOffset(wxAuiPaneInfo& test);
	546	void OnFloatingPaneMoveStart(wxWindow* window);
	547	void OnFloatingPaneMoving(wxWindow* window, wxDirection dir );
	548	void OnFloatingPaneMoved(wxWindow* window, wxDirection dir);
	549	void OnFloatingPaneActivated(wxWindow* window);
	550	void OnFloatingPaneClosed(wxWindow* window, wxCloseEvent& evt);
	551	void OnFloatingPaneResized(wxWindow* window, const wxSize& size);
	552	void Render(wxDC* dc);
	553	void Repaint(wxDC* dc = NULL);
	554	void ProcessMgrEvent(wxAuiManagerEvent& event);
	555	void UpdateButtonOnScreen(wxAuiDockUIPart* button_ui_part,
	556	const wxMouseEvent& event);
	557	void GetPanePositionsAndSizes(wxAuiDockInfo& dock,
	558	wxArrayInt& positions,
	559	wxArrayInt& sizes);
	560
	561
	562	public:
	563
	564	// public events (which can be invoked externally)
	565	void OnRender(wxAuiManagerEvent& evt);
	566	void OnPaneButton(wxAuiManagerEvent& evt);
	567
	568	protected:
	569
	570	// protected events
	571	void OnPaint(wxPaintEvent& evt);
	572	void OnEraseBackground(wxEraseEvent& evt);
	573	void OnSize(wxSizeEvent& evt);
	574	void OnSetCursor(wxSetCursorEvent& evt);
	575	void OnLeftDown(wxMouseEvent& evt);
	576	void OnLeftUp(wxMouseEvent& evt);
	577	void OnMotion(wxMouseEvent& evt);
	578	void OnLeaveWindow(wxMouseEvent& evt);
	579	void OnChildFocus(wxChildFocusEvent& evt);
	580	void OnHintFadeTimer(wxTimerEvent& evt);
	581	void OnFindManager(wxAuiManagerEvent& evt);
	582
	583	protected:
	584
	585	enum
	586	{
	587	actionNone = 0,
	588	actionResize,
	589	actionClickButton,
	590	actionClickCaption,
	591	actionDragToolbarPane,
	592	actionDragFloatingPane
	593	};
	594
	595	protected:
	596
	597	wxWindow* m_frame; // the window being managed
	598	wxAuiDockArt* m_art; // dock art object which does all drawing
	599	unsigned int m_flags; // manager flags wxAUI_MGR_*
	600
	601	wxAuiPaneInfoArray m_panes; // array of panes structures
	602	wxAuiDockInfoArray m_docks; // array of docks structures
	603	wxAuiDockUIPartArray m_uiparts; // array of UI parts (captions, buttons, etc)
	604
	605	int m_action; // current mouse action
	606	wxPoint m_action_start; // position where the action click started
	607	wxPoint m_action_offset; // offset from upper left of the item clicked
	608	wxAuiDockUIPart* m_action_part; // ptr to the part the action happened to
	609	wxWindow* m_action_window; // action frame or window (NULL if none)
	610	wxRect m_action_hintrect; // hint rectangle for the action
	611	wxRect m_last_rect;
	612	wxAuiDockUIPart* m_hover_button;// button uipart being hovered over
	613	wxRect m_last_hint; // last hint rectangle
	614	wxPoint m_last_mouse_move; // last mouse move position (see OnMotion)
	615	bool m_skipping;
	616	bool m_has_maximized;
	617
	618	double m_dock_constraint_x; // 0.0 .. 1.0; max pct of window width a dock can consume
	619	double m_dock_constraint_y; // 0.0 .. 1.0; max pct of window height a dock can consume
	620
	621	wxFrame* m_hint_wnd; // transparent hint window, if supported by platform
	622	wxTimer m_hint_fadetimer; // transparent fade timer
	623	wxByte m_hint_fadeamt; // transparent fade amount
	624	wxByte m_hint_fademax; // maximum value of hint fade
	625
	626	void* m_reserved;
	627
	628	#ifndef SWIG
	629	DECLARE_EVENT_TABLE()
	630	DECLARE_CLASS(wxAuiManager)
	631	#endif // SWIG
	632	};
	633
	634
	635
	636	// event declarations/classes
	637
	638	class WXDLLIMPEXP_AUI wxAuiManagerEvent : public wxEvent
	639	{
	640	public:
	641	wxAuiManagerEvent(wxEventType type=wxEVT_NULL) : wxEvent(0, type)
	642	{
	643	manager = NULL;
	644	pane = NULL;
	645	button = 0;
	646	veto_flag = false;
	647	canveto_flag = true;
	648	dc = NULL;
	649	}
	650	#ifndef SWIG
	651	wxAuiManagerEvent(const wxAuiManagerEvent& c) : wxEvent(c)
	652	{
	653	manager = c.manager;
	654	pane = c.pane;
	655	button = c.button;
	656	veto_flag = c.veto_flag;
	657	canveto_flag = c.canveto_flag;
	658	dc = c.dc;
	659	}
	660	#endif
	661	wxEvent Clone() const { return new wxAuiManagerEvent(this); }
	662
	663	void SetManager(wxAuiManager* mgr) { manager = mgr; }
	664	void SetPane(wxAuiPaneInfo* p) { pane = p; }
	665	void SetButton(int b) { button = b; }
	666	void SetDC(wxDC* pdc) { dc = pdc; }
	667
	668	wxAuiManager* GetManager() const { return manager; }
	669	wxAuiPaneInfo* GetPane() const { return pane; }
	670	int GetButton() const { return button; }
	671	wxDC* GetDC() const { return dc; }
	672
	673	void Veto(bool veto = true) { veto_flag = veto; }
	674	bool GetVeto() const { return veto_flag; }
	675	void SetCanVeto(bool can_veto) { canveto_flag = can_veto; }
	676	bool CanVeto() const { return canveto_flag && veto_flag; }
	677
	678	public:
	679	wxAuiManager* manager;
	680	wxAuiPaneInfo* pane;
	681	int button;
	682	bool veto_flag;
	683	bool canveto_flag;
	684	wxDC* dc;
	685
	686	#ifndef SWIG
	687	private:
	688	DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxAuiManagerEvent)
	689	#endif
	690	};
	691
	692
	693	class WXDLLIMPEXP_AUI wxAuiDockInfo
	694	{
	695	public:
	696	wxAuiDockInfo()
	697	{
	698	dock_direction = 0;
	699	dock_layer = 0;
	700	dock_row = 0;
	701	size = 0;
	702	min_size = 0;
	703	resizable = true;
	704	fixed = false;
	705	toolbar = false;
	706	reserved1 = false;
	707	}
	708
	709	#ifndef SWIG
	710	wxAuiDockInfo(const wxAuiDockInfo& c)
	711	{
	712	dock_direction = c.dock_direction;
	713	dock_layer = c.dock_layer;
	714	dock_row = c.dock_row;
	715	size = c.size;
	716	min_size = c.min_size;
	717	resizable = c.resizable;
	718	fixed = c.fixed;
	719	toolbar = c.toolbar;
	720	panes = c.panes;
	721	rect = c.rect;
	722	reserved1 = c.reserved1;
	723	}
	724
	725	wxAuiDockInfo& operator=(const wxAuiDockInfo& c)
	726	{
	727	dock_direction = c.dock_direction;
	728	dock_layer = c.dock_layer;
	729	dock_row = c.dock_row;
	730	size = c.size;
	731	min_size = c.min_size;
	732	resizable = c.resizable;
	733	fixed = c.fixed;
	734	toolbar = c.toolbar;
	735	panes = c.panes;
	736	rect = c.rect;
	737	reserved1 = c.reserved1;
	738	return *this;
	739	}
	740	#endif // SWIG
	741
	742	bool IsOk() const { return (dock_direction != 0) ? true : false; }
	743	bool IsHorizontal() const { return (dock_direction == wxAUI_DOCK_TOP \|\|
	744	dock_direction == wxAUI_DOCK_BOTTOM) ? true:false; }
	745	bool IsVertical() const { return (dock_direction == wxAUI_DOCK_LEFT \|\|
	746	dock_direction == wxAUI_DOCK_RIGHT \|\|
	747	dock_direction == wxAUI_DOCK_CENTER) ? true:false; }
	748	public:
	749	wxAuiPaneInfoPtrArray panes; // array of panes
	750	wxRect rect; // current rectangle
	751	int dock_direction; // dock direction (top, bottom, left, right, center)
	752	int dock_layer; // layer number (0 = innermost layer)
	753	int dock_row; // row number on the docking bar (0 = first row)
	754	int size; // size of the dock
	755	int min_size; // minimum size of a dock (0 if there is no min)
	756	bool resizable; // flag indicating whether the dock is resizable
	757	bool toolbar; // flag indicating dock contains only toolbars
	758	bool fixed; // flag indicating that the dock operates on
	759	// absolute coordinates as opposed to proportional
	760	bool reserved1;
	761	};
	762
	763
	764	class WXDLLIMPEXP_AUI wxAuiDockUIPart
	765	{
	766	public:
	767	enum
	768	{
	769	typeCaption,
	770	typeGripper,
	771	typeDock,
	772	typeDockSizer,
	773	typePane,
	774	typePaneSizer,
	775	typeBackground,
	776	typePaneBorder,
	777	typePaneButton
	778	};
	779
	780	int type; // ui part type (see enum above)
	781	int orientation; // orientation (either wxHORIZONTAL or wxVERTICAL)
	782	wxAuiDockInfo* dock; // which dock the item is associated with
	783	wxAuiPaneInfo* pane; // which pane the item is associated with
	784	wxAuiPaneButton* button; // which pane button the item is associated with
	785	wxSizer* cont_sizer; // the part's containing sizer
	786	wxSizerItem* sizer_item; // the sizer item of the part
	787	wxRect rect; // client coord rectangle of the part itself
	788	};
	789
	790
	791	class WXDLLIMPEXP_AUI wxAuiPaneButton
	792	{
	793	public:
	794	int button_id; // id of the button (e.g. buttonClose)
	795	};
	796
	797
	798
	799	#ifndef SWIG
	800	// wx event machinery
	801
	802	BEGIN_DECLARE_EVENT_TYPES()
	803	DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_AUI, wxEVT_AUI_PANE_BUTTON, 0)
	804	DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_AUI, wxEVT_AUI_PANE_CLOSE, 0)
	805	DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_AUI, wxEVT_AUI_PANE_MAXIMIZE, 0)
	806	DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_AUI, wxEVT_AUI_PANE_RESTORE, 0)
	807	DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_AUI, wxEVT_AUI_RENDER, 0)
	808	DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_AUI, wxEVT_AUI_FIND_MANAGER, 0)
	809	END_DECLARE_EVENT_TYPES()
	810
	811	typedef void (wxEvtHandler::*wxAuiManagerEventFunction)(wxAuiManagerEvent&);
	812
	813	#define wxAuiManagerEventHandler(func) \
	814	(wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxAuiManagerEventFunction, &func)
	815
	816	#define EVT_AUI_PANE_BUTTON(func) \
	817	wx__DECLARE_EVT0(wxEVT_AUI_PANE_BUTTON, wxAuiManagerEventHandler(func))
	818	#define EVT_AUI_PANE_CLOSE(func) \
	819	wx__DECLARE_EVT0(wxEVT_AUI_PANE_CLOSE, wxAuiManagerEventHandler(func))
	820	#define EVT_AUI_PANE_MAXIMIZE(func) \
	821	wx__DECLARE_EVT0(wxEVT_AUI_PANE_MAXIMIZE, wxAuiManagerEventHandler(func))
	822	#define EVT_AUI_PANE_RESTORE(func) \
	823	wx__DECLARE_EVT0(wxEVT_AUI_PANE_RESTORE, wxAuiManagerEventHandler(func))
	824	#define EVT_AUI_RENDER(func) \
	825	wx__DECLARE_EVT0(wxEVT_AUI_RENDER, wxAuiManagerEventHandler(func))
	826	#define EVT_AUI_FIND_MANAGER(func) \
	827	wx__DECLARE_EVT0(wxEVT_AUI_FIND_MANAGER, wxAuiManagerEventHandler(func))
	828
	829	#else
	830
	831	%constant wxEventType wxEVT_AUI_PANE_BUTTON;
	832	%constant wxEventType wxEVT_AUI_PANE_CLOSE;
	833	%constant wxEventType wxEVT_AUI_PANE_MAXIMIZE;
	834	%constant wxEventType wxEVT_AUI_PANE_RESTORE;
	835	%constant wxEventType wxEVT_AUI_RENDER;
	836	%constant wxEventType wxEVT_AUI_FIND_MANAGER;
	837
	838	%pythoncode {
	839	EVT_AUI_PANE_BUTTON = wx.PyEventBinder( wxEVT_AUI_PANE_BUTTON )
	840	EVT_AUI_PANE_CLOSE = wx.PyEventBinder( wxEVT_AUI_PANE_CLOSE )
	841	EVT_AUI_PANE_MAXIMIZE = wx.PyEventBinder( wxEVT_AUI_PANE_MAXIMIZE )
	842	EVT_AUI_PANE_RESTORE = wx.PyEventBinder( wxEVT_AUI_PANE_RESTORE )
	843	EVT_AUI_RENDER = wx.PyEventBinder( wxEVT_AUI_RENDER )
	844	EVT_AUI_FIND_MANAGER = wx.PyEventBinder( wxEVT_AUI_FIND_MANAGER )
	845	}
	846	#endif // SWIG
	847
	848	#endif // wxUSE_AUI
	849	#endif //_WX_FRAMEMANAGER_H_
	850