361bd11400
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@40833 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
737 lines
25 KiB
C++
737 lines
25 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
// Name: pseudodc.h
|
|
// Purpose: wxPseudoDC class
|
|
// Author: Paul Lanier
|
|
// Modified by:
|
|
// Created: 05/25/06
|
|
// RCS-ID: $Id$
|
|
// Copyright: (c) wxWidgets team
|
|
// Licence: wxWindows licence
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
#ifndef _WX_PSUEDO_DC_H_BASE_
|
|
#define _WX_PSUEDO_DC_H_BASE_
|
|
|
|
#include "wx/wx.h"
|
|
#include "wx/dc.h"
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Base class for all pdcOp classes
|
|
//----------------------------------------------------------------------------
|
|
class pdcOp
|
|
{
|
|
public:
|
|
// Constructor and Destructor
|
|
pdcOp() {}
|
|
virtual ~pdcOp() {}
|
|
|
|
// Virtual Drawing Methods
|
|
virtual void DrawToDC(wxDC *dc)=0;
|
|
virtual void Translate(wxCoord WXUNUSED(dx), wxCoord WXUNUSED(dy)) {}
|
|
};
|
|
|
|
//----------------------------------------------------------------------------
|
|
// declare a list class for list of pdcOps
|
|
//----------------------------------------------------------------------------
|
|
WX_DECLARE_LIST(pdcOp, pdcOpList);
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Classes derived from pdcOp
|
|
// There is one class for each method mirrored from wxDC to wxPseudoDC
|
|
//----------------------------------------------------------------------------
|
|
class pdcSetFontOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcSetFontOp(const wxFont& font)
|
|
{m_font=font;}
|
|
virtual void DrawToDC(wxDC *dc) {dc->SetFont(m_font);}
|
|
protected:
|
|
wxFont m_font;
|
|
};
|
|
|
|
class pdcSetBrushOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcSetBrushOp(const wxBrush& brush)
|
|
{m_brush=brush;}
|
|
virtual void DrawToDC(wxDC *dc) {dc->SetBrush(m_brush);}
|
|
protected:
|
|
wxBrush m_brush;
|
|
};
|
|
|
|
class pdcSetBackgroundOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcSetBackgroundOp(const wxBrush& brush)
|
|
{m_brush=brush;}
|
|
virtual void DrawToDC(wxDC *dc) {dc->SetBackground(m_brush);}
|
|
protected:
|
|
wxBrush m_brush;
|
|
};
|
|
|
|
class pdcSetPenOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcSetPenOp(const wxPen& pen)
|
|
{m_pen=pen;}
|
|
virtual void DrawToDC(wxDC *dc) {dc->SetPen(m_pen);}
|
|
protected:
|
|
wxPen m_pen;
|
|
};
|
|
|
|
class pdcSetTextBackgroundOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcSetTextBackgroundOp(const wxColour& colour)
|
|
{m_colour=colour;}
|
|
virtual void DrawToDC(wxDC *dc) {dc->SetTextBackground(m_colour);}
|
|
protected:
|
|
wxColour m_colour;
|
|
};
|
|
|
|
class pdcSetTextForegroundOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcSetTextForegroundOp(const wxColour& colour)
|
|
{m_colour=colour;}
|
|
virtual void DrawToDC(wxDC *dc) {dc->SetTextForeground(m_colour);}
|
|
protected:
|
|
wxColour m_colour;
|
|
};
|
|
|
|
class pdcDrawRectangleOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawRectangleOp(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) {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 pdcDrawLineOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawLineOp(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) {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 pdcSetBackgroundModeOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcSetBackgroundModeOp(int mode) {m_mode=mode;}
|
|
virtual void DrawToDC(wxDC *dc) {dc->SetBackgroundMode(m_mode);}
|
|
protected:
|
|
int m_mode;
|
|
};
|
|
|
|
class pdcDrawTextOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawTextOp(const wxString& text, wxCoord x, wxCoord y)
|
|
{m_text=text; m_x=x; m_y=y;}
|
|
virtual void DrawToDC(wxDC *dc) {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 pdcClearOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcClearOp() {}
|
|
virtual void DrawToDC(wxDC *dc) {dc->Clear();}
|
|
};
|
|
|
|
class pdcBeginDrawingOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcBeginDrawingOp() {}
|
|
virtual void DrawToDC(wxDC *) {}
|
|
};
|
|
|
|
class pdcEndDrawingOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcEndDrawingOp() {}
|
|
virtual void DrawToDC(wxDC *) {}
|
|
};
|
|
|
|
class pdcFloodFillOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcFloodFillOp(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) {dc->FloodFill(m_x,m_y,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 pdcCrossHairOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcCrossHairOp(wxCoord x, wxCoord y) {m_x=x; m_y=y;}
|
|
virtual void DrawToDC(wxDC *dc) {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 pdcDrawArcOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawArcOp(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)
|
|
{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 pdcDrawCheckMarkOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawCheckMarkOp(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)
|
|
{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 pdcDrawEllipticArcOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawEllipticArcOp(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)
|
|
{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 pdcDrawPointOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawPointOp(wxCoord x, wxCoord y)
|
|
{m_x=x; m_y=y;}
|
|
virtual void DrawToDC(wxDC *dc) {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 pdcDrawRoundedRectangleOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawRoundedRectangleOp(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)
|
|
{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 pdcDrawEllipseOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawEllipseOp(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) {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 pdcDrawIconOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawIconOp(const wxIcon& icon, wxCoord x, wxCoord y)
|
|
{m_icon=icon; m_x=x; m_y=y;}
|
|
virtual void DrawToDC(wxDC *dc) {dc->DrawIcon(m_icon,m_x,m_y);}
|
|
virtual void Translate(wxCoord dx, wxCoord dy)
|
|
{m_x+=dx; m_y+=dy;}
|
|
protected:
|
|
wxIcon m_icon;
|
|
wxCoord m_x,m_y;
|
|
};
|
|
|
|
class pdcDrawLinesOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawLinesOp(int n, wxPoint points[],
|
|
wxCoord xoffset = 0, wxCoord yoffset = 0);
|
|
virtual ~pdcDrawLinesOp();
|
|
virtual void DrawToDC(wxDC *dc)
|
|
{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 pdcDrawPolygonOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawPolygonOp(int n, wxPoint points[],
|
|
wxCoord xoffset = 0, wxCoord yoffset = 0,
|
|
int fillStyle = wxODDEVEN_RULE);
|
|
virtual ~pdcDrawPolygonOp();
|
|
virtual void DrawToDC(wxDC *dc)
|
|
{ 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 pdcDrawPolyPolygonOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawPolyPolygonOp(int n, int count[], wxPoint points[],
|
|
wxCoord xoffset = 0, wxCoord yoffset = 0,
|
|
int fillStyle = wxODDEVEN_RULE);
|
|
virtual ~pdcDrawPolyPolygonOp();
|
|
virtual void DrawToDC(wxDC *dc)
|
|
{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 pdcDrawRotatedTextOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawRotatedTextOp(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)
|
|
{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 pdcDrawBitmapOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawBitmapOp(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) {dc->DrawBitmap(m_bmp,m_x,m_y,m_useMask);}
|
|
virtual void Translate(wxCoord dx, wxCoord dy)
|
|
{m_x+=dx; m_y+=dy;}
|
|
protected:
|
|
wxBitmap m_bmp;
|
|
wxCoord m_x,m_y;
|
|
bool m_useMask;
|
|
};
|
|
|
|
class pdcDrawLabelOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawLabelOp(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)
|
|
{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 pdcDrawSplineOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcDrawSplineOp(int n, wxPoint points[]);
|
|
virtual ~pdcDrawSplineOp();
|
|
virtual void DrawToDC(wxDC *dc) {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 pdcSetPaletteOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcSetPaletteOp(const wxPalette& palette) {m_palette=palette;}
|
|
virtual void DrawToDC(wxDC *dc) {dc->SetPalette(m_palette);}
|
|
protected:
|
|
wxPalette m_palette;
|
|
};
|
|
#endif // wxUSE_PALETTE
|
|
|
|
class pdcSetLogicalFunctionOp : public pdcOp
|
|
{
|
|
public:
|
|
pdcSetLogicalFunctionOp(int function) {m_function=function;}
|
|
virtual void DrawToDC(wxDC *dc) {dc->SetLogicalFunction(m_function);}
|
|
protected:
|
|
int m_function;
|
|
};
|
|
|
|
//----------------------------------------------------------------------------
|
|
// pdcObject type to contain list of operations for each real (Python) object
|
|
//----------------------------------------------------------------------------
|
|
class pdcObject
|
|
{
|
|
public:
|
|
pdcObject(int id)
|
|
{m_id=id; m_bounded=false; m_oplist.DeleteContents(true);}
|
|
|
|
virtual ~pdcObject() {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;}
|
|
|
|
// Op List Management Methods
|
|
void Clear() {m_oplist.Clear();}
|
|
void AddOp(pdcOp *op) {m_oplist.Append(op);}
|
|
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 pdcObject
|
|
// 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
|
|
pdcOpList m_oplist; // list of operations for this object
|
|
};
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// 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 pdcObjectList;
|
|
WX_DECLARE_LIST(pdcObject, pdcObjectList);
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxPseudoDC 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 wxPseudoDC : public wxObject
|
|
{
|
|
public:
|
|
wxPseudoDC()
|
|
{m_currId=-1; m_lastObjNode=NULL; m_objectlist.DeleteContents(true);}
|
|
~wxPseudoDC();
|
|
// ------------------------------------------------------------------------
|
|
// 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);
|
|
|
|
// ------------------------------------------------------------------------
|
|
// 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);
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Methods mirrored from wxDC
|
|
//
|
|
void FloodFill(wxCoord x, wxCoord y, const wxColour& col,
|
|
int style = wxFLOOD_SURFACE)
|
|
{AddToList(new pdcFloodFillOp(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 pdcDrawLineOp(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 pdcCrossHairOp(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 pdcDrawArcOp(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 pdcDrawCheckMarkOp(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 pdcDrawEllipticArcOp(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 pdcDrawPointOp(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 pdcDrawPolygonOp(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 pdcDrawPolyPolygonOp(n,count,points,xoffset,yoffset,fillStyle));}
|
|
|
|
void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
|
|
{AddToList(new pdcDrawRectangleOp(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 pdcDrawRoundedRectangleOp(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 pdcDrawEllipseOp(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 pdcDrawIconOp(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 pdcDrawLinesOp(n,points,xoffset,yoffset));}
|
|
|
|
void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
|
|
bool useMask = false)
|
|
{AddToList(new pdcDrawBitmapOp(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 pdcDrawTextOp(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 pdcDrawRotatedTextOp(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 pdcDrawLabelOp(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 pdcBlitOp(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 pdcDrawSplineOp(n,points));}
|
|
#endif // wxUSE_SPLINES
|
|
|
|
#if wxUSE_PALETTE
|
|
void SetPalette(const wxPalette& palette)
|
|
{AddToList(new pdcSetPaletteOp(palette));}
|
|
#endif // wxUSE_PALETTE
|
|
|
|
void SetLogicalFunction(int function)
|
|
{AddToList(new pdcSetLogicalFunctionOp(function));}
|
|
void SetFont(const wxFont& font)
|
|
{AddToList(new pdcSetFontOp(font));}
|
|
void SetPen(const wxPen& pen)
|
|
{AddToList(new pdcSetPenOp(pen));}
|
|
void SetBrush(const wxBrush& brush)
|
|
{AddToList(new pdcSetBrushOp(brush));}
|
|
void SetBackground(const wxBrush& brush)
|
|
{AddToList(new pdcSetBackgroundOp(brush));}
|
|
void SetBackgroundMode(int mode)
|
|
{AddToList(new pdcSetBackgroundModeOp(mode));}
|
|
void SetTextBackground(const wxColour& colour)
|
|
{AddToList(new pdcSetTextBackgroundOp(colour));}
|
|
void SetTextForeground(const wxColour& colour)
|
|
{AddToList(new pdcSetTextForegroundOp(colour));}
|
|
|
|
void Clear()
|
|
{AddToList(new pdcClearOp());}
|
|
void BeginDrawing()
|
|
{AddToList(new pdcBeginDrawingOp());}
|
|
void EndDrawing()
|
|
{AddToList(new pdcEndDrawingOp());}
|
|
|
|
protected:
|
|
// ------------------------------------------------------------------------
|
|
// protected helper methods
|
|
void AddToList(pdcOp *newOp);
|
|
pdcObjectList::Node *FindObjNode(int id, bool create=false);
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Data members
|
|
//
|
|
int m_currId; // id to use for operations done on the PseudoDC
|
|
pdcObjectList::Node *m_lastObjNode; // used to find last used object quickly
|
|
pdcObjectList m_objectlist; // list of objects
|
|
};
|
|
|
|
#endif
|
|
|