[wxWidgets.git] / contrib / include / wx / ogl / composit.h

/////////////////////////////////////////////////////////////////////////////
// Name:        composit.h
// Purpose:     wxCompositeShape
// Author:      Julian Smart
// Modified by:
// Created:     12/07/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifndef _OGL_COMPOSIT_H_
#define _OGL_COMPOSIT_H_

#ifdef __GNUG__
#pragma interface "composit.h"
#endif

class wxDivisionShape;
class wxOGLConstraint;

/*
 * A composite object is an invisible rectangle surrounding all children
 *
 */

class wxCompositeShape: public wxRectangleShape
{
 DECLARE_DYNAMIC_CLASS(wxCompositeShape)
public:

  wxCompositeShape();
  ~wxCompositeShape();

  void OnDraw(wxDC& dc);
  void OnDrawContents(wxDC& dc);
  void OnErase(wxDC& dc);
  bool OnMovePre(wxDC& dc, double x, double y, double oldX, double oldY, bool display = TRUE);
  void OnDragLeft(bool draw, double x, double y, int keys, int attachment = 0);
  void OnBeginDragLeft(double x, double y, int keys, int attachment = 0);
  void OnEndDragLeft(double x, double y, int keys, int attachment = 0);

  void OnRightClick(double x, double y, int keys, int attachment = 0);

  void SetSize(double w, double h, bool recursive = TRUE);

  // Returns TRUE if it settled down
  bool Recompute();

  // New members
  void AddChild(wxShape *child, wxShape *addAfter = NULL);
  void RemoveChild(wxShape *child);

  wxOGLConstraint *AddConstraint(wxOGLConstraint *constraint);
  wxOGLConstraint *AddConstraint(int type, wxShape *constraining, wxList& constrained);
  wxOGLConstraint *AddConstraint(int type, wxShape *constraining, wxShape *constrained);

  void DeleteConstraint(wxOGLConstraint *constraint);

  // Delete constraints that involve this child.
  void DeleteConstraintsInvolvingChild(wxShape *child);

  // Remove the image from any constraints involving it, but DON'T
  // remove any constraints.
  void RemoveChildFromConstraints(wxShape *child);

  // Find constraint, also returning actual composite the constraint was in,
  // in case it had to find it recursively.
  wxOGLConstraint *FindConstraint(long id, wxCompositeShape **actualComposite = NULL);

  // Returns TRUE if something changed
  bool Constrain();

  // Make this composite into a container by creating one wxDivisionShape
  void MakeContainer();

  // Calculates size and position of composite object based on children
  void CalculateSize();

#ifdef PROLOGIO
  void WriteAttributes(wxExpr *clause);
  void ReadAttributes(wxExpr *clause);
  // In case the object has constraints it needs to read in in a different pass
  void ReadConstraints(wxExpr *clause, wxExprDatabase *database);
#endif
  // Does the copying for this object
  void Copy(wxShape& copy);

  virtual wxDivisionShape *OnCreateDivision();

  // Finds the image used to visualize a container. This is any child
  // of the composite that is not in the divisions list.
  wxShape *FindContainerImage();

  // Returns TRUE if division is a descendant of this container
  bool ContainsDivision(wxDivisionShape *division);

  inline wxList& GetDivisions() const { return (wxList&) m_divisions; }
  inline wxList& GetConstraints() const { return (wxList&) m_constraints; }

protected:
  double             m_oldX;
  double             m_oldY;
  wxList            m_constraints;
  wxList            m_divisions; // In case it's a container
};

/*
 * A division object is a composite with special properties,
 * to be used for containment. It's a subdivision of a container.
 * A containing node image consists of a composite with a main child shape
 * such as rounded rectangle, plus a list of division objects.
 * It needs to be a composite because a division contains pieces
 * of diagram.
 * NOTE a container has at least one wxDivisionShape for consistency.
 * This can be subdivided, so it turns into two objects, then each of
 * these can be subdivided, etc.
 */
#define DIVISION_SIDE_NONE      0
#define DIVISION_SIDE_LEFT      1
#define DIVISION_SIDE_TOP       2
#define DIVISION_SIDE_RIGHT     3
#define DIVISION_SIDE_BOTTOM    4

class wxDivisionShape: public wxCompositeShape
{
 DECLARE_DYNAMIC_CLASS(wxDivisionShape)
 public:

  wxDivisionShape();
  ~wxDivisionShape();

  void OnDraw(wxDC& dc);
  void OnDrawContents(wxDC& dc);
  bool OnMovePre(wxDC& dc, double x, double y, double oldX, double oldY, bool display = TRUE);
  void OnDragLeft(bool draw, double x, double y, int keys, int attachment = 0);
  void OnBeginDragLeft(double x, double y, int keys, int attachment = 0);
  void OnEndDragLeft(double x, double y, int keys, int attachment = 0);

