[wxWidgets.git] / utils / ogl / src / 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;
};

extern wxMenu *oglPopupDivisionMenu;
extern void oglGraphicsDivisionMenuProc(wxMenu& menu, wxCommandEvent& event);

#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
0fc1a713 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;
6f5f3ca0	20	class wxOGLConstraint;
0fc1a713 JS	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);
42cfaf8c JS	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);
0fc1a713	42
42cfaf8c	43	void OnRightClick(double x, double y, int keys, int attachment = 0);
0fc1a713	44
42cfaf8c	45	void SetSize(double w, double h, bool recursive = TRUE);
0fc1a713 JS	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
6f5f3ca0 JS	54	wxOGLConstraint AddConstraint(wxOGLConstraint constraint);
	55	wxOGLConstraint AddConstraint(int type, wxShape constraining, wxList& constrained);
	56	wxOGLConstraint AddConstraint(int type, wxShape constraining, wxShape *constrained);
0fc1a713	57
6f5f3ca0	58	void DeleteConstraint(wxOGLConstraint *constraint);
0fc1a713 JS	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.
6f5f3ca0	69	wxOGLConstraint FindConstraint(long id, wxCompositeShape *actualComposite = NULL);
0fc1a713 JS	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
6f5f3ca0 JS	81	void WriteAttributes(wxExpr *clause);
6f5f3ca0 JS	82	void ReadAttributes(wxExpr *clause);
0fc1a713 JS	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
2bb0cd28	87	void Copy(wxShape& copy);
0fc1a713 JS	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:
42cfaf8c JS	102	double m_oldX;
42cfaf8c JS	103	double m_oldY;
0fc1a713 JS	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);
42cfaf8c JS	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);
0fc1a713	139
42cfaf8c	140	void OnRightClick(double x, double y, int keys = 0, int attachment = 0);
0fc1a713 JS	141
	142	// Don't want this kind of composite to resize its subdiagrams, so
	143	// override composite's SetSize.
42cfaf8c	144	void SetSize(double w, double h, bool recursive = TRUE);
0fc1a713 JS	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
6f5f3ca0 JS	156	void WriteAttributes(wxExpr *clause);
6f5f3ca0 JS	157	void ReadAttributes(wxExpr *clause);
0fc1a713 JS	158	#endif
0fc1a713 JS	159	// Does the copying for this object
2bb0cd28	160	void Copy(wxShape& copy);
0fc1a713 JS	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.
42cfaf8c	168	bool ResizeAdjoining(int side, double newPos, bool test);
0fc1a713 JS	169
0fc1a713 JS	170	// Adjust a side, returning FALSE if it's not physically possible.
42cfaf8c JS	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);
0fc1a713 JS	175
	176	// Edit style of left or top side
	177	void EditEdge(int side);
	178
	179	// Popup menu
42cfaf8c JS	180	void PopupMenu(double x, double y);
42cfaf8c JS	181
0fc1a713 JS	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	extern wxMenu *oglPopupDivisionMenu;
	229	extern void oglGraphicsDivisionMenuProc(wxMenu& menu, wxCommandEvent& event);
	230
	231	#define DIVISION_MENU_SPLIT_HORIZONTALLY 1
	232	#define DIVISION_MENU_SPLIT_VERTICALLY 2
	233	#define DIVISION_MENU_EDIT_LEFT_EDGE 3
	234	#define DIVISION_MENU_EDIT_TOP_EDGE 4
	235	#define DIVISION_MENU_EDIT_RIGHT_EDGE 5
	236	#define DIVISION_MENU_EDIT_BOTTOM_EDGE 6
	237	#define DIVISION_MENU_DELETE_ALL 7
	238
	239	#endif
	240	// _OGL_COMPOSIT_H_