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

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

#ifndef _OGL_DRAWN_H_
#define _OGL_DRAWN_H_

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

#include <wx/ogl/basic.h>

#define oglMETAFLAGS_OUTLINE         1
#define oglMETAFLAGS_ATTACHMENTS     2

class wxDrawnShape;
class wxPseudoMetaFile: public wxObject
{
 DECLARE_DYNAMIC_CLASS(wxPseudoMetaFile)
 public:
  wxPseudoMetaFile();
  wxPseudoMetaFile(wxPseudoMetaFile& mf);
  ~wxPseudoMetaFile();

  void Draw(wxDC& dc, double xoffset, double yoffset);

#if wxUSE_PROLOGIO
  void WriteAttributes(wxExpr *clause, int whichAngle);
  void ReadAttributes(wxExpr *clause, int whichAngle);
#endif

  void Clear();

  void Copy(wxPseudoMetaFile& copy);

  void Scale(double sx, double sy);
  void ScaleTo(double w, double h); // Scale to fit size
  void Translate(double x, double y);

  // Rotate about the given axis by theta radians from the x axis.
  void Rotate(double x, double y, double theta);

  bool LoadFromMetaFile(const wxString& filename, double *width, double *height);

  void GetBounds(double *minX, double *minY, double *maxX, double *maxY);

  // Calculate size from current operations
  void CalculateSize(wxDrawnShape* shape);

  inline wxList& GetOutlineColours() const { return (wxList&) m_outlineColours; }
  inline wxList& GetFillColours() const { return (wxList&) m_fillColours; }
  inline void SetRotateable(bool rot) { m_rotateable = rot; }
  inline bool GetRotateable() const { return m_rotateable; }

  inline void SetSize(double w, double h) { m_width = w; m_height = h; }

  inline void SetFillBrush(wxBrush* brush) { m_fillBrush = brush; }
  inline wxBrush* GetFillBrush() const { return m_fillBrush; }

  inline void SetOutlinePen(wxPen* pen) { m_outlinePen = pen; }
  inline wxPen* GetOutlinePen() const { return m_outlinePen; }

  inline void SetOutlineOp(int op) { m_outlineOp = op; }
  inline int GetOutlineOp() const { return m_outlineOp; }

  inline wxList& GetOps() const { return (wxList&) m_ops; }

  // Is this a valid (non-empty) metafile?
  inline bool IsValid() const { return (m_ops.Number() > 0); }

public:
  /// Set of functions for drawing into a pseudo metafile.
  /// They use integers, but doubles are used internally for accuracy
  /// when scaling.

  virtual void DrawLine(const wxPoint& pt1, const wxPoint& pt2);
  virtual void DrawRectangle(const wxRect& rect);
  virtual void DrawRoundedRectangle(const wxRect& rect, double radius);
  virtual void DrawArc(const wxPoint& centrePt, const wxPoint& startPt, const wxPoint& endPt);
  virtual void DrawEllipticArc(const wxRect& rect, double startAngle, double endAngle);
  virtual void DrawEllipse(const wxRect& rect);
  virtual void DrawPoint(const wxPoint& pt);
  virtual void DrawText(const wxString& text, const wxPoint& pt);
  virtual void DrawLines(int n, wxPoint pts[]);
  // flags:
  // oglMETAFLAGS_OUTLINE: will be used for drawing the outline and
  //                       also drawing lines/arrows at the circumference.
  // oglMETAFLAGS_ATTACHMENTS: will be used for initialising attachment points at
  //                       the vertices (perhaps a rare case...)
  virtual void DrawPolygon(int n, wxPoint pts[], int flags = 0);
  virtual void DrawSpline(int n, wxPoint pts[]);

  virtual void SetClippingRect(const wxRect& rect);
  virtual void DestroyClippingRect();

  virtual void SetPen(wxPen* pen, bool isOutline = FALSE);     // TODO: eventually, just store GDI object attributes, not actual
  virtual void SetBrush(wxBrush* brush, bool isFill = FALSE);  // pens/brushes etc.
  virtual void SetFont(wxFont* font);
  virtual void SetTextColour(const wxColour& colour);
  virtual void SetBackgroundColour(const wxColour& colour);
  virtual void SetBackgroundMode(int mode);

public:
  bool              m_rotateable;
  double            m_width;
  double            m_height;
  wxList            m_ops; // List of drawing operations (see drawnp.h)
  wxList            m_gdiObjects; // List of pens, brushes and fonts for this object.
  int               m_outlineOp;  // The op representing the outline, if any

  // Pen/brush specifying outline/fill colours
  // to override operations.
  wxPen*            m_outlinePen;
  wxBrush*          m_fillBrush;
  wxList            m_outlineColours; // List of the GDI operations that comprise the outline
  wxList            m_fillColours; // List of the GDI operations that fill the shape
  double             m_currentRotation;
};

