[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_

#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "composit.h"
#endif


class WXDLLIMPEXP_OGL wxDivisionShape;
class WXDLLIMPEXP_OGL wxOGLConstraint;

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

class WXDLLIMPEXP_OGL 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();

#if wxUSE_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 WXDLLIMPEXP_OGL 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();

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