  void OnRightClick(double x, double y, int keys = 0, int attachment = 0);

  // Don't want this kind of composite to resize its subdiagrams, so
  // override composite's SetSize.
  void SetSize(double w, double h, bool recursive = TRUE);

  // Similarly for calculating size: it's fixed at whatever SetSize
  // set it to, not in terms of children.
  void CalculateSize();

  void MakeControlPoints();
  void ResetControlPoints();
  void MakeMandatoryControlPoints();
  void ResetMandatoryControlPoints();

#ifdef PROLOGIO
  void WriteAttributes(wxExpr *clause);
  void ReadAttributes(wxExpr *clause);
#endif
  // Does the copying for this object
  void Copy(wxShape& copy);

  // Divide horizontally (wxHORIZONTAL) or vertically (wxVERTICAL)
  bool Divide(int direction);

  // Resize adjoining divisions at the given side. If test is TRUE,
  // just see whether it's possible for each adjoining region,
  // returning FALSE if it's not.
  bool ResizeAdjoining(int side, double newPos, bool test);

  // Adjust a side, returning FALSE if it's not physically possible.
  bool AdjustLeft(double left, bool test);
  bool AdjustTop(double top, bool test);
  bool AdjustRight(double right, bool test);
  bool AdjustBottom(double bottom, bool test);

  // Edit style of left or top side
  void EditEdge(int side);

  // Popup menu
  void PopupMenu(double x, double y);

  inline void SetLeftSide(wxDivisionShape *shape) { m_leftSide = shape; }
  inline void SetTopSide(wxDivisionShape *shape) { m_topSide = shape; }
  inline void SetRightSide(wxDivisionShape *shape) { m_rightSide = shape; }
  inline void SetBottomSide(wxDivisionShape *shape) { m_bottomSide = shape; }
  inline wxDivisionShape *GetLeftSide() const { return m_leftSide; }
  inline wxDivisionShape *GetTopSide() const { return m_topSide; }
  inline wxDivisionShape *GetRightSide() const { return m_rightSide; }
  inline wxDivisionShape *GetBottomSide() const { return m_bottomSide; }

  inline void SetHandleSide(int side) { m_handleSide = side; }
  inline int GetHandleSide() const { return m_handleSide; }

  inline void SetLeftSidePen(wxPen *pen) { m_leftSidePen = pen; }
  inline wxPen *GetLeftSidePen() const { return m_leftSidePen; }
  inline void SetTopSidePen(wxPen *pen) { m_topSidePen = pen; }
  inline wxPen *GetTopSidePen() const { return m_topSidePen; }

  void SetLeftSideColour(const wxString& colour);
  void SetTopSideColour(const wxString& colour);
  void SetLeftSideStyle(const wxString& style);
  void SetTopSideStyle(const wxString& style);

  inline wxString GetLeftSideColour() const { return m_leftSideColour; }
  inline wxString GetTopSideColour() const { return m_topSideColour; }
  inline wxString GetLeftSideStyle() const { return m_leftSideStyle; }
  inline wxString GetTopSideStyle() const { return m_topSideStyle; }

 protected:
  // Adjoining divisions. NULL indicates edge
  // of container, and that side shouldn't be
  // drawn.
  wxDivisionShape*      m_leftSide;
  wxDivisionShape*      m_rightSide;
  wxDivisionShape*      m_topSide;
  wxDivisionShape*      m_bottomSide;

  int                   m_handleSide;       // Side at which handle is legal

  wxPen*                m_leftSidePen;
  wxPen*                m_topSidePen;
  wxString              m_leftSideColour;
  wxString              m_topSideColour;
  wxString              m_leftSideStyle;
  wxString              m_topSideStyle;
};


#define DIVISION_MENU_SPLIT_HORIZONTALLY    1
#define DIVISION_MENU_SPLIT_VERTICALLY      2
#define DIVISION_MENU_EDIT_LEFT_EDGE        3
#define DIVISION_MENU_EDIT_TOP_EDGE         4
#define DIVISION_MENU_EDIT_RIGHT_EDGE       5
#define DIVISION_MENU_EDIT_BOTTOM_EDGE      6
#define DIVISION_MENU_DELETE_ALL            7

#endif
 // _OGL_COMPOSIT_H_