#define oglDRAWN_ANGLE_0        0
#define oglDRAWN_ANGLE_90       1
#define oglDRAWN_ANGLE_180      2
#define oglDRAWN_ANGLE_270      3

class wxDrawnShape: public wxRectangleShape
{
 DECLARE_DYNAMIC_CLASS(wxDrawnShape)
 public:
  wxDrawnShape();
  ~wxDrawnShape();

  void OnDraw(wxDC& dc);

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

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

  void Scale(double sx, double sy);
  void Translate(double x, double y);
  // Rotate about the given axis by theta radians from the x axis.
  void Rotate(double x, double y, double theta);

  // Get current rotation
  inline double GetRotation() const { return m_rotation; }

  void SetSize(double w, double h, bool recursive = TRUE);
  bool LoadFromMetaFile(const wxString& filename);

  inline void SetSaveToFile(bool save) { m_saveToFile = save; }
  inline wxPseudoMetaFile& GetMetaFile(int which = 0) const { return (wxPseudoMetaFile&) m_metafiles[which]; }

  void OnDrawOutline(wxDC& dc, double x, double y, double w, double h);

  // Get the perimeter point using the special outline op, if there is one,
  // otherwise use default wxRectangleShape scheme
  bool GetPerimeterPoint(double x1, double y1,
                                     double x2, double y2,
                                     double *x3, double *y3);

  /// Set of functions for drawing into a pseudo metafile.
  /// They use integers, but doubles are used internally for accuracy
  /// when scaling.

  virtual void DrawLine(const wxPoint& pt1, const wxPoint& pt2);
  virtual void DrawRectangle(const wxRect& rect);
  virtual void DrawRoundedRectangle(const wxRect& rect, double radius);
  virtual void DrawArc(const wxPoint& centrePt, const wxPoint& startPt, const wxPoint& endPt);
  virtual void DrawEllipticArc(const wxRect& rect, double startAngle, double endAngle);
  virtual void DrawEllipse(const wxRect& rect);
  virtual void DrawPoint(const wxPoint& pt);
  virtual void DrawText(const wxString& text, const wxPoint& pt);
  virtual void DrawLines(int n, wxPoint pts[]);
  virtual void DrawPolygon(int n, wxPoint pts[], int flags = 0);
  virtual void DrawSpline(int n, wxPoint pts[]);

  virtual void SetClippingRect(const wxRect& rect);
  virtual void DestroyClippingRect();

  virtual void SetDrawnPen(wxPen* pen, bool isOutline = FALSE);     // TODO: eventually, just store GDI object attributes, not actual
  virtual void SetDrawnBrush(wxBrush* brush, bool isFill = FALSE);  // pens/brushes etc.
  virtual void SetDrawnFont(wxFont* font);
  virtual void SetDrawnTextColour(const wxColour& colour);
  virtual void SetDrawnBackgroundColour(const wxColour& colour);
  virtual void SetDrawnBackgroundMode(int mode);

  // Set the width/height according to the shapes in the metafile.
  // Call this after drawing into the shape.
  inline void CalculateSize() { m_metafiles[m_currentAngle].CalculateSize(this); }

  inline void DrawAtAngle(int angle) { m_currentAngle = angle; };

  inline int GetAngle() const { return m_currentAngle; }

// Implementation
protected:
  // Which metafile do we use now? Based on current rotation and validity
  // of metafiles.
  int DetermineMetaFile(double rotation);

private:
  // One metafile for each 90 degree rotation (or just a single one).
  wxPseudoMetaFile      m_metafiles[4];

  // Don't save all wxDrawnShape metafiles to file: sometimes
  // we take the metafile data from a symbol library.
  bool                  m_saveToFile;

  // Which angle are we using/drawing into?
  int                   m_currentAngle;
};

#endif
    // _DRAWN_H_
Commit	Line	Data
1fc25a89 JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: drawn.h
	3	// Purpose: wxDrawnShape
	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_DRAWN_H_
	13	#define _OGL_DRAWN_H_
	14
