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

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

#ifndef _OGL_LINES_H_
#define _OGL_LINES_H_


class WXDLLIMPEXP_OGL wxLabelShape;
class WXDLLIMPEXP_OGL wxPseudoMetaFile;
class WXDLLIMPEXP_OGL wxLineControlPoint;
/*
 * Arcs with multiple arrowheads
 *
 */

// Types of arrowhead
// (i) Built-in
#define ARROW_HOLLOW_CIRCLE   1
#define ARROW_FILLED_CIRCLE   2
#define ARROW_ARROW           3
#define ARROW_SINGLE_OBLIQUE  4
#define ARROW_DOUBLE_OBLIQUE  5
// (ii) Custom
#define ARROW_METAFILE        20

// Position of arrow on line
#define ARROW_POSITION_START  0
#define ARROW_POSITION_END    1
#define ARROW_POSITION_MIDDLE 2

// Line alignment flags
// Vertical by default
#define LINE_ALIGNMENT_HORIZ              1
#define LINE_ALIGNMENT_VERT               0
#define LINE_ALIGNMENT_TO_NEXT_HANDLE     2
#define LINE_ALIGNMENT_NONE               0

class WXDLLIMPEXP_OGL wxArrowHead: public wxObject
{
 DECLARE_DYNAMIC_CLASS(wxArrowHead)

 public:
  wxArrowHead(WXTYPE type = 0, int end = 0, double size = 0.0, double dist = 0.0, const wxString& name = wxEmptyString, wxPseudoMetaFile *mf = NULL,
            long arrowId = -1);
  ~wxArrowHead();
  wxArrowHead(wxArrowHead& toCopy);

  inline WXTYPE _GetType() const { return m_arrowType; }
  inline int GetPosition() const { return m_arrowEnd; }
  inline void SetPosition(int pos) { m_arrowEnd = pos; }
  inline double GetXOffset() const { return m_xOffset; }
  inline double GetYOffset() const { return m_yOffset; }
  inline double GetSpacing() const { return m_spacing; }
  inline double GetSize() const { return m_arrowSize; }
  inline wxString GetName() const { return m_arrowName; }
  inline void SetXOffset(double x) { m_xOffset = x; }
  inline void SetYOffset(double y) { m_yOffset = y; }
  inline wxPseudoMetaFile *GetMetaFile() const { return m_metaFile; }
  inline long GetId() const { return m_id; }
  inline int GetArrowEnd() const { return m_arrowEnd; }
  inline double GetArrowSize() const { return m_arrowSize; }
  void SetSize(double size);
  inline void SetSpacing(double sp) { m_spacing = sp; }

 protected:
  WXTYPE            m_arrowType;
  int               m_arrowEnd;         // Position on line
  double             m_xOffset;          // Distance from arc start or end, w.r.t. point on arrowhead
                                        // nearest start or end. If zero, use default spacing.
  double             m_yOffset;          // vertical offset (w.r.t. a horizontal line). Normally zero.
  double             m_spacing;          // Spacing from the last arrowhead
  double             m_arrowSize;        // Length of arrowhead
  wxString          m_arrowName;        // Name of arrow
  bool              m_saveToFile;       // true if we want to save custom arrowheads to file.
  wxPseudoMetaFile* m_metaFile;         // Pseudo metafile if this is a custom arrowhead
  long              m_id;               // identifier
};

// Line object
class WXDLLIMPEXP_OGL wxLabelShape;
class WXDLLIMPEXP_OGL wxLineShape: public wxShape
{
 DECLARE_DYNAMIC_CLASS(wxLineShape)

 public:
  wxLineShape();
  ~wxLineShape();