Commit	Line	Data
1fc25a89 JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: composit.h
	3	// Purpose: wxCompositeShape
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 12/07/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifndef _OGL_COMPOSIT_H_
	13	#define _OGL_COMPOSIT_H_
	14
	15	#ifdef __GNUG__
	16	#pragma interface "composit.h"
	17	#endif
	18
	19	class wxDivisionShape;
	20	class wxOGLConstraint;
	21
	22	/*
	23	* A composite object is an invisible rectangle surrounding all children
	24	*
	25	*/
	26
	27	class wxCompositeShape: public wxRectangleShape
	28	{
	29	DECLARE_DYNAMIC_CLASS(wxCompositeShape)
	30	public:
	31
	32	wxCompositeShape();
	33	~wxCompositeShape();
	34
	35	void OnDraw(wxDC& dc);
	36	void OnDrawContents(wxDC& dc);
	37	void OnErase(wxDC& dc);
	38	bool OnMovePre(wxDC& dc, double x, double y, double oldX, double oldY, bool display = TRUE);
	39	void OnDragLeft(bool draw, double x, double y, int keys, int attachment = 0);
	40	void OnBeginDragLeft(double x, double y, int keys, int attachment = 0);
	41	void OnEndDragLeft(double x, double y, int keys, int attachment = 0);
	42
	43	void OnRightClick(double x, double y, int keys, int attachment = 0);
	44
	45	void SetSize(double w, double h, bool recursive = TRUE);
	46
	47	// Returns TRUE if it settled down
	48	bool Recompute();
	49
	50	// New members
	51	void AddChild(wxShape child, wxShape addAfter = NULL);
	52	void RemoveChild(wxShape *child);
	53
	54	wxOGLConstraint AddConstraint(wxOGLConstraint constraint);
	55	wxOGLConstraint AddConstraint(int type, wxShape constraining, wxList& constrained);
	56	wxOGLConstraint AddConstraint(int type, wxShape constraining, wxShape *constrained);
	57
	58	void DeleteConstraint(wxOGLConstraint *constraint);
	59
	60	// Delete constraints that involve this child.
	61	void DeleteConstraintsInvolvingChild(wxShape *child);
	62
	63	// Remove the image from any constraints involving it, but DON'T
	64	// remove any constraints.
65	void RemoveChildFromConstraints(wxShape *child);
66
67	// Find constraint, also returning actual composite the constraint was in,
68	// in case it had to find it recursively.
69	wxOGLConstraint FindConstraint(long id, wxCompositeShape *actualComposite = NULL);
70
71	// Returns TRUE if something changed
72	bool Constrain();
73
74	// Make this composite into a container by creating one wxDivisionShape
75	void MakeContainer();
76
77	// Calculates size and position of composite object based on children
78	void CalculateSize();
79
80	#ifdef PROLOGIO
81	void WriteAttributes(wxExpr *clause);
82	void ReadAttributes(wxExpr *clause);
83	// In case the object has constraints it needs to read in in a different pass
84	void ReadConstraints(wxExpr clause, wxExprDatabase database);
85	#endif
86	// Does the copying for this object
87	void Copy(wxShape& copy);
88
89	virtual wxDivisionShape *OnCreateDivision();
90
91	// Finds the image used to visualize a container. This is any child
92	// of the composite that is not in the divisions list.
93	wxShape *FindContainerImage();
94
95	// Returns TRUE if division is a descendant of this container
96	bool ContainsDivision(wxDivisionShape *division);
97
98	inline wxList& GetDivisions() const { return (wxList&) m_divisions; }
99	inline wxList& GetConstraints() const { return (wxList&) m_constraints; }
100
101	protected:
102	double m_oldX;
103	double m_oldY;
104	wxList m_constraints;
105	wxList m_divisions; // In case it's a container
106	};
107
108	/*
109	* A division object is a composite with special properties,
110	* to be used for containment. It's a subdivision of a container.
111	* A containing node image consists of a composite with a main child shape
112	* such as rounded rectangle, plus a list of division objects.
113	* It needs to be a composite because a division contains pieces
114	* of diagram.
115	* NOTE a container has at least one wxDivisionShape for consistency.
116	* This can be subdivided, so it turns into two objects, then each of
117	* these can be subdivided, etc.
118	*/
119	#define DIVISION_SIDE_NONE 0
120	#define DIVISION_SIDE_LEFT 1
121	#define DIVISION_SIDE_TOP 2
122	#define DIVISION_SIDE_RIGHT 3
123	#define DIVISION_SIDE_BOTTOM 4
124
125	class wxDivisionShape: public wxCompositeShape
126	{
127	DECLARE_DYNAMIC_CLASS(wxDivisionShape)
128	public:
129
130	wxDivisionShape();
131	~wxDivisionShape();
132
133	void OnDraw(wxDC& dc);
134	void OnDrawContents(wxDC& dc);
135	bool OnMovePre(wxDC& dc, double x, double y, double oldX, double oldY, bool display = TRUE);
136	void OnDragLeft(bool draw, double x, double y, int keys, int attachment = 0);
137	void OnBeginDragLeft(double x, double y, int keys, int attachment = 0);
138	void OnEndDragLeft(double x, double y, int keys, int attachment = 0);
139
140	void OnRightClick(double x, double y, int keys = 0, int attachment = 0);
141
142	// Don't want this kind of composite to resize its subdiagrams, so
143	// override composite's SetSize.
144	void SetSize(double w, double h, bool recursive = TRUE);
145
146	// Similarly for calculating size: it's fixed at whatever SetSize
147	// set it to, not in terms of children.
148	void CalculateSize();
149
150	void MakeControlPoints();
151	void ResetControlPoints();
152	void MakeMandatoryControlPoints();
153	void ResetMandatoryControlPoints();
154
155	#ifdef PROLOGIO
156	void WriteAttributes(wxExpr *clause);
157	void ReadAttributes(wxExpr *clause);
158	#endif
159	// Does the copying for this object
160	void Copy(wxShape& copy);
161
162	// Divide horizontally (wxHORIZONTAL) or vertically (wxVERTICAL)
163	bool Divide(int direction);
164
165	// Resize adjoining divisions at the given side. If test is TRUE,
166	// just see whether it's possible for each adjoining region,
167	// returning FALSE if it's not.
168	bool ResizeAdjoining(int side, double newPos, bool test);
169
170	// Adjust a side, returning FALSE if it's not physically possible.
171	bool AdjustLeft(double left, bool test);
172	bool AdjustTop(double top, bool test);
173	bool AdjustRight(double right, bool test);
174	bool AdjustBottom(double bottom, bool test);
175
176	// Edit style of left or top side
177	void EditEdge(int side);
178
179	// Popup menu
180	void PopupMenu(double x, double y);
181
182	inline void SetLeftSide(wxDivisionShape *shape) { m_leftSide = shape; }
183	inline void SetTopSide(wxDivisionShape *shape) { m_topSide = shape; }
184	inline void SetRightSide(wxDivisionShape *shape) { m_rightSide = shape; }
185	inline void SetBottomSide(wxDivisionShape *shape) { m_bottomSide = shape; }
186	inline wxDivisionShape *GetLeftSide() const { return m_leftSide; }
187	inline wxDivisionShape *GetTopSide() const { return m_topSide; }
188	inline wxDivisionShape *GetRightSide() const { return m_rightSide; }
189	inline wxDivisionShape *GetBottomSide() const { return m_bottomSide; }
190
191	inline void SetHandleSide(int side) { m_handleSide = side; }
192	inline int GetHandleSide() const { return m_handleSide; }
193
194	inline void SetLeftSidePen(wxPen *pen) { m_leftSidePen = pen; }
195	inline wxPen *GetLeftSidePen() const { return m_leftSidePen; }
196	inline void SetTopSidePen(wxPen *pen) { m_topSidePen = pen; }
197	inline wxPen *GetTopSidePen() const { return m_topSidePen; }
198
199	void SetLeftSideColour(const wxString& colour);
200	void SetTopSideColour(const wxString& colour);
201	void SetLeftSideStyle(const wxString& style);
202	void SetTopSideStyle(const wxString& style);
203
204	inline wxString GetLeftSideColour() const { return m_leftSideColour; }
205	inline wxString GetTopSideColour() const { return m_topSideColour; }
206	inline wxString GetLeftSideStyle() const { return m_leftSideStyle; }
207	inline wxString GetTopSideStyle() const { return m_topSideStyle; }
208
209	protected:
210	// Adjoining divisions. NULL indicates edge
211	// of container, and that side shouldn't be
212	// drawn.
213	wxDivisionShape* m_leftSide;
214	wxDivisionShape* m_rightSide;
215	wxDivisionShape* m_topSide;
216	wxDivisionShape* m_bottomSide;
217
218	int m_handleSide; // Side at which handle is legal
219
220	wxPen* m_leftSidePen;
221	wxPen* m_topSidePen;
222	wxString m_leftSideColour;
223	wxString m_topSideColour;
224	wxString m_leftSideStyle;
225	wxString m_topSideStyle;
226	};
227
228
229	#define DIVISION_MENU_SPLIT_HORIZONTALLY 1
230	#define DIVISION_MENU_SPLIT_VERTICALLY 2
231	#define DIVISION_MENU_EDIT_LEFT_EDGE 3
232	#define DIVISION_MENU_EDIT_TOP_EDGE 4
233	#define DIVISION_MENU_EDIT_RIGHT_EDGE 5
234	#define DIVISION_MENU_EDIT_BOTTOM_EDGE 6
235	#define DIVISION_MENU_DELETE_ALL 7
236
237	#endif
238	// _OGL_COMPOSIT_H_