|
|
@@ -0,0 +1,826 @@
|
|
|
+/////////////////////////////////////////////////////////////////////////////
|
|
|
+// Name: pseudodc.h
|
|
|
+// Purpose: gwxPseudoDC class
|
|
|
+// Author: Paul Lanier
|
|
|
+// Modified by: Glynn Clements 2009-01-14
|
|
|
+// Created: 05/25/06
|
|
|
+// RCS-ID: $Id: pseudodc.h 49047 2007-10-05 18:08:39Z RD $
|
|
|
+// Copyright: (c) wxWidgets team
|
|
|
+// Licence: wxWindows licence
|
|
|
+/////////////////////////////////////////////////////////////////////////////
|
|
|
+#ifndef _GWX_PSUEDO_DC_H_BASE_
|
|
|
+#define _GWX_PSUEDO_DC_H_BASE_
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+// Base class for all gpdcOp classes
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+class gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ // Constructor and Destructor
|
|
|
+ gpdcOp() {}
|
|
|
+ virtual ~gpdcOp() {}
|
|
|
+
|
|
|
+ // Virtual Drawing Methods
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)=0;
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy) {}
|
|
|
+ virtual void CacheGrey() {}
|
|
|
+};
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+// declare a list class for list of gpdcOps
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+WX_DECLARE_LIST(gpdcOp, gpdcOpList);
|
|
|
+
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+// Helper functions used for drawing greyed out versions of objects
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+wxColour &gwxMakeColourGrey(const wxColour &c);
|
|
|
+wxBrush &gwxGetGreyBrush(wxBrush &brush);
|
|
|
+wxPen &gwxGetGreyPen(wxPen &pen);
|
|
|
+wxIcon &gwxGetGreyIcon(wxIcon &icon);
|
|
|
+wxBitmap &gwxGetGreyBitmap(wxBitmap &bmp);
|
|
|
+void gwxGreyOutImage(wxImage &img);
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+// Classes derived from gpdcOp
|
|
|
+// There is one class for each method mirrored from wxDC to gwxPseudoDC
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+class gpdcSetFontOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcSetFontOp(const wxFont& font)
|
|
|
+ {m_font=font;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false) {dc->SetFont(m_font);}
|
|
|
+ protected:
|
|
|
+ wxFont m_font;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcSetBrushOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcSetBrushOp(const wxBrush& brush)
|
|
|
+ {m_greybrush=m_brush=brush;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {
|
|
|
+ if (!grey) dc->SetBrush(m_brush);
|
|
|
+ else dc->SetBrush(m_greybrush);
|
|
|
+ }
|
|
|
+ virtual void CacheGrey() {m_greybrush=gwxGetGreyBrush(m_brush);}
|
|
|
+ protected:
|
|
|
+ wxBrush m_brush;
|
|
|
+ wxBrush m_greybrush;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcSetBackgroundOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcSetBackgroundOp(const wxBrush& brush)
|
|
|
+ {m_greybrush=m_brush=brush;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {
|
|
|
+ if (!grey) dc->SetBackground(m_brush);
|
|
|
+ else dc->SetBackground(m_greybrush);
|
|
|
+ }
|
|
|
+ virtual void CacheGrey() {m_greybrush=gwxGetGreyBrush(m_brush);}
|
|
|
+ protected:
|
|
|
+ wxBrush m_brush;
|
|
|
+ wxBrush m_greybrush;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcSetPenOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcSetPenOp(const wxPen& pen)
|
|
|
+ {m_greypen=m_pen=pen;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {
|
|
|
+ if (!grey) dc->SetPen(m_pen);
|
|
|
+ else dc->SetPen(m_greypen);
|
|
|
+ }
|
|
|
+ virtual void CacheGrey() {m_greypen=gwxGetGreyPen(m_pen);}
|
|
|
+ protected:
|
|
|
+ wxPen m_pen;
|
|
|
+ wxPen m_greypen;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcSetTextBackgroundOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcSetTextBackgroundOp(const wxColour& colour)
|
|
|
+ {m_colour=colour;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {
|
|
|
+ if (!grey) dc->SetTextBackground(m_colour);
|
|
|
+ else dc->SetTextBackground(gwxMakeColourGrey(m_colour));
|
|
|
+ }
|
|
|
+ protected:
|
|
|
+ wxColour m_colour;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcSetTextForegroundOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcSetTextForegroundOp(const wxColour& colour)
|
|
|
+ {m_colour=colour;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {
|
|
|
+ if (!grey) dc->SetTextForeground(m_colour);
|
|
|
+ else dc->SetTextForeground(gwxMakeColourGrey(m_colour));
|
|
|
+ }
|
|
|
+ protected:
|
|
|
+ wxColour m_colour;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawRectangleOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawRectangleOp(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
|
|
|
+ {m_x=x; m_y=y; m_w=w; m_h=h;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false) {dc->DrawRectangle(m_x,m_y,m_w,m_h);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {m_x+=dx;m_y+=dy;}
|
|
|
+ protected:
|
|
|
+ wxCoord m_x,m_y,m_w,m_h;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawLineOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawLineOp(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
|
|
|
+ {m_x1=x1; m_y1=y1; m_x2=x2; m_y2=y2;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false) {dc->DrawLine(m_x1,m_y1,m_x2,m_y2);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {m_x1+=dx; m_y1+=dy; m_x2+=dx; m_y2+=dy;}
|
|
|
+ protected:
|
|
|
+ wxCoord m_x1,m_y1,m_x2,m_y2;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcSetBackgroundModeOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcSetBackgroundModeOp(int mode) {m_mode=mode;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false) {dc->SetBackgroundMode(m_mode);}
|
|
|
+ protected:
|
|
|
+ int m_mode;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawTextOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawTextOp(const wxString& text, wxCoord x, wxCoord y)
|
|
|
+ {m_text=text; m_x=x; m_y=y;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false) {dc->DrawText(m_text, m_x, m_y);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {m_x+=dx; m_y+=dy;}
|
|
|
+ protected:
|
|
|
+ wxString m_text;
|
|
|
+ wxCoord m_x, m_y;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcClearOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcClearOp() {}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false) {dc->Clear();}
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcBeginDrawingOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcBeginDrawingOp() {}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false) {}
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcEndDrawingOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcEndDrawingOp() {}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false) {}
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcFloodFillOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcFloodFillOp(wxCoord x, wxCoord y, const wxColour& col,
|
|
|
+ int style) {m_x=x; m_y=y; m_col=col; m_style=style;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {
|
|
|
+ if (!grey) dc->FloodFill(m_x,m_y,m_col,m_style);
|
|
|
+ else dc->FloodFill(m_x,m_y,gwxMakeColourGrey(m_col),m_style);
|
|
|
+ }
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {m_x+=dx; m_y+=dy;}
|
|
|
+ protected:
|
|
|
+ wxCoord m_x,m_y;
|
|
|
+ wxColour m_col;
|
|
|
+ int m_style;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcCrossHairOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcCrossHairOp(wxCoord x, wxCoord y) {m_x=x; m_y=y;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false) {dc->CrossHair(m_x,m_y);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {m_x+=dx; m_y+=dy;}
|
|
|
+ protected:
|
|
|
+ wxCoord m_x,m_y;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawArcOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawArcOp(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
|
|
|
+ wxCoord xc, wxCoord yc)
|
|
|
+ {m_x1=x1; m_y1=y1; m_x2=x2; m_y2=y2; m_xc=xc; m_yc=yc;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {dc->DrawArc(m_x1,m_y1,m_x2,m_y2,m_xc,m_yc);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {m_x1+=dx; m_x2+=dx; m_y1+=dy; m_y2+=dy;}
|
|
|
+ protected:
|
|
|
+ wxCoord m_x1,m_x2,m_xc;
|
|
|
+ wxCoord m_y1,m_y2,m_yc;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawCheckMarkOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawCheckMarkOp(wxCoord x, wxCoord y,
|
|
|
+ wxCoord width, wxCoord height)
|
|
|
+ {m_x=x; m_y=y; m_w=width; m_h=height;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {dc->DrawCheckMark(m_x,m_y,m_w,m_h);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {m_x+=dx; m_y+=dy;}
|
|
|
+ protected:
|
|
|
+ wxCoord m_x,m_y,m_w,m_h;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawEllipticArcOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawEllipticArcOp(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
|
|
|
+ double sa, double ea)
|
|
|
+ {m_x=x; m_y=y; m_w=w; m_h=h; m_sa=sa; m_ea=ea;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {dc->DrawEllipticArc(m_x,m_y,m_w,m_h,m_sa,m_ea);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {m_x+=dx; m_y+=dy;}
|
|
|
+ protected:
|
|
|
+ wxCoord m_x,m_y,m_w,m_h;
|
|
|
+ double m_sa,m_ea;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawPointOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawPointOp(wxCoord x, wxCoord y)
|
|
|
+ {m_x=x; m_y=y;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false) {dc->DrawPoint(m_x,m_y);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {m_x+=dx; m_y+=dy;}
|
|
|
+ protected:
|
|
|
+ wxCoord m_x,m_y;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawRoundedRectangleOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawRoundedRectangleOp(wxCoord x, wxCoord y, wxCoord width,
|
|
|
+ wxCoord height, double radius)
|
|
|
+ {m_x=x; m_y=y; m_w=width; m_h=height; m_r=radius;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {dc->DrawRoundedRectangle(m_x,m_y,m_w,m_h,m_r);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {m_x+=dx; m_y+=dy;}
|
|
|
+ protected:
|
|
|
+ wxCoord m_x,m_y,m_w,m_h;
|
|
|
+ double m_r;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawEllipseOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawEllipseOp(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
|
|
|
+ {m_x=x; m_y=y; m_w=width; m_h=height;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false) {dc->DrawEllipse(m_x,m_y,m_w,m_h);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {m_x+=dx; m_y+=dy;}
|
|
|
+ protected:
|
|
|
+ wxCoord m_x,m_y,m_w,m_h;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawIconOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawIconOp(const wxIcon& icon, wxCoord x, wxCoord y)
|
|
|
+ {m_icon=icon; m_x=x; m_y=y;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {
|
|
|
+ if (grey) dc->DrawIcon(m_greyicon,m_x,m_y);
|
|
|
+ else dc->DrawIcon(m_icon,m_x,m_y);
|
|
|
+ }
|
|
|
+ virtual void CacheGrey() {m_greyicon=gwxGetGreyIcon(m_icon);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {m_x+=dx; m_y+=dy;}
|
|
|
+ protected:
|
|
|
+ wxIcon m_icon;
|
|
|
+ wxIcon m_greyicon;
|
|
|
+ wxCoord m_x,m_y;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawLinesOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawLinesOp(int n, wxPoint points[],
|
|
|
+ wxCoord xoffset = 0, wxCoord yoffset = 0);
|
|
|
+ virtual ~gpdcDrawLinesOp();
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {dc->DrawLines(m_n,m_points,m_xoffset,m_yoffset);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {
|
|
|
+ for(int i=0; i<m_n; i++)
|
|
|
+ {
|
|
|
+ m_points[i].x+=dx;
|
|
|
+ m_points[i].y+=dy;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ protected:
|
|
|
+ int m_n;
|
|
|
+ wxPoint *m_points;
|
|
|
+ wxCoord m_xoffset,m_yoffset;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawPolygonOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawPolygonOp(int n, wxPoint points[],
|
|
|
+ wxCoord xoffset = 0, wxCoord yoffset = 0,
|
|
|
+ int fillStyle = wxODDEVEN_RULE);
|
|
|
+ virtual ~gpdcDrawPolygonOp();
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {dc->DrawPolygon(m_n,m_points,m_xoffset,m_yoffset,m_fillStyle);}
|
|
|
+
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {
|
|
|
+ for(int i=0; i<m_n; i++)
|
|
|
+ {
|
|
|
+ m_points[i].x+=dx;
|
|
|
+ m_points[i].y+=dy;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ protected:
|
|
|
+ int m_n;
|
|
|
+ wxPoint *m_points;
|
|
|
+ wxCoord m_xoffset,m_yoffset;
|
|
|
+ int m_fillStyle;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawPolyPolygonOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawPolyPolygonOp(int n, int count[], wxPoint points[],
|
|
|
+ wxCoord xoffset = 0, wxCoord yoffset = 0,
|
|
|
+ int fillStyle = wxODDEVEN_RULE);
|
|
|
+ virtual ~gpdcDrawPolyPolygonOp();
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {dc->DrawPolyPolygon(m_n,m_count,m_points,
|
|
|
+ m_xoffset,m_yoffset,m_fillStyle);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {
|
|
|
+ for(int i=0; i<m_totaln; i++)
|
|
|
+ {
|
|
|
+ m_points[i].x += dx;
|
|
|
+ m_points[i].y += dy;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ protected:
|
|
|
+ int m_n;
|
|
|
+ int m_totaln;
|
|
|
+ int *m_count;
|
|
|
+ wxPoint *m_points;
|
|
|
+ wxCoord m_xoffset, m_yoffset;
|
|
|
+ int m_fillStyle;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawRotatedTextOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawRotatedTextOp(const wxString& text, wxCoord x, wxCoord y, double angle)
|
|
|
+ {m_text=text; m_x=x; m_y=y; m_angle=angle;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {dc->DrawRotatedText(m_text,m_x,m_y,m_angle);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {m_x+=dx; m_y+=dy;}
|
|
|
+ protected:
|
|
|
+ wxString m_text;
|
|
|
+ wxCoord m_x,m_y;
|
|
|
+ double m_angle;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawBitmapOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawBitmapOp(const wxBitmap &bmp, wxCoord x, wxCoord y,
|
|
|
+ bool useMask = false)
|
|
|
+ {m_bmp=bmp; m_x=x; m_y=y; m_useMask=useMask;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {
|
|
|
+ if (grey) dc->DrawBitmap(m_greybmp,m_x,m_y,m_useMask);
|
|
|
+ else dc->DrawBitmap(m_bmp,m_x,m_y,m_useMask);
|
|
|
+ }
|
|
|
+ virtual void CacheGrey() {m_greybmp=gwxGetGreyBitmap(m_bmp);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {m_x+=dx; m_y+=dy;}
|
|
|
+ protected:
|
|
|
+ wxBitmap m_bmp;
|
|
|
+ wxBitmap m_greybmp;
|
|
|
+ wxCoord m_x,m_y;
|
|
|
+ bool m_useMask;
|
|
|
+};
|
|
|
+
|
|
|
+class gpdcDrawLabelOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawLabelOp(const wxString& text,
|
|
|
+ const wxBitmap& image,
|
|
|
+ const wxRect& rect,
|
|
|
+ int alignment = wxALIGN_LEFT | wxALIGN_TOP,
|
|
|
+ int indexAccel = -1)
|
|
|
+ {m_text=text; m_image=image; m_rect=rect;
|
|
|
+ m_align=alignment; m_iAccel=indexAccel;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false)
|
|
|
+ {dc->DrawLabel(m_text,m_image,m_rect,m_align,m_iAccel);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {m_rect.x+=dx; m_rect.y+=dy;}
|
|
|
+ protected:
|
|
|
+ wxString m_text;
|
|
|
+ wxBitmap m_image;
|
|
|
+ wxRect m_rect;
|
|
|
+ int m_align;
|
|
|
+ int m_iAccel;
|
|
|
+};
|
|
|
+
|
|
|
+#if wxUSE_SPLINES
|
|
|
+class gpdcDrawSplineOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcDrawSplineOp(int n, wxPoint points[]);
|
|
|
+ virtual ~gpdcDrawSplineOp();
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false) {dc->DrawSpline(m_n,m_points);}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy)
|
|
|
+ {
|
|
|
+ int i;
|
|
|
+ for(i=0; i<m_n; i++)
|
|
|
+ m_points[i].x+=dx; m_points[i].y+=dy;
|
|
|
+ }
|
|
|
+ protected:
|
|
|
+ wxPoint *m_points;
|
|
|
+ int m_n;
|
|
|
+};
|
|
|
+#endif // wxUSE_SPLINES
|
|
|
+
|
|
|
+#if wxUSE_PALETTE
|
|
|
+class gpdcSetPaletteOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcSetPaletteOp(const wxPalette& palette) {m_palette=palette;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false) {dc->SetPalette(m_palette);}
|
|
|
+ protected:
|
|
|
+ wxPalette m_palette;
|
|
|
+};
|
|
|
+#endif // wxUSE_PALETTE
|
|
|
+
|
|
|
+class gpdcSetLogicalFunctionOp : public gpdcOp
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcSetLogicalFunctionOp(int function) {m_function=function;}
|
|
|
+ virtual void DrawToDC(wxDC *dc, bool grey=false) {dc->SetLogicalFunction(m_function);}
|
|
|
+ protected:
|
|
|
+ int m_function;
|
|
|
+};
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+// gpdcObject type to contain list of operations for each real (Python) object
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+class gpdcObject
|
|
|
+{
|
|
|
+ public:
|
|
|
+ gpdcObject(int id)
|
|
|
+ {m_id=id; m_bounded=false; m_oplist.DeleteContents(true);
|
|
|
+ m_greyedout=false;}
|
|
|
+
|
|
|
+ virtual ~gpdcObject() {m_oplist.Clear();}
|
|
|
+
|
|
|
+ // Protected Member Access
|
|
|
+ void SetId(int id) {m_id=id;}
|
|
|
+ int GetId() {return m_id;}
|
|
|
+ void SetBounds(wxRect& rect) {m_bounds=rect; m_bounded=true;}
|
|
|
+ wxRect GetBounds() {return m_bounds;}
|
|
|
+ void SetBounded(bool bounded) {m_bounded=bounded;}
|
|
|
+ bool IsBounded() {return m_bounded;}
|
|
|
+ void SetGreyedOut(bool greyout=true);
|
|
|
+ bool GetGreyedOut() {return m_greyedout;}
|
|
|
+
|
|
|
+ // Op List Management Methods
|
|
|
+ void Clear() {m_oplist.Clear();}
|
|
|
+ void AddOp(gpdcOp *op)
|
|
|
+ {
|
|
|
+ m_oplist.Append(op);
|
|
|
+ if (m_greyedout) op->CacheGrey();
|
|
|
+ }
|
|
|
+ int GetLen() {return m_oplist.GetCount();}
|
|
|
+ virtual void Translate(wxCoord dx, wxCoord dy);
|
|
|
+
|
|
|
+ // Drawing Method
|
|
|
+ virtual void DrawToDC(wxDC *dc);
|
|
|
+ protected:
|
|
|
+ int m_id; // id of object (associates this gpdcObject
|
|
|
+ // with a Python object with same id)
|
|
|
+ wxRect m_bounds; // bounding rect of this object
|
|
|
+ bool m_bounded; // true if bounds is valid, false by default
|
|
|
+ gpdcOpList m_oplist; // list of operations for this object
|
|
|
+ bool m_greyedout; // if true then draw this object in greys only
|
|
|
+};
|
|
|
+
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+// Declare a wxList to hold all the objects. List order reflects drawing
|
|
|
+// order (Z order) and is the same order as objects are added to the list
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+class gpdcObjectList;
|
|
|
+WX_DECLARE_LIST(gpdcObject, gpdcObjectList);
|
|
|
+
|
|
|
+//Declare a hashmap that maps from ids to nodes in the object list.
|
|
|
+WX_DECLARE_HASH_MAP(
|
|
|
+ int,
|
|
|
+ gpdcObject *,
|
|
|
+ wxIntegerHash,
|
|
|
+ wxIntegerEqual,
|
|
|
+ gpdcObjectHash
|
|
|
+);
|
|
|
+
|
|
|
+
|
|
|
+// ----------------------------------------------------------------------------
|
|
|
+// gwxPseudoDC class
|
|
|
+// ----------------------------------------------------------------------------
|
|
|
+// This is the actual PseudoDC class
|
|
|
+// This class stores a list of recorded dc operations in m_list
|
|
|
+// and plays them back to a real dc using DrawToDC or DrawToDCClipped.
|
|
|
+// Drawing methods are mirrored from wxDC but add nodes to m_list
|
|
|
+// instead of doing any real drawing.
|
|
|
+// ----------------------------------------------------------------------------
|
|
|
+class gwxPseudoDC : public wxObject
|
|
|
+{
|
|
|
+public:
|
|
|
+ gwxPseudoDC()
|
|
|
+ {m_currId=-1; m_lastObject=NULL; m_objectlist.DeleteContents(true);m_objectIndex.clear();}
|
|
|
+ ~gwxPseudoDC();
|
|
|
+ // ------------------------------------------------------------------------
|
|
|
+ // List managment methods
|
|
|
+ //
|
|
|
+ void RemoveAll();
|
|
|
+ int GetLen();
|
|
|
+
|
|
|
+ // ------------------------------------------------------------------------
|
|
|
+ // methods for managing operations by ID
|
|
|
+ //
|
|
|
+ // Set the Id for all subsequent operations (until SetId is called again)
|
|
|
+ void SetId(int id) {m_currId = id;}
|
|
|
+ // Remove all the operations associated with an id so it can be redrawn
|
|
|
+ void ClearId(int id);
|
|
|
+ // Remove the object node (and all operations) associated with an id
|
|
|
+ void RemoveId(int id);
|
|
|
+ // Set the bounding rect of a given object
|
|
|
+ // This will create an object node if one doesn't exist
|
|
|
+ void SetIdBounds(int id, wxRect& rect);
|
|
|
+ void GetIdBounds(int id, wxRect& rect);
|
|
|
+ // Translate all the operations for this id
|
|
|
+ void TranslateId(int id, wxCoord dx, wxCoord dy);
|
|
|
+ // Grey-out an object
|
|
|
+ void SetIdGreyedOut(int id, bool greyout=true);
|
|
|
+ bool GetIdGreyedOut(int id);
|
|
|
+ // Find Objects at a point. Returns Python list of id's
|
|
|
+ // sorted in reverse drawing order (result[0] is top object)
|
|
|
+ // This version looks at drawn pixels
|
|
|
+ PyObject *FindObjects(wxCoord x, wxCoord y,
|
|
|
+ wxCoord radius=1, const wxColor& bg=*wxWHITE);
|
|
|
+ // This version only looks at bounding boxes
|
|
|
+ PyObject *FindObjectsByBBox(wxCoord x, wxCoord y);
|
|
|
+
|
|
|
+ // ------------------------------------------------------------------------
|
|
|
+ // Playback Methods
|
|
|
+ //
|
|
|
+ // draw to dc but skip objects known to be outside of rect
|
|
|
+ // This is a coarse level of clipping to speed things up
|
|
|
+ // when lots of objects are off screen and doesn't affect the dc level
|
|
|
+ // clipping
|
|
|
+ void DrawToDCClipped(wxDC *dc, const wxRect& rect);
|
|
|
+ void DrawToDCClippedRgn(wxDC *dc, const wxRegion& region);
|
|
|
+ // draw to dc with no clipping (well the dc will still clip)
|
|
|
+ void DrawToDC(wxDC *dc);
|
|
|
+ // draw a single object to the dc
|
|
|
+ void DrawIdToDC(int id, wxDC *dc);
|
|
|
+
|
|
|
+ // ------------------------------------------------------------------------
|
|
|
+ // Hit Detection Methods
|
|
|
+ //
|
|
|
+ // returns list of object with a drawn pixel within radius pixels of (x,y)
|
|
|
+ // the list is in reverse draw order so last drawn is first in list
|
|
|
+ // PyObject *HitTest(wxCoord x, wxCoord y, double radius)
|
|
|
+ // returns list of objects whose bounding boxes include (x,y)
|
|
|
+ // PyObject *HitTestBB(wxCoord x, wxCoord y)
|
|
|
+
|
|
|
+
|
|
|
+ // ------------------------------------------------------------------------
|
|
|
+ // Methods mirrored from wxDC
|
|
|
+ //
|
|
|
+ void FloodFill(wxCoord x, wxCoord y, const wxColour& col,
|
|
|
+ int style = wxFLOOD_SURFACE)
|
|
|
+ {AddToList(new gpdcFloodFillOp(x,y,col,style));}
|
|
|
+ void FloodFill(const wxPoint& pt, const wxColour& col,
|
|
|
+ int style = wxFLOOD_SURFACE)
|
|
|
+ { FloodFill(pt.x, pt.y, col, style); }
|
|
|
+
|
|
|
+ void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
|
|
|
+ {AddToList(new gpdcDrawLineOp(x1, y1, x2, y2));}
|
|
|
+ void DrawLine(const wxPoint& pt1, const wxPoint& pt2)
|
|
|
+ { DrawLine(pt1.x, pt1.y, pt2.x, pt2.y); }
|
|
|
+
|
|
|
+ void CrossHair(wxCoord x, wxCoord y)
|
|
|
+ {AddToList(new gpdcCrossHairOp(x,y));}
|
|
|
+ void CrossHair(const wxPoint& pt)
|
|
|
+ { CrossHair(pt.x, pt.y); }
|
|
|
+
|
|
|
+ void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
|
|
|
+ wxCoord xc, wxCoord yc)
|
|
|
+ {AddToList(new gpdcDrawArcOp(x1,y1,x2,y2,xc,yc));}
|
|
|
+ void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre)
|
|
|
+ { DrawArc(pt1.x, pt1.y, pt2.x, pt2.y, centre.x, centre.y); }
|
|
|
+
|
|
|
+ void DrawCheckMark(wxCoord x, wxCoord y,
|
|
|
+ wxCoord width, wxCoord height)
|
|
|
+ {AddToList(new gpdcDrawCheckMarkOp(x,y,width,height));}
|
|
|
+ void DrawCheckMark(const wxRect& rect)
|
|
|
+ { DrawCheckMark(rect.x, rect.y, rect.width, rect.height); }
|
|
|
+
|
|
|
+ void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
|
|
|
+ double sa, double ea)
|
|
|
+ {AddToList(new gpdcDrawEllipticArcOp(x,y,w,h,sa,ea));}
|
|
|
+ void DrawEllipticArc(const wxPoint& pt, const wxSize& sz,
|
|
|
+ double sa, double ea)
|
|
|
+ { DrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea); }
|
|
|
+
|
|
|
+ void DrawPoint(wxCoord x, wxCoord y)
|
|
|
+ {AddToList(new gpdcDrawPointOp(x,y));}
|
|
|
+ void DrawPoint(const wxPoint& pt)
|
|
|
+ { DrawPoint(pt.x, pt.y); }
|
|
|
+
|
|
|
+ void DrawPolygon(int n, wxPoint points[],
|
|
|
+ wxCoord xoffset = 0, wxCoord yoffset = 0,
|
|
|
+ int fillStyle = wxODDEVEN_RULE)
|
|
|
+ {AddToList(new gpdcDrawPolygonOp(n,points,xoffset,yoffset,fillStyle));}
|
|
|
+
|
|
|
+ void DrawPolyPolygon(int n, int count[], wxPoint points[],
|
|
|
+ wxCoord xoffset = 0, wxCoord yoffset = 0,
|
|
|
+ int fillStyle = wxODDEVEN_RULE)
|
|
|
+ {AddToList(new gpdcDrawPolyPolygonOp(n,count,points,xoffset,yoffset,fillStyle));}
|
|
|
+
|
|
|
+ void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
|
|
|
+ {AddToList(new gpdcDrawRectangleOp(x, y, width, height));}
|
|
|
+ void DrawRectangle(const wxPoint& pt, const wxSize& sz)
|
|
|
+ { DrawRectangle(pt.x, pt.y, sz.x, sz.y); }
|
|
|
+ void DrawRectangle(const wxRect& rect)
|
|
|
+ { DrawRectangle(rect.x, rect.y, rect.width, rect.height); }
|
|
|
+
|
|
|
+ void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height,
|
|
|
+ double radius)
|
|
|
+ {AddToList(new gpdcDrawRoundedRectangleOp(x,y,width,height,radius));}
|
|
|
+ void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz,
|
|
|
+ double radius)
|
|
|
+ { DrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius); }
|
|
|
+ void DrawRoundedRectangle(const wxRect& r, double radius)
|
|
|
+ { DrawRoundedRectangle(r.x, r.y, r.width, r.height, radius); }
|
|
|
+
|
|
|
+ void DrawCircle(wxCoord x, wxCoord y, wxCoord radius)
|
|
|
+ { DrawEllipse(x - radius, y - radius, 2*radius, 2*radius); }
|
|
|
+ void DrawCircle(const wxPoint& pt, wxCoord radius)
|
|
|
+ { DrawCircle(pt.x, pt.y, radius); }
|
|
|
+
|
|
|
+ void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
|
|
|
+ {AddToList(new gpdcDrawEllipseOp(x,y,width,height));}
|
|
|
+ void DrawEllipse(const wxPoint& pt, const wxSize& sz)
|
|
|
+ { DrawEllipse(pt.x, pt.y, sz.x, sz.y); }
|
|
|
+ void DrawEllipse(const wxRect& rect)
|
|
|
+ { DrawEllipse(rect.x, rect.y, rect.width, rect.height); }
|
|
|
+
|
|
|
+ void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
|
|
|
+ {AddToList(new gpdcDrawIconOp(icon,x,y));}
|
|
|
+ void DrawIcon(const wxIcon& icon, const wxPoint& pt)
|
|
|
+ { DrawIcon(icon, pt.x, pt.y); }
|
|
|
+
|
|
|
+ void DrawLines(int n, wxPoint points[],
|
|
|
+ wxCoord xoffset = 0, wxCoord yoffset = 0)
|
|
|
+ {AddToList(new gpdcDrawLinesOp(n,points,xoffset,yoffset));}
|
|
|
+
|
|
|
+ void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
|
|
|
+ bool useMask = false)
|
|
|
+ {AddToList(new gpdcDrawBitmapOp(bmp,x,y,useMask));}
|
|
|
+ void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt,
|
|
|
+ bool useMask = false)
|
|
|
+ { DrawBitmap(bmp, pt.x, pt.y, useMask); }
|
|
|
+
|
|
|
+ void DrawText(const wxString& text, wxCoord x, wxCoord y)
|
|
|
+ {AddToList(new gpdcDrawTextOp(text, x, y));}
|
|
|
+ void DrawText(const wxString& text, const wxPoint& pt)
|
|
|
+ { DrawText(text, pt.x, pt.y); }
|
|
|
+
|
|
|
+ void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle)
|
|
|
+ {AddToList(new gpdcDrawRotatedTextOp(text,x,y,angle));}
|
|
|
+ void DrawRotatedText(const wxString& text, const wxPoint& pt, double angle)
|
|
|
+ { DrawRotatedText(text, pt.x, pt.y, angle); }
|
|
|
+
|
|
|
+ // this version puts both optional bitmap and the text into the given
|
|
|
+ // rectangle and aligns is as specified by alignment parameter; it also
|
|
|
+ // will emphasize the character with the given index if it is != -1
|
|
|
+ void DrawLabel(const wxString& text,
|
|
|
+ const wxBitmap& image,
|
|
|
+ const wxRect& rect,
|
|
|
+ int alignment = wxALIGN_LEFT | wxALIGN_TOP,
|
|
|
+ int indexAccel = -1)
|
|
|
+ {AddToList(new gpdcDrawLabelOp(text,image,rect,alignment,indexAccel));}
|
|
|
+
|
|
|
+ void DrawLabel(const wxString& text, const wxRect& rect,
|
|
|
+ int alignment = wxALIGN_LEFT | wxALIGN_TOP,
|
|
|
+ int indexAccel = -1)
|
|
|
+ { DrawLabel(text, wxNullBitmap, rect, alignment, indexAccel); }
|
|
|
+
|
|
|
+/*?????? I don't think that the source dc would stick around
|
|
|
+ void Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
|
|
|
+ wxDC *source, wxCoord xsrc, wxCoord ysrc,
|
|
|
+ int rop = wxCOPY, bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord)
|
|
|
+ {AddToList(new gpdcBlitOp(xdest,ydest,width,height,source,xsrc,
|
|
|
+ ysrc,rop,useMask,xsrcMask,ysrcMask));}
|
|
|
+ void Blit(const wxPoint& destPt, const wxSize& sz,
|
|
|
+ wxDC *source, const wxPoint& srcPt,
|
|
|
+ int rop = wxCOPY, bool useMask = false, const wxPoint& srcPtMask = wxDefaultPosition)
|
|
|
+ {
|
|
|
+ Blit(destPt.x, destPt.y, sz.x, sz.y, source, srcPt.x, srcPt.y,
|
|
|
+ rop, useMask, srcPtMask.x, srcPtMask.y);
|
|
|
+ }
|
|
|
+??????*/
|
|
|
+
|
|
|
+#if wxUSE_SPLINES
|
|
|
+ void DrawSpline(int n, wxPoint points[])
|
|
|
+ {AddToList(new gpdcDrawSplineOp(n,points));}
|
|
|
+#endif // wxUSE_SPLINES
|
|
|
+
|
|
|
+#if wxUSE_PALETTE
|
|
|
+ void SetPalette(const wxPalette& palette)
|
|
|
+ {AddToList(new gpdcSetPaletteOp(palette));}
|
|
|
+#endif // wxUSE_PALETTE
|
|
|
+
|
|
|
+ void SetLogicalFunction(int function)
|
|
|
+ {AddToList(new gpdcSetLogicalFunctionOp(function));}
|
|
|
+ void SetFont(const wxFont& font)
|
|
|
+ {AddToList(new gpdcSetFontOp(font));}
|
|
|
+ void SetPen(const wxPen& pen)
|
|
|
+ {AddToList(new gpdcSetPenOp(pen));}
|
|
|
+ void SetBrush(const wxBrush& brush)
|
|
|
+ {AddToList(new gpdcSetBrushOp(brush));}
|
|
|
+ void SetBackground(const wxBrush& brush)
|
|
|
+ {AddToList(new gpdcSetBackgroundOp(brush));}
|
|
|
+ void SetBackgroundMode(int mode)
|
|
|
+ {AddToList(new gpdcSetBackgroundModeOp(mode));}
|
|
|
+ void SetTextBackground(const wxColour& colour)
|
|
|
+ {AddToList(new gpdcSetTextBackgroundOp(colour));}
|
|
|
+ void SetTextForeground(const wxColour& colour)
|
|
|
+ {AddToList(new gpdcSetTextForegroundOp(colour));}
|
|
|
+
|
|
|
+ void Clear()
|
|
|
+ {AddToList(new gpdcClearOp());}
|
|
|
+ void BeginDrawing()
|
|
|
+ {AddToList(new gpdcBeginDrawingOp());}
|
|
|
+ void EndDrawing()
|
|
|
+ {AddToList(new gpdcEndDrawingOp());}
|
|
|
+
|
|
|
+protected:
|
|
|
+ // ------------------------------------------------------------------------
|
|
|
+ // protected helper methods
|
|
|
+ void AddToList(gpdcOp *newOp);
|
|
|
+ gpdcObject *FindObject(int id, bool create=false);
|
|
|
+
|
|
|
+ // ------------------------------------------------------------------------
|
|
|
+ // Data members
|
|
|
+ //
|
|
|
+ int m_currId; // id to use for operations done on the PseudoDC
|
|
|
+ gpdcObject *m_lastObject; // used to find last used object quickly
|
|
|
+ gpdcObjectList m_objectlist; // list of objects
|
|
|
+ gpdcObjectHash m_objectIndex; //id->object lookup index
|
|
|
+
|
|
|
+};
|
|
|
+
|
|
|
+#endif
|
|
|
+
|
Glynn Clements