  // Called when a connected object has moved, to move the link to
  // correct position
  // moveControlPoints must be disabled when a control point is being
  // dragged.
  void OnMoveLink(wxDC& dc, bool moveControlPoints = true);
  bool OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = true);
  void OnDraw(wxDC& dc);
  void OnDrawContents(wxDC& dc);
  void OnDrawControlPoints(wxDC& dc);
  void OnEraseControlPoints(wxDC& dc);
  void OnErase(wxDC& dc);
  virtual bool OnMoveControlPoint(int WXUNUSED(which), double WXUNUSED(x), double WXUNUSED(y)) { return false; }
  virtual bool OnMoveMiddleControlPoint(wxDC& dc, wxLineControlPoint* lpt, const wxRealPoint& pt);
  virtual bool OnLabelMovePre(wxDC& dc, wxLabelShape* labelShape, double x, double y, double old_x, double old_y, bool display);
  void OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
  void GetBoundingBoxMin(double *w, double *h);
  void FormatText(wxDC& dc, const wxString& s, int regionId = 0);
  virtual void SetEnds(double x1, double y1, double x2, double y2);
  virtual void GetEnds(double *x1, double *y1, double *x2, double *y2);
  inline virtual wxShape *GetFrom() { return m_from; }
  inline virtual wxShape *GetTo() { return m_to; }
  inline virtual int GetAttachmentFrom() { return m_attachmentFrom; }
  inline virtual int GetAttachmentTo() { return m_attachmentTo; }

  virtual void SetFrom(wxShape *object);
  virtual void SetTo(wxShape *object);
  virtual void DrawArrows(wxDC& dc);

  // Finds the x, y points at the two ends of the line.
  // This function can be used by e.g. line-routing routines to
  // get the actual points on the two node images where the lines will be drawn
  // to/from.
  void FindLineEndPoints(double *fromX, double *fromY, double *toX, double *toY);

  // Format one region at this position
  void DrawRegion(wxDC& dc, wxShapeRegion *region, double x, double y);

  // Erase one region at this position
  void EraseRegion(wxDC& dc, wxShapeRegion *region, double x, double y);

  // Get the reference point for a label. Region x and y
  // are offsets from this.
  // position is 0 (middle), 1 (start), 2 (end)
  void GetLabelPosition(int position, double *x, double *y);

  // Can override this to create a different class of label shape
  virtual wxLabelShape* OnCreateLabelShape(wxLineShape *parent = NULL, wxShapeRegion *region = NULL, double w = 0.0, double h = 0.0);

  // Straighten verticals and horizontals
  virtual void Straighten(wxDC* dc = NULL);

  // Not implemented
  inline void SetMaintainStraightLines(bool flag) { m_maintainStraightLines = flag; }
  inline bool GetMaintainStraightLines() const { return m_maintainStraightLines; }

  // Make handle control points
  void MakeControlPoints();
  void ResetControlPoints();

  // Make a given number of control points
  virtual void MakeLineControlPoints(int n);
  virtual wxNode *InsertLineControlPoint(wxDC* dc);
  virtual bool DeleteLineControlPoint();
  virtual void Initialise();
  inline wxList *GetLineControlPoints() { return m_lineControlPoints; }

  // Override dragging behaviour - don't want to be able to drag lines!
  void OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
  void OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
  void OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);

  // Control points ('handles') redirect control to the actual shape, to make it easier
  // to override sizing behaviour.
  virtual void OnSizingDragLeft(wxControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
  virtual void OnSizingBeginDragLeft(wxControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
  virtual void OnSizingEndDragLeft(wxControlPoint* pt, double x, double y, int keys=0, int attachment = 0);

  // Override select, to create/delete temporary label-moving objects
  void Select(bool select = true, wxDC* dc = NULL);

  // Set to spline (true) or line (false)
  inline void SetSpline(bool spl) { m_isSpline = spl; }
  inline bool IsSpline() const { return m_isSpline; }

  void Unlink();
  void SetAttachments(int from_attach, int to_attach);
  inline void SetAttachmentFrom(int attach) { m_attachmentFrom = attach; }
  inline void SetAttachmentTo(int attach) { m_attachmentTo = attach; }

  bool HitTest(double x, double y, int *attachment, double *distance);

#if wxUSE_PROLOGIO
  // I/O
  virtual void WriteAttributes(wxExpr *clause);
  virtual void ReadAttributes(wxExpr *clause);
#endif

  virtual void FindNth(wxShape *image, int *nth, int *no_arcs, bool incoming);

  // Find which position we're talking about at this (x, y).
  // Returns ARROW_POSITION_START, ARROW_POSITION_MIDDLE, ARROW_POSITION_END
  int FindLinePosition(double x, double y);

  // This is really to distinguish between lines and other images.
  // For lines, want to pass drag to canvas, since lines tend to prevent
  // dragging on a canvas (they get in the way.)
  virtual bool Draggable() const { return false; }

  // Does the copying for this object
  void Copy(wxShape& copy);

  // Add an arrowhead.
  wxArrowHead *AddArrow(WXTYPE type, int end = ARROW_POSITION_END,
                        double arrowSize = 10.0, double xOffset = 0.0,
                        const wxString& name = wxEmptyString,
                        wxPseudoMetaFile *mf = NULL, long arrowId = -1);

  // Add an arrowhead in the position indicated by the reference
  // list of arrowheads, which contains all legal arrowheads for this
  // line, in the correct order.
  // E.g. reference list:      a b c d e
  //      Current line list:   a d
  // Add c, then line list is: a c d
  // If no legal arrowhead position, return false.
  // Assume reference list is for one end only, since it potentially defines
  // the ordering for any one of the 3 positions. So we don't check
  // the reference list for arrowhead position.
  bool AddArrowOrdered(wxArrowHead *arrow, wxList& referenceList, int end);

  // Delete arrowhead(s)
  void ClearArrowsAtPosition(int end = -1);
  bool ClearArrow(const wxString& name);
  wxArrowHead *FindArrowHead(int position, const wxString& name);
  wxArrowHead *FindArrowHead(long arrowId);
  bool DeleteArrowHead(int position, const wxString& name);
  bool DeleteArrowHead(long arrowId);
  void DrawArrow(wxDC& dc, wxArrowHead *arrow, double xOffset, bool proportionalOffset);
  inline void SetIgnoreOffsets(bool ignore) { m_ignoreArrowOffsets = ignore; }
  inline wxList& GetArrows() const { return (wxList&) m_arcArrows; }

  // Find horizontal width for drawing a line with
  // arrows in minimum space. Assume arrows at
  // END only
  double FindMinimumWidth();

  // Set alignment flags. ALIGNMENT NOT IMPLEMENTED.
  void SetAlignmentOrientation(bool isEnd, bool isHoriz);
  void SetAlignmentType(bool isEnd, int alignType);
  bool GetAlignmentOrientation(bool isEnd);
  int GetAlignmentType(bool isEnd);
  int GetAlignmentStart() const { return m_alignmentStart; }
  int GetAlignmentEnd() const { return m_alignmentEnd; }

  // Find next control point in line after the start/end point
  // (depending on whether the node object is at start or end)
  wxRealPoint *GetNextControlPoint(wxShape *nodeObject);
  inline bool IsEnd(wxShape *nodeObject) const { return (m_to == nodeObject); }

private:
  bool              m_erasing;              // flag to say whether we're erasing or drawing
                                            // this line (really so metafiles can draw a
                                            // blank rectangle)
  bool              m_ignoreArrowOffsets;   // Don't always want to draw arrowhead offsets
                                            // because they may not work on tool palettes (for example)
  bool              m_isSpline;
  bool              m_maintainStraightLines;

protected:
  // Temporary list of line segment orientations
  // so we know what direction the line is supposed to be dog-legging
  // in. The values are integer: 0 for vertical, 1 for horizontal.
  wxList            m_lineOrientations;

  // Temporary pointers for start, middle and end label editing objects
  // (active only when the line is selected)
  wxLabelShape*     m_labelObjects[3];

  // These define the segmented line - not to be confused with temporary control
  // points which appear when object is selected (although in this case they'll
  // probably be the same)
  wxList*           m_lineControlPoints;

  double            m_arrowSpacing; // Separation between adjacent arrows

  wxShape*          m_to;
  wxShape*          m_from;

  int               m_attachmentTo;   // Attachment point at one end
  int               m_attachmentFrom; // Attachment point at other end

  // Alignment flags
  int               m_alignmentStart;
  int               m_alignmentEnd;

  wxList            m_arcArrows;

};

#endif
    // _OGL_LINES_H_
Commit	Line	Data
1fc25a89 JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: lines.h
	3	// Purpose: wxLineShape
	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_LINES_H_
	13	#define _OGL_LINES_H_
	14
5f331691 RD	15
	16	class WXDLLIMPEXP_OGL wxLabelShape;
	17	class WXDLLIMPEXP_OGL wxPseudoMetaFile;
	18	class WXDLLIMPEXP_OGL wxLineControlPoint;
1fc25a89 JS	19	/*
	20	* Arcs with multiple arrowheads
	21	*
	22	*/
	23
	24	// Types of arrowhead
	25	// (i) Built-in
	26	#define ARROW_HOLLOW_CIRCLE 1
	27	#define ARROW_FILLED_CIRCLE 2
	28	#define ARROW_ARROW 3
	29	#define ARROW_SINGLE_OBLIQUE 4
	30	#define ARROW_DOUBLE_OBLIQUE 5
	31	// (ii) Custom
	32	#define ARROW_METAFILE 20
	33
	34	// Position of arrow on line
	35	#define ARROW_POSITION_START 0
	36	#define ARROW_POSITION_END 1
	37	#define ARROW_POSITION_MIDDLE 2
	38
	39	// Line alignment flags
	40	// Vertical by default
	41	#define LINE_ALIGNMENT_HORIZ 1
	42	#define LINE_ALIGNMENT_VERT 0
	43	#define LINE_ALIGNMENT_TO_NEXT_HANDLE 2
	44	#define LINE_ALIGNMENT_NONE 0
	45
5f331691	46	class WXDLLIMPEXP_OGL wxArrowHead: public wxObject
1fc25a89 JS	47	{
	48	DECLARE_DYNAMIC_CLASS(wxArrowHead)
	49
	50	public:
9e053640	51	wxArrowHead(WXTYPE type = 0, int end = 0, double size = 0.0, double dist = 0.0, const wxString& name = wxEmptyString, wxPseudoMetaFile *mf = NULL,
1fc25a89 JS	52	long arrowId = -1);
	53	~wxArrowHead();
	54	wxArrowHead(wxArrowHead& toCopy);
	55
	56	inline WXTYPE _GetType() const { return m_arrowType; }
	57	inline int GetPosition() const { return m_arrowEnd; }
	58	inline void SetPosition(int pos) { m_arrowEnd = pos; }
	59	inline double GetXOffset() const { return m_xOffset; }
	60	inline double GetYOffset() const { return m_yOffset; }
	61	inline double GetSpacing() const { return m_spacing; }
	62	inline double GetSize() const { return m_arrowSize; }
	63	inline wxString GetName() const { return m_arrowName; }
	64	inline void SetXOffset(double x) { m_xOffset = x; }
	65	inline void SetYOffset(double y) { m_yOffset = y; }
	66	inline wxPseudoMetaFile *GetMetaFile() const { return m_metaFile; }
	67	inline long GetId() const { return m_id; }
	68	inline int GetArrowEnd() const { return m_arrowEnd; }
	69	inline double GetArrowSize() const { return m_arrowSize; }
	70	void SetSize(double size);
	71	inline void SetSpacing(double sp) { m_spacing = sp; }
	72
	73	protected:
	74	WXTYPE m_arrowType;
	75	int m_arrowEnd; // Position on line
	76	double m_xOffset; // Distance from arc start or end, w.r.t. point on arrowhead
	77	// nearest start or end. If zero, use default spacing.
	78	double m_yOffset; // vertical offset (w.r.t. a horizontal line). Normally zero.
	79	double m_spacing; // Spacing from the last arrowhead
	80	double m_arrowSize; // Length of arrowhead
	81	wxString m_arrowName; // Name of arrow
2ba06d5a	82	bool m_saveToFile; // true if we want to save custom arrowheads to file.
1fc25a89 JS	83	wxPseudoMetaFile* m_metaFile; // Pseudo metafile if this is a custom arrowhead
	84	long m_id; // identifier
	85	};
	86
	87	// Line object
5f331691 RD	88	class WXDLLIMPEXP_OGL wxLabelShape;
5f331691 RD	89	class WXDLLIMPEXP_OGL wxLineShape: public wxShape
1fc25a89 JS	90	{
	91	DECLARE_DYNAMIC_CLASS(wxLineShape)
	92
	93	public:
	94	wxLineShape();
	95	~wxLineShape();
	96
	97	// Called when a connected object has moved, to move the link to
	98	// correct position
	99	// moveControlPoints must be disabled when a control point is being
	100	// dragged.
2ba06d5a WS	101	void OnMoveLink(wxDC& dc, bool moveControlPoints = true);
2ba06d5a WS	102	bool OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = true);
1fc25a89 JS	103	void OnDraw(wxDC& dc);
	104	void OnDrawContents(wxDC& dc);
	105	void OnDrawControlPoints(wxDC& dc);
	106	void OnEraseControlPoints(wxDC& dc);
	107	void OnErase(wxDC& dc);
2ba06d5a	108	virtual bool OnMoveControlPoint(int WXUNUSED(which), double WXUNUSED(x), double WXUNUSED(y)) { return false; }
1fc25a89 JS	109	virtual bool OnMoveMiddleControlPoint(wxDC& dc, wxLineControlPoint* lpt, const wxRealPoint& pt);
	110	virtual bool OnLabelMovePre(wxDC& dc, wxLabelShape* labelShape, double x, double y, double old_x, double old_y, bool display);
	111	void OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
	112	void GetBoundingBoxMin(double w, double h);
	113	void FormatText(wxDC& dc, const wxString& s, int regionId = 0);
	114	virtual void SetEnds(double x1, double y1, double x2, double y2);
	115	virtual void GetEnds(double x1, double y1, double x2, double y2);
	116	inline virtual wxShape *GetFrom() { return m_from; }
	117	inline virtual wxShape *GetTo() { return m_to; }
	118	inline virtual int GetAttachmentFrom() { return m_attachmentFrom; }
	119	inline virtual int GetAttachmentTo() { return m_attachmentTo; }
	120
	121	virtual void SetFrom(wxShape *object);
	122	virtual void SetTo(wxShape *object);
	123	virtual void DrawArrows(wxDC& dc);
	124
	125	// Finds the x, y points at the two ends of the line.
	126	// This function can be used by e.g. line-routing routines to
	127	// get the actual points on the two node images where the lines will be drawn
	128	// to/from.
	129	void FindLineEndPoints(double fromX, double fromY, double toX, double toY);
	130
	131	// Format one region at this position
	132	void DrawRegion(wxDC& dc, wxShapeRegion *region, double x, double y);
	133
	134	// Erase one region at this position
	135	void EraseRegion(wxDC& dc, wxShapeRegion *region, double x, double y);
	136
	137	// Get the reference point for a label. Region x and y
	138	// are offsets from this.
	139	// position is 0 (middle), 1 (start), 2 (end)
	140	void GetLabelPosition(int position, double x, double y);
	141
	142	// Can override this to create a different class of label shape
	143	virtual wxLabelShape* OnCreateLabelShape(wxLineShape parent = NULL, wxShapeRegion region = NULL, double w = 0.0, double h = 0.0);
	144
	145	// Straighten verticals and horizontals
	146	virtual void Straighten(wxDC* dc = NULL);
	147
	148	// Not implemented
	149	inline void SetMaintainStraightLines(bool flag) { m_maintainStraightLines = flag; }
	150	inline bool GetMaintainStraightLines() const { return m_maintainStraightLines; }
	151
	152	// Make handle control points
	153	void MakeControlPoints();
	154	void ResetControlPoints();
	155
	156	// Make a given number of control points
	157	virtual void MakeLineControlPoints(int n);
	158	virtual wxNode InsertLineControlPoint(wxDC dc);
	159	virtual bool DeleteLineControlPoint();
	160	virtual void Initialise();
	161	inline wxList *GetLineControlPoints() { return m_lineControlPoints; }
	162
	163	// Override dragging behaviour - don't want to be able to drag lines!
	164	void OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
	165	void OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
	166	void OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
	167
	168	// Control points ('handles') redirect control to the actual shape, to make it easier
	169	// to override sizing behaviour.
	170	virtual void OnSizingDragLeft(wxControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
	171	virtual void OnSizingBeginDragLeft(wxControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
	172	virtual void OnSizingEndDragLeft(wxControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
173
174	// Override select, to create/delete temporary label-moving objects
2ba06d5a	175	void Select(bool select = true, wxDC* dc = NULL);
1fc25a89	176
2ba06d5a	177	// Set to spline (true) or line (false)
1fc25a89 JS	178	inline void SetSpline(bool spl) { m_isSpline = spl; }
	179	inline bool IsSpline() const { return m_isSpline; }
	180
	181	void Unlink();
	182	void SetAttachments(int from_attach, int to_attach);
	183	inline void SetAttachmentFrom(int attach) { m_attachmentFrom = attach; }
	184	inline void SetAttachmentTo(int attach) { m_attachmentTo = attach; }
	185
	186	bool HitTest(double x, double y, int attachment, double distance);
	187
2b5f62a0	188	#if wxUSE_PROLOGIO
1fc25a89 JS	189	// I/O
	190	virtual void WriteAttributes(wxExpr *clause);
	191	virtual void ReadAttributes(wxExpr *clause);
	192	#endif
	193
	194	virtual void FindNth(wxShape image, int nth, int *no_arcs, bool incoming);
	195
	196	// Find which position we're talking about at this (x, y).
	197	// Returns ARROW_POSITION_START, ARROW_POSITION_MIDDLE, ARROW_POSITION_END
	198	int FindLinePosition(double x, double y);
	199
	200	// This is really to distinguish between lines and other images.
	201	// For lines, want to pass drag to canvas, since lines tend to prevent
	202	// dragging on a canvas (they get in the way.)
2ba06d5a	203	virtual bool Draggable() const { return false; }
1fc25a89 JS	204
	205	// Does the copying for this object
	206	void Copy(wxShape& copy);
	207
	208	// Add an arrowhead.
	209	wxArrowHead *AddArrow(WXTYPE type, int end = ARROW_POSITION_END,
9e053640 RD	210	double arrowSize = 10.0, double xOffset = 0.0,
	211	const wxString& name = wxEmptyString,
	212	wxPseudoMetaFile *mf = NULL, long arrowId = -1);
1fc25a89 JS	213
	214	// Add an arrowhead in the position indicated by the reference
	215	// list of arrowheads, which contains all legal arrowheads for this
	216	// line, in the correct order.
	217	// E.g. reference list: a b c d e
	218	// Current line list: a d
	219	// Add c, then line list is: a c d
2ba06d5a	220	// If no legal arrowhead position, return false.
1fc25a89 JS	221	// Assume reference list is for one end only, since it potentially defines
	222	// the ordering for any one of the 3 positions. So we don't check
	223	// the reference list for arrowhead position.
	224	bool AddArrowOrdered(wxArrowHead *arrow, wxList& referenceList, int end);
	225
	226	// Delete arrowhead(s)
	227	void ClearArrowsAtPosition(int end = -1);
	228	bool ClearArrow(const wxString& name);
	229	wxArrowHead *FindArrowHead(int position, const wxString& name);
	230	wxArrowHead *FindArrowHead(long arrowId);
	231	bool DeleteArrowHead(int position, const wxString& name);
	232	bool DeleteArrowHead(long arrowId);
	233	void DrawArrow(wxDC& dc, wxArrowHead *arrow, double xOffset, bool proportionalOffset);
	234	inline void SetIgnoreOffsets(bool ignore) { m_ignoreArrowOffsets = ignore; }
	235	inline wxList& GetArrows() const { return (wxList&) m_arcArrows; }
	236
	237	// Find horizontal width for drawing a line with
	238	// arrows in minimum space. Assume arrows at
	239	// END only
	240	double FindMinimumWidth();
	241
	242	// Set alignment flags. ALIGNMENT NOT IMPLEMENTED.
	243	void SetAlignmentOrientation(bool isEnd, bool isHoriz);
	244	void SetAlignmentType(bool isEnd, int alignType);
	245	bool GetAlignmentOrientation(bool isEnd);
	246	int GetAlignmentType(bool isEnd);
4b7eab30 JS	247	int GetAlignmentStart() const { return m_alignmentStart; }
4b7eab30 JS	248	int GetAlignmentEnd() const { return m_alignmentEnd; }
1fc25a89 JS	249
	250	// Find next control point in line after the start/end point
	251	// (depending on whether the node object is at start or end)
	252	wxRealPoint GetNextControlPoint(wxShape nodeObject);
	253	inline bool IsEnd(wxShape *nodeObject) const { return (m_to == nodeObject); }
	254
	255	private:
	256	bool m_erasing; // flag to say whether we're erasing or drawing
	257	// this line (really so metafiles can draw a
	258	// blank rectangle)
	259	bool m_ignoreArrowOffsets; // Don't always want to draw arrowhead offsets
	260	// because they may not work on tool palettes (for example)
	261	bool m_isSpline;
	262	bool m_maintainStraightLines;
	263
	264	protected:
	265	// Temporary list of line segment orientations
	266	// so we know what direction the line is supposed to be dog-legging
	267	// in. The values are integer: 0 for vertical, 1 for horizontal.
	268	wxList m_lineOrientations;
	269
	270	// Temporary pointers for start, middle and end label editing objects
	271	// (active only when the line is selected)
	272	wxLabelShape* m_labelObjects[3];
	273
	274	// These define the segmented line - not to be confused with temporary control
	275	// points which appear when object is selected (although in this case they'll
	276	// probably be the same)
	277	wxList* m_lineControlPoints;
	278
	279	double m_arrowSpacing; // Separation between adjacent arrows
	280
	281	wxShape* m_to;
	282	wxShape* m_from;
	283
	284	int m_attachmentTo; // Attachment point at one end
	285	int m_attachmentFrom; // Attachment point at other end
	286
	287	// Alignment flags
	288	int m_alignmentStart;
	289	int m_alignmentEnd;
	290
	291	wxList m_arcArrows;
	292
	293	};
	294
	295	#endif
	296	// _OGL_LINES_H_