ab7ce33c	15	#if defined(__GNUG__) && !defined(__APPLE__)
1fc25a89 JS	16	#pragma interface "drawn.h"
	17	#endif
	18
	19	#include <wx/ogl/basic.h>
	20
	21	#define oglMETAFLAGS_OUTLINE 1
	22	#define oglMETAFLAGS_ATTACHMENTS 2
	23
	24	class wxDrawnShape;
	25	class wxPseudoMetaFile: public wxObject
	26	{
	27	DECLARE_DYNAMIC_CLASS(wxPseudoMetaFile)
	28	public:
	29	wxPseudoMetaFile();
	30	wxPseudoMetaFile(wxPseudoMetaFile& mf);
	31	~wxPseudoMetaFile();
	32
	33	void Draw(wxDC& dc, double xoffset, double yoffset);
	34
2b5f62a0	35	#if wxUSE_PROLOGIO
1fc25a89 JS	36	void WriteAttributes(wxExpr *clause, int whichAngle);
	37	void ReadAttributes(wxExpr *clause, int whichAngle);
	38	#endif
	39
	40	void Clear();
	41
	42	void Copy(wxPseudoMetaFile& copy);
	43
	44	void Scale(double sx, double sy);
	45	void ScaleTo(double w, double h); // Scale to fit size
	46	void Translate(double x, double y);
	47
	48	// Rotate about the given axis by theta radians from the x axis.
	49	void Rotate(double x, double y, double theta);
	50
9e053640	51	bool LoadFromMetaFile(const wxString& filename, double width, double height);
1fc25a89 JS	52
	53	void GetBounds(double minX, double minY, double maxX, double maxY);
	54
	55	// Calculate size from current operations
	56	void CalculateSize(wxDrawnShape* shape);
	57
	58	inline wxList& GetOutlineColours() const { return (wxList&) m_outlineColours; }
	59	inline wxList& GetFillColours() const { return (wxList&) m_fillColours; }
	60	inline void SetRotateable(bool rot) { m_rotateable = rot; }
	61	inline bool GetRotateable() const { return m_rotateable; }
	62
	63	inline void SetSize(double w, double h) { m_width = w; m_height = h; }
	64
	65	inline void SetFillBrush(wxBrush* brush) { m_fillBrush = brush; }
	66	inline wxBrush* GetFillBrush() const { return m_fillBrush; }
	67
	68	inline void SetOutlinePen(wxPen* pen) { m_outlinePen = pen; }
	69	inline wxPen* GetOutlinePen() const { return m_outlinePen; }
	70
	71	inline void SetOutlineOp(int op) { m_outlineOp = op; }
	72	inline int GetOutlineOp() const { return m_outlineOp; }
	73
	74	inline wxList& GetOps() const { return (wxList&) m_ops; }
	75
	76	// Is this a valid (non-empty) metafile?
	77	inline bool IsValid() const { return (m_ops.Number() > 0); }
	78
	79	public:
	80	/// Set of functions for drawing into a pseudo metafile.
	81	/// They use integers, but doubles are used internally for accuracy
	82	/// when scaling.
	83
	84	virtual void DrawLine(const wxPoint& pt1, const wxPoint& pt2);
	85	virtual void DrawRectangle(const wxRect& rect);
	86	virtual void DrawRoundedRectangle(const wxRect& rect, double radius);
	87	virtual void DrawArc(const wxPoint& centrePt, const wxPoint& startPt, const wxPoint& endPt);
	88	virtual void DrawEllipticArc(const wxRect& rect, double startAngle, double endAngle);
	89	virtual void DrawEllipse(const wxRect& rect);
	90	virtual void DrawPoint(const wxPoint& pt);
	91	virtual void DrawText(const wxString& text, const wxPoint& pt);
	92	virtual void DrawLines(int n, wxPoint pts[]);
	93	// flags:
	94	// oglMETAFLAGS_OUTLINE: will be used for drawing the outline and
	95	// also drawing lines/arrows at the circumference.
	96	// oglMETAFLAGS_ATTACHMENTS: will be used for initialising attachment points at
	97	// the vertices (perhaps a rare case...)
	98	virtual void DrawPolygon(int n, wxPoint pts[], int flags = 0);
	99	virtual void DrawSpline(int n, wxPoint pts[]);
	100
	101	virtual void SetClippingRect(const wxRect& rect);
	102	virtual void DestroyClippingRect();
	103
	104	virtual void SetPen(wxPen* pen, bool isOutline = FALSE); // TODO: eventually, just store GDI object attributes, not actual
	105	virtual void SetBrush(wxBrush* brush, bool isFill = FALSE); // pens/brushes etc.
	106	virtual void SetFont(wxFont* font);
	107	virtual void SetTextColour(const wxColour& colour);
	108	virtual void SetBackgroundColour(const wxColour& colour);
	109	virtual void SetBackgroundMode(int mode);
	110
	111	public:
	112	bool m_rotateable;
	113	double m_width;
	114	double m_height;
	115	wxList m_ops; // List of drawing operations (see drawnp.h)
116	wxList m_gdiObjects; // List of pens, brushes and fonts for this object.
117	int m_outlineOp; // The op representing the outline, if any
118
119	// Pen/brush specifying outline/fill colours
120	// to override operations.
121	wxPen* m_outlinePen;
122	wxBrush* m_fillBrush;
123	wxList m_outlineColours; // List of the GDI operations that comprise the outline
124	wxList m_fillColours; // List of the GDI operations that fill the shape
125	double m_currentRotation;
126	};
127
128	#define oglDRAWN_ANGLE_0 0
129	#define oglDRAWN_ANGLE_90 1
130	#define oglDRAWN_ANGLE_180 2
131	#define oglDRAWN_ANGLE_270 3
132
133	class wxDrawnShape: public wxRectangleShape
134	{
135	DECLARE_DYNAMIC_CLASS(wxDrawnShape)
136	public:
137	wxDrawnShape();
138	~wxDrawnShape();
139
140	void OnDraw(wxDC& dc);
141
2b5f62a0	142	#if wxUSE_PROLOGIO
1fc25a89 JS	143	// I/O
	144	void WriteAttributes(wxExpr *clause);
	145	void ReadAttributes(wxExpr *clause);
	146	#endif
	147
	148	// Does the copying for this object
	149	void Copy(wxShape& copy);
	150
	151	void Scale(double sx, double sy);
	152	void Translate(double x, double y);
	153	// Rotate about the given axis by theta radians from the x axis.
	154	void Rotate(double x, double y, double theta);
	155
	156	// Get current rotation
	157	inline double GetRotation() const { return m_rotation; }
	158
	159	void SetSize(double w, double h, bool recursive = TRUE);
9e053640	160	bool LoadFromMetaFile(const wxString& filename);
1fc25a89 JS	161
	162	inline void SetSaveToFile(bool save) { m_saveToFile = save; }
	163	inline wxPseudoMetaFile& GetMetaFile(int which = 0) const { return (wxPseudoMetaFile&) m_metafiles[which]; }
	164
	165	void OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
	166
	167	// Get the perimeter point using the special outline op, if there is one,
	168	// otherwise use default wxRectangleShape scheme
	169	bool GetPerimeterPoint(double x1, double y1,
	170	double x2, double y2,
	171	double x3, double y3);
	172
	173	/// Set of functions for drawing into a pseudo metafile.
	174	/// They use integers, but doubles are used internally for accuracy
	175	/// when scaling.
	176
	177	virtual void DrawLine(const wxPoint& pt1, const wxPoint& pt2);
	178	virtual void DrawRectangle(const wxRect& rect);
	179	virtual void DrawRoundedRectangle(const wxRect& rect, double radius);
	180	virtual void DrawArc(const wxPoint& centrePt, const wxPoint& startPt, const wxPoint& endPt);
	181	virtual void DrawEllipticArc(const wxRect& rect, double startAngle, double endAngle);
	182	virtual void DrawEllipse(const wxRect& rect);
	183	virtual void DrawPoint(const wxPoint& pt);
	184	virtual void DrawText(const wxString& text, const wxPoint& pt);
	185	virtual void DrawLines(int n, wxPoint pts[]);
	186	virtual void DrawPolygon(int n, wxPoint pts[], int flags = 0);
	187	virtual void DrawSpline(int n, wxPoint pts[]);
	188
	189	virtual void SetClippingRect(const wxRect& rect);
	190	virtual void DestroyClippingRect();
	191
	192	virtual void SetDrawnPen(wxPen* pen, bool isOutline = FALSE); // TODO: eventually, just store GDI object attributes, not actual
	193	virtual void SetDrawnBrush(wxBrush* brush, bool isFill = FALSE); // pens/brushes etc.
	194	virtual void SetDrawnFont(wxFont* font);
	195	virtual void SetDrawnTextColour(const wxColour& colour);
	196	virtual void SetDrawnBackgroundColour(const wxColour& colour);
	197	virtual void SetDrawnBackgroundMode(int mode);
	198
	199	// Set the width/height according to the shapes in the metafile.
	200	// Call this after drawing into the shape.
	201	inline void CalculateSize() { m_metafiles[m_currentAngle].CalculateSize(this); }
	202
	203	inline void DrawAtAngle(int angle) { m_currentAngle = angle; };
	204
	205	inline int GetAngle() const { return m_currentAngle; }
	206
	207	// Implementation
	208	protected:
	209	// Which metafile do we use now? Based on current rotation and validity
	210	// of metafiles.
	211	int DetermineMetaFile(double rotation);
	212
	213	private:
	214	// One metafile for each 90 degree rotation (or just a single one).
	215	wxPseudoMetaFile m_metafiles[4];
	216
	217	// Don't save all wxDrawnShape metafiles to file: sometimes
	218	// we take the metafile data from a symbol library.
	219	bool m_saveToFile;
	220
	221	// Which angle are we using/drawing into?
	222	int m_currentAngle;
	223	};
	224
225	#endif
226	// _DRAWN_H_
227