utils/wxPython/src/gdi.i

/////////////////////////////////////////////////////////////////////////////
// Name:        gdi.i
// Purpose:     SWIG interface file for wxDC, wxBrush, wxPen, wxFont, etc.
//
// Author:      Robin Dunn
//
// Created:     7/7/97
// RCS-ID:      $Id$
// Copyright:   (c) 1998 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////


%module gdi

%{
#include "helpers.h"
#include <wx/metafile.h>
#include <wx/imaglist.h>
#ifndef __WXMSW__
#include <wx/dcps.h>
#endif
%}

//----------------------------------------------------------------------

%include typemaps.i
%include my_typemaps.i

// Import some definitions of other classes, etc.
%import _defs.i
%import misc.i

//---------------------------------------------------------------------------

class wxBitmap {
public:
    wxBitmap(const wxString& name, long type);
    ~wxBitmap();

#ifdef __WXMSW__
    void Create(int width, int height, int depth = -1);
#endif
    int GetDepth();
    int GetHeight();
    wxPalette* GetPalette();
    wxMask* GetMask();
    int GetWidth();
    bool LoadFile(const wxString& name, long flags);
    bool Ok();
    bool SaveFile(const wxString& name, int type, wxPalette* palette = NULL);
    void SetDepth(int depth);
    void SetHeight(int height);
    void SetMask(wxMask* mask);
#ifdef __WXMSW__
    void SetPalette(wxPalette& palette);
#endif
    void SetWidth(int width);
};

%new wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1);
wxBitmap* wxNoRefBitmap(char* name, long flags);

#ifdef __WXMSW__
%new wxBitmap* wxBitmapFromData(char* data, long type,
                                int width, int height, int depth = 1);
#endif

%{                              // Alternate 'constructor'
    wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1) {
        return new wxBitmap(width, height, depth);
    }

                                // This one won't own the reference, so Python
                                // won't call the dtor, this is good for
                                // toolbars and such where the parent will
                                // manage the bitmap.
    wxBitmap* wxNoRefBitmap(char* name, long flags) {
        return new wxBitmap(name, flags);
    }

#ifdef __WXMSW__
    wxBitmap* wxBitmapFromData(char* data, long type,
                               int width, int height, int depth = 1) {
        return new wxBitmap((void*)data, type, width, height, depth);
    }
#endif
%}

//---------------------------------------------------------------------------

class wxMask {
public:
    wxMask(const wxBitmap& bitmap);
    ~wxMask();
};

%new wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour);
%{
    wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour) {
        return new wxMask(bitmap, colour);
    }
%}


//---------------------------------------------------------------------------


class wxIcon : public wxBitmap {
public:
    wxIcon(const wxString& name, long flags,
           int desiredWidth = -1, int desiredHeight = -1);
    ~wxIcon();

    int GetDepth();
    int GetHeight();
    int GetWidth();
    bool LoadFile(const wxString& name, long flags);
    bool Ok();
    void SetDepth(int depth);
    void SetHeight(int height);
    void SetWidth(int width);
};


//---------------------------------------------------------------------------

class wxCursor : public wxBitmap {
public:
#ifdef __WXMSW__
    wxCursor(const wxString& cursorName, long flags, int hotSpotX=0, int hotSpotY=0);
#endif
    ~wxCursor();
    bool Ok();
};

%name(wxStockCursor) %new wxCursor* wxPyStockCursor(int id);
%{                              // Alternate 'constructor'
    wxCursor* wxPyStockCursor(int id) {
        return new wxCursor(id);
    }
%}

//----------------------------------------------------------------------

class wxFont {
public:
    // I'll do it this way to use long-lived objects and not have to
    // worry about when python may delete the object.
    %addmethods {
        wxFont( int pointSize, int family, int style, int weight,
                int underline=FALSE, char* faceName = "") {

            return wxTheFontList->FindOrCreateFont(pointSize, family, style, weight,
                                                   underline, faceName);
        }
        // NO Destructor.
    }


    wxString GetFaceName();
    int GetFamily();
#ifdef __WXMSW__
    int GetFontId();
#endif
    int GetPointSize();
    int GetStyle();
    bool GetUnderlined();
    int GetWeight();
    void SetFaceName(const wxString& faceName);
    void SetFamily(int family);
    void SetPointSize(int pointSize);
    void SetStyle(int style);
    void SetUnderlined(bool underlined);
    void SetWeight(int weight);
};

//----------------------------------------------------------------------

class wxColour {
public:
    wxColour(unsigned char red=0, unsigned char green=0, unsigned char blue=0);
    ~wxColour();
    unsigned char Red();
    unsigned char Green();
    unsigned char Blue();
    bool Ok();
    void Set(unsigned char red, unsigned char green, unsigned char blue);
    %addmethods {
        PyObject* Get() {
            PyObject* rv = PyTuple_New(3);
            PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red()));
            PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green()));
            PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue()));
            return rv;
        }
    }
};

%new wxColour* wxNamedColour(const wxString& colorName);
%{                                      // Alternate 'constructor'
    wxColour* wxNamedColour(const wxString& colorName) {
        return new wxColour(colorName);
    }
%}


//----------------------------------------------------------------------

typedef unsigned long wxDash;

class wxPen {
public:
    // I'll do it this way to use long-lived objects and not have to
    // worry about when python may delete the object.
    %addmethods {
        wxPen(wxColour* colour, int width=1, int style=wxSOLID) {
            return wxThePenList->FindOrCreatePen(*colour, width, style);
        }
        // NO Destructor.
    }

    int GetCap();
    wxColour& GetColour();

    int GetJoin();
    int GetStyle();
    int GetWidth();
    bool Ok();
    void SetCap(int cap_style);
    void SetColour(wxColour& colour);
    void SetJoin(int join_style);
    void SetStyle(int style);
    void SetWidth(int width);

#ifdef __WXMSW__
            // **** This one needs to return a list of ints (wxDash)
    int GetDashes(wxDash **dashes);
    wxBitmap* GetStipple();
    void SetDashes(int LCOUNT, wxDash* LIST);
    void SetStipple(wxBitmap& stipple);
#endif
};

//----------------------------------------------------------------------

class wxBrush {
public:
    // I'll do it this way to use long-lived objects and not have to
    // worry about when python may delete the object.
    %addmethods {
        wxBrush(wxColour* colour, int style=wxSOLID) {
            return wxTheBrushList->FindOrCreateBrush(*colour, style);
        }
        // NO Destructor.
    }

    wxColour& GetColour();
    wxBitmap * GetStipple();
    int GetStyle();
    bool Ok();
    void SetColour(wxColour &colour);
    void SetStipple(wxBitmap& bitmap);
    void SetStyle(int style);
};

//----------------------------------------------------------------------


class wxDC {
public:
//    wxDC(); **** abstract base class, can't instantiate.
    ~wxDC();

    void BeginDrawing();
//  %name(BlitXY)
    bool Blit(long xdest, long ydest,
              long width, long height,
              wxDC *source, long xsrc, long ysrc,
              int logicalFunc = wxCOPY, int useMask = FALSE);
//      bool Blit(const wxPoint& destPt, const wxSize& sz,
//                wxDC *source, const wxPoint& srcPt,
//                int logicalFunc = wxCOPY, int useMask = FALSE);

    void Clear();
    void CrossHair(long x, long y);
    void DestroyClippingRegion();
    long DeviceToLogicalX(long x);
    long DeviceToLogicalXRel(long x);
    long DeviceToLogicalY(long y);
    long DeviceToLogicalYRel(long y);
    void DrawArc(long x1, long y1, long x2, long y2, long xc, long yc);
    void DrawCircle(long x, long y, long radius);
    void DrawEllipse(long x, long y, long width, long height);
    void DrawEllipticArc(long x, long y, long width, long height, long start, long end);
    void DrawIcon(const wxIcon& icon, long x, long y);
    void DrawLine(long x1, long y1, long x2, long y2);
    void DrawLines(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0);
    void DrawPolygon(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0,
                     int fill_style=wxODDEVEN_RULE);
    void DrawPoint(long x, long y);
    void DrawRectangle(long x, long y, long width, long height);
    void DrawRoundedRectangle(long x, long y, long width, long height, long radius=20);
    void DrawSpline(int LCOUNT, wxPoint* LIST);
    void DrawText(const wxString& text, long x, long y);
    void EndDoc();
    void EndDrawing();
    void EndPage();
    void FloodFill(long x, long y, const wxColour& colour, int style=wxFLOOD_SURFACE);
    wxBrush&  GetBackground();
    wxBrush&  GetBrush();
    long GetCharHeight();
    long GetCharWidth();
    void GetClippingBox(long *OUTPUT, long *OUTPUT,
                        long *OUTPUT, long *OUTPUT);
    wxFont& GetFont();
    int GetLogicalFunction();
    int GetMapMode();
    bool GetOptimization();
    wxPen& GetPen();
    %addmethods {
        %new wxColour* GetPixel(long x, long y) {
            wxColour* wc = new wxColour();
            self->GetPixel(x, y, wc);
            return wc;
        }
    }
    %name(GetSizeTuple)void GetSize(int* OUTPUT, int* OUTPUT);
    wxSize GetSize();
    wxColour& GetTextBackground();
    void GetTextExtent(const wxString& string, long *OUTPUT, long *OUTPUT);
    %name(GetFullTextExtent)void GetTextExtent(const wxString& string,
                       long *OUTPUT, long *OUTPUT, long *OUTPUT, long* OUTPUT,
                       const wxFont* font = NULL);
    wxColour& GetTextForeground();
    long LogicalToDeviceX(long x);
    long LogicalToDeviceXRel(long x);
    long LogicalToDeviceY(long y);
    long LogicalToDeviceYRel(long y);
    long MaxX();
    long MaxY();
    long MinX();
    long MinY();
    bool Ok();
    void SetDeviceOrigin(long x, long y);
    void SetBackground(const wxBrush& brush);
    void SetBackgroundMode(int mode);
    void SetClippingRegion(long x, long y, long width, long height);
    void SetPalette(const wxPalette& colourMap);
    void SetBrush(const wxBrush& brush);
    void SetFont(const wxFont& font);
    void SetLogicalFunction(int function);
    void SetMapMode(int mode);
    void SetOptimization(bool optimize);
    void SetPen(const wxPen& pen);
    void SetTextBackground(const wxColour& colour);
    void SetTextForeground(const wxColour& colour);
    void SetUserScale(double x_scale, double y_scale);
    bool StartDoc(const wxString& message);
    void StartPage();


//  Don't need this one anymore as wxWindows has one...
//      %addmethods {
//              // This one is my own creation...
//          void DrawBitmap(wxBitmap& bitmap, long x, long y, bool swapPalette=TRUE) {
//              wxMemoryDC* memDC = new wxMemoryDC;
//              memDC->SelectObject(bitmap);
//  #ifdef __WXMSW__
//              if (swapPalette)
//                  self->SetPalette(*bitmap.GetPalette());
//  #endif
//              self->Blit(x, y, bitmap.GetWidth(), bitmap.GetHeight(), memDC,
//                      0, 0, self->GetLogicalFunction());
//              memDC->SelectObject(wxNullBitmap);
//              delete memDC;
//          }
//      }

    void DrawBitmap(const wxBitmap& bitmap, long x, long y,
                    int useMask = FALSE);

};


//----------------------------------------------------------------------

class wxMemoryDC : public wxDC {
public:
    wxMemoryDC();

    void SelectObject(const wxBitmap& bitmap);
}

%new wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC);
%{                                      // Alternate 'constructor'
    wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC) {
        return new wxMemoryDC(oldDC);
    }
%}


//---------------------------------------------------------------------------

class wxScreenDC : public wxDC {
public:
    wxScreenDC();

    bool StartDrawingOnTop(wxWindow* window);
    %name(StartDrawingOnTopRect) bool StartDrawingOnTop(wxRect* rect = NULL);
    bool EndDrawingOnTop();
};

//---------------------------------------------------------------------------

class wxClientDC : public wxDC {
public:
      wxClientDC(wxWindow* win);
};

//---------------------------------------------------------------------------

class wxPaintDC : public wxDC {
public:
      wxPaintDC(wxWindow* win);
};

//---------------------------------------------------------------------------

class wxWindowDC : public wxDC {
public:
      wxWindowDC(wxWindow* win);
};

//---------------------------------------------------------------------------

#ifndef __WXMSW__
class wxPostScriptDC : public wxDC {
public:
      wxPostScriptDC(const wxString& output, bool interactive = TRUE, wxWindow* win = NULL);
};
#endif

//---------------------------------------------------------------------------

#ifdef __WXMSW__
class  wxPrinterDC : public wxDC {
public:
    wxPrinterDC(const wxString& driver, const wxString& device, const wxString& output,
                bool interactive = TRUE, int orientation = wxPORTRAIT);
};
#endif

//---------------------------------------------------------------------------

#ifdef __WXMSW__
class wxMetaFileDC : public wxDC {
public:
    wxMetaFileDC(const wxString& filename = wxPyEmptyStr);
    wxMetaFile* Close();
};
#endif

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------


%readonly
%{
#if 0
%}
extern wxFont *wxNORMAL_FONT;
extern wxFont *wxSMALL_FONT;
extern wxFont *wxITALIC_FONT;
extern wxFont *wxSWISS_FONT;

extern wxPen *wxRED_PEN;
extern wxPen *wxCYAN_PEN;
extern wxPen *wxGREEN_PEN;
extern wxPen *wxBLACK_PEN;
extern wxPen *wxWHITE_PEN;
extern wxPen *wxTRANSPARENT_PEN;
extern wxPen *wxBLACK_DASHED_PEN;
extern wxPen *wxGREY_PEN;
extern wxPen *wxMEDIUM_GREY_PEN;
extern wxPen *wxLIGHT_GREY_PEN;

extern wxBrush *wxBLUE_BRUSH;
extern wxBrush *wxGREEN_BRUSH;
extern wxBrush *wxWHITE_BRUSH;
extern wxBrush *wxBLACK_BRUSH;
extern wxBrush *wxTRANSPARENT_BRUSH;
extern wxBrush *wxCYAN_BRUSH;
extern wxBrush *wxRED_BRUSH;
extern wxBrush *wxGREY_BRUSH;
extern wxBrush *wxMEDIUM_GREY_BRUSH;
extern wxBrush *wxLIGHT_GREY_BRUSH;

extern wxColour *wxBLACK;
extern wxColour *wxWHITE;
extern wxColour *wxRED;
extern wxColour *wxBLUE;
extern wxColour *wxGREEN;
extern wxColour *wxCYAN;
extern wxColour *wxLIGHT_GREY;

extern wxCursor *wxSTANDARD_CURSOR;
extern wxCursor *wxHOURGLASS_CURSOR;
extern wxCursor *wxCROSS_CURSOR;

extern wxBitmap wxNullBitmap;
extern wxIcon   wxNullIcon;
extern wxCursor wxNullCursor;
extern wxPen    wxNullPen;
extern wxBrush  wxNullBrush;
extern wxPalette wxNullPalette;
extern wxFont   wxNullFont;
extern wxColour wxNullColour;

%readwrite
%{
#endif
%}

//---------------------------------------------------------------------------

class wxPalette {
public:
    wxPalette(int LCOUNT, byte* LIST, byte* LIST, byte* LIST);
    ~wxPalette();

    int GetPixel(byte red, byte green, byte blue);
    bool GetRGB(int pixel, byte* OUTPUT, byte* OUTPUT, byte* OUTPUT);
    bool Ok();
};

//---------------------------------------------------------------------------

enum {
    wxIMAGELIST_DRAW_NORMAL ,
    wxIMAGELIST_DRAW_TRANSPARENT,
    wxIMAGELIST_DRAW_SELECTED,
    wxIMAGELIST_DRAW_FOCUSED,
    wxIMAGE_LIST_NORMAL,
    wxIMAGE_LIST_SMALL,
    wxIMAGE_LIST_STATE
};

class wxImageList {
public:
    wxImageList(int width, int height, const bool mask=TRUE, int initialCount=1);
    ~wxImageList();

#ifdef __WXMSW__
    int Add(const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
    %name(AddWithColourMask)int Add(const wxBitmap& bitmap, const wxColour& maskColour);
    %name(AddIcon)int Add(const wxIcon& icon);
    bool Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
    %name(ReplaceIcon)bool Replace(int index, const wxIcon& icon);
#else
    int Add(const wxBitmap& bitmap);
    bool Replace(int index, const wxBitmap& bitmap);
#endif

    bool Draw(int index, wxDC& dc, int x, int x, int flags = wxIMAGELIST_DRAW_NORMAL,
              const bool solidBackground = FALSE);

    int GetImageCount();
    bool Remove(int index);
    bool RemoveAll();
};


//---------------------------------------------------------------------------
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: gdi.i
	3	// Purpose: SWIG interface file for wxDC, wxBrush, wxPen, wxFont, etc.
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 7/7/97
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 1998 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13
	14	%module gdi
	15
	16	%{
	17	#include "helpers.h"
	18	#include <wx/metafile.h>
	19	#include <wx/imaglist.h>
	20	#ifndef __WXMSW__
	21	#include <wx/dcps.h>
	22	#endif
	23	%}
	24
	25	//----------------------------------------------------------------------
	26
	27	%include typemaps.i
	28	%include my_typemaps.i
	29
	30	// Import some definitions of other classes, etc.
	31	%import _defs.i
	32	%import misc.i
	33
	34	//---------------------------------------------------------------------------
	35
	36	class wxBitmap {
	37	public:
	38	wxBitmap(const wxString& name, long type);
	39	~wxBitmap();
	40
	41	#ifdef __WXMSW__
	42	void Create(int width, int height, int depth = -1);
	43	#endif
	44	int GetDepth();
	45	int GetHeight();
	46	wxPalette* GetPalette();
	47	wxMask* GetMask();
	48	int GetWidth();
	49	bool LoadFile(const wxString& name, long flags);
	50	bool Ok();
	51	bool SaveFile(const wxString& name, int type, wxPalette* palette = NULL);
	52	void SetDepth(int depth);
	53	void SetHeight(int height);
	54	void SetMask(wxMask* mask);
	55	#ifdef __WXMSW__
	56	void SetPalette(wxPalette& palette);
	57	#endif
	58	void SetWidth(int width);
	59	};
	60
	61	%new wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1);
	62	wxBitmap* wxNoRefBitmap(char* name, long flags);
	63
	64	#ifdef __WXMSW__
	65	%new wxBitmap* wxBitmapFromData(char* data, long type,
	66	int width, int height, int depth = 1);
	67	#endif
	68
	69	%{ // Alternate 'constructor'
	70	wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1) {
	71	return new wxBitmap(width, height, depth);
	72	}
	73
	74	// This one won't own the reference, so Python
	75	// won't call the dtor, this is good for
	76	// toolbars and such where the parent will
	77	// manage the bitmap.
	78	wxBitmap* wxNoRefBitmap(char* name, long flags) {
	79	return new wxBitmap(name, flags);
	80	}
	81
	82	#ifdef __WXMSW__
	83	wxBitmap* wxBitmapFromData(char* data, long type,
	84	int width, int height, int depth = 1) {
	85	return new wxBitmap((void*)data, type, width, height, depth);
	86	}
	87	#endif
	88	%}
	89
	90	//---------------------------------------------------------------------------
	91
	92	class wxMask {
	93	public:
	94	wxMask(const wxBitmap& bitmap);
	95	~wxMask();
	96	};
	97
	98	%new wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour);
	99	%{
	100	wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour) {
	101	return new wxMask(bitmap, colour);
	102	}
	103	%}
	104
	105
	106	//---------------------------------------------------------------------------
	107
	108
	109	class wxIcon : public wxBitmap {
	110	public:
	111	wxIcon(const wxString& name, long flags,
	112	int desiredWidth = -1, int desiredHeight = -1);
	113	~wxIcon();
	114
	115	int GetDepth();
	116	int GetHeight();
	117	int GetWidth();
	118	bool LoadFile(const wxString& name, long flags);
	119	bool Ok();
	120	void SetDepth(int depth);
	121	void SetHeight(int height);
	122	void SetWidth(int width);
	123	};
	124
	125
	126	//---------------------------------------------------------------------------
	127
	128	class wxCursor : public wxBitmap {
	129	public:
	130	#ifdef __WXMSW__
	131	wxCursor(const wxString& cursorName, long flags, int hotSpotX=0, int hotSpotY=0);
	132	#endif
	133	~wxCursor();
	134	bool Ok();
	135	};
	136
	137	%name(wxStockCursor) %new wxCursor* wxPyStockCursor(int id);
	138	%{ // Alternate 'constructor'
	139	wxCursor* wxPyStockCursor(int id) {
	140	return new wxCursor(id);
	141	}
	142	%}
	143
	144	//----------------------------------------------------------------------
	145
	146	class wxFont {
	147	public:
	148	// I'll do it this way to use long-lived objects and not have to
	149	// worry about when python may delete the object.
	150	%addmethods {
	151	wxFont( int pointSize, int family, int style, int weight,
	152	int underline=FALSE, char* faceName = "") {
	153
	154	return wxTheFontList->FindOrCreateFont(pointSize, family, style, weight,
	155	underline, faceName);
	156	}
	157	// NO Destructor.
	158	}
	159
	160
	161	wxString GetFaceName();
	162	int GetFamily();
	163	#ifdef __WXMSW__
	164	int GetFontId();
	165	#endif
	166	int GetPointSize();
	167	int GetStyle();
	168	bool GetUnderlined();
	169	int GetWeight();
	170	void SetFaceName(const wxString& faceName);
	171	void SetFamily(int family);
	172	void SetPointSize(int pointSize);
	173	void SetStyle(int style);
	174	void SetUnderlined(bool underlined);
	175	void SetWeight(int weight);
	176	};
	177
	178	//----------------------------------------------------------------------
	179
	180	class wxColour {
	181	public:
	182	wxColour(unsigned char red=0, unsigned char green=0, unsigned char blue=0);
	183	~wxColour();
	184	unsigned char Red();
	185	unsigned char Green();
	186	unsigned char Blue();
	187	bool Ok();
	188	void Set(unsigned char red, unsigned char green, unsigned char blue);
	189	%addmethods {
	190	PyObject* Get() {
	191	PyObject* rv = PyTuple_New(3);
	192	PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red()));
	193	PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green()));
	194	PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue()));
	195	return rv;
	196	}
	197	}
	198	};
	199
	200	%new wxColour* wxNamedColour(const wxString& colorName);
	201	%{ // Alternate 'constructor'
	202	wxColour* wxNamedColour(const wxString& colorName) {
	203	return new wxColour(colorName);
	204	}
	205	%}
	206
	207
	208	//----------------------------------------------------------------------
	209
	210	typedef unsigned long wxDash;
	211
	212	class wxPen {
	213	public:
	214	// I'll do it this way to use long-lived objects and not have to
	215	// worry about when python may delete the object.
	216	%addmethods {
	217	wxPen(wxColour* colour, int width=1, int style=wxSOLID) {
	218	return wxThePenList->FindOrCreatePen(*colour, width, style);
	219	}
	220	// NO Destructor.
	221	}
	222
	223	int GetCap();
	224	wxColour& GetColour();
	225
	226	int GetJoin();
	227	int GetStyle();
	228	int GetWidth();
	229	bool Ok();
	230	void SetCap(int cap_style);
	231	void SetColour(wxColour& colour);
	232	void SetJoin(int join_style);
	233	void SetStyle(int style);
	234	void SetWidth(int width);
	235
	236	#ifdef __WXMSW__
	237	// **** This one needs to return a list of ints (wxDash)
	238	int GetDashes(wxDash **dashes);
	239	wxBitmap* GetStipple();
	240	void SetDashes(int LCOUNT, wxDash* LIST);
	241	void SetStipple(wxBitmap& stipple);
	242	#endif
	243	};
	244
	245	//----------------------------------------------------------------------
	246
	247	class wxBrush {
	248	public:
	249	// I'll do it this way to use long-lived objects and not have to
	250	// worry about when python may delete the object.
	251	%addmethods {
	252	wxBrush(wxColour* colour, int style=wxSOLID) {
	253	return wxTheBrushList->FindOrCreateBrush(*colour, style);
	254	}
	255	// NO Destructor.
	256	}
	257
	258	wxColour& GetColour();
	259	wxBitmap * GetStipple();
	260	int GetStyle();
	261	bool Ok();
	262	void SetColour(wxColour &colour);
	263	void SetStipple(wxBitmap& bitmap);
	264	void SetStyle(int style);
	265	};
	266
	267	//----------------------------------------------------------------------
	268
	269
	270
	271	class wxDC {
	272	public:
	273	// wxDC(); **** abstract base class, can't instantiate.
	274	~wxDC();
	275
	276	void BeginDrawing();
	277	// %name(BlitXY)
	278	bool Blit(long xdest, long ydest,
	279	long width, long height,
	280	wxDC *source, long xsrc, long ysrc,
	281	int logicalFunc = wxCOPY, int useMask = FALSE);
	282	// bool Blit(const wxPoint& destPt, const wxSize& sz,
	283	// wxDC *source, const wxPoint& srcPt,
	284	// int logicalFunc = wxCOPY, int useMask = FALSE);
	285
	286	void Clear();
	287	void CrossHair(long x, long y);
	288	void DestroyClippingRegion();
	289	long DeviceToLogicalX(long x);
	290	long DeviceToLogicalXRel(long x);
	291	long DeviceToLogicalY(long y);
	292	long DeviceToLogicalYRel(long y);
	293	void DrawArc(long x1, long y1, long x2, long y2, long xc, long yc);
	294	void DrawCircle(long x, long y, long radius);
	295	void DrawEllipse(long x, long y, long width, long height);
	296	void DrawEllipticArc(long x, long y, long width, long height, long start, long end);
	297	void DrawIcon(const wxIcon& icon, long x, long y);
	298	void DrawLine(long x1, long y1, long x2, long y2);
	299	void DrawLines(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0);
	300	void DrawPolygon(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0,
	301	int fill_style=wxODDEVEN_RULE);
	302	void DrawPoint(long x, long y);
	303	void DrawRectangle(long x, long y, long width, long height);
	304	void DrawRoundedRectangle(long x, long y, long width, long height, long radius=20);
	305	void DrawSpline(int LCOUNT, wxPoint* LIST);
	306	void DrawText(const wxString& text, long x, long y);
	307	void EndDoc();
	308	void EndDrawing();
	309	void EndPage();
	310	void FloodFill(long x, long y, const wxColour& colour, int style=wxFLOOD_SURFACE);
	311	wxBrush& GetBackground();
	312	wxBrush& GetBrush();
	313	long GetCharHeight();
	314	long GetCharWidth();
	315	void GetClippingBox(long OUTPUT, long OUTPUT,
	316	long OUTPUT, long OUTPUT);
	317	wxFont& GetFont();
	318	int GetLogicalFunction();
	319	int GetMapMode();
	320	bool GetOptimization();
	321	wxPen& GetPen();
	322	%addmethods {
	323	%new wxColour* GetPixel(long x, long y) {
	324	wxColour* wc = new wxColour();
	325	self->GetPixel(x, y, wc);
	326	return wc;
	327	}
	328	}
	329	%name(GetSizeTuple)void GetSize(int* OUTPUT, int* OUTPUT);
	330	wxSize GetSize();
	331	wxColour& GetTextBackground();
	332	void GetTextExtent(const wxString& string, long OUTPUT, long OUTPUT);
	333	%name(GetFullTextExtent)void GetTextExtent(const wxString& string,
	334	long OUTPUT, long OUTPUT, long OUTPUT, long OUTPUT,
	335	const wxFont* font = NULL);
	336	wxColour& GetTextForeground();
	337	long LogicalToDeviceX(long x);
	338	long LogicalToDeviceXRel(long x);
	339	long LogicalToDeviceY(long y);
	340	long LogicalToDeviceYRel(long y);
	341	long MaxX();
	342	long MaxY();
	343	long MinX();
	344	long MinY();
	345	bool Ok();
	346	void SetDeviceOrigin(long x, long y);
	347	void SetBackground(const wxBrush& brush);
	348	void SetBackgroundMode(int mode);
	349	void SetClippingRegion(long x, long y, long width, long height);
	350	void SetPalette(const wxPalette& colourMap);
	351	void SetBrush(const wxBrush& brush);
	352	void SetFont(const wxFont& font);
	353	void SetLogicalFunction(int function);
	354	void SetMapMode(int mode);
	355	void SetOptimization(bool optimize);
	356	void SetPen(const wxPen& pen);
	357	void SetTextBackground(const wxColour& colour);
	358	void SetTextForeground(const wxColour& colour);
	359	void SetUserScale(double x_scale, double y_scale);
	360	bool StartDoc(const wxString& message);
	361	void StartPage();
	362
	363
	364	// Don't need this one anymore as wxWindows has one...
	365	// %addmethods {
	366	// // This one is my own creation...
	367	// void DrawBitmap(wxBitmap& bitmap, long x, long y, bool swapPalette=TRUE) {
	368	// wxMemoryDC* memDC = new wxMemoryDC;
	369	// memDC->SelectObject(bitmap);
	370	// #ifdef __WXMSW__
	371	// if (swapPalette)
	372	// self->SetPalette(*bitmap.GetPalette());
	373	// #endif
	374	// self->Blit(x, y, bitmap.GetWidth(), bitmap.GetHeight(), memDC,
	375	// 0, 0, self->GetLogicalFunction());
	376	// memDC->SelectObject(wxNullBitmap);
	377	// delete memDC;
	378	// }
	379	// }
	380
	381	void DrawBitmap(const wxBitmap& bitmap, long x, long y,
	382	int useMask = FALSE);
	383
	384	};
	385
	386
	387	//----------------------------------------------------------------------
	388
	389	class wxMemoryDC : public wxDC {
	390	public:
	391	wxMemoryDC();
	392
	393	void SelectObject(const wxBitmap& bitmap);
	394	}
	395
	396	%new wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC);
	397	%{ // Alternate 'constructor'
	398	wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC) {
	399	return new wxMemoryDC(oldDC);
	400	}
	401	%}
	402
	403
	404	//---------------------------------------------------------------------------
	405
	406	class wxScreenDC : public wxDC {
	407	public:
	408	wxScreenDC();
	409
	410	bool StartDrawingOnTop(wxWindow* window);
	411	%name(StartDrawingOnTopRect) bool StartDrawingOnTop(wxRect* rect = NULL);
	412	bool EndDrawingOnTop();
	413	};
	414
	415	//---------------------------------------------------------------------------
	416
	417	class wxClientDC : public wxDC {
	418	public:
	419	wxClientDC(wxWindow* win);
	420	};
	421
	422	//---------------------------------------------------------------------------
	423
	424	class wxPaintDC : public wxDC {
	425	public:
	426	wxPaintDC(wxWindow* win);
	427	};
	428
	429	//---------------------------------------------------------------------------
	430
	431	class wxWindowDC : public wxDC {
	432	public:
	433	wxWindowDC(wxWindow* win);
	434	};
	435
	436	//---------------------------------------------------------------------------
	437
	438	#ifndef __WXMSW__
	439	class wxPostScriptDC : public wxDC {
	440	public:
	441	wxPostScriptDC(const wxString& output, bool interactive = TRUE, wxWindow* win = NULL);
	442	};
	443	#endif
	444
	445	//---------------------------------------------------------------------------
	446
	447	#ifdef __WXMSW__
	448	class wxPrinterDC : public wxDC {
	449	public:
	450	wxPrinterDC(const wxString& driver, const wxString& device, const wxString& output,
	451	bool interactive = TRUE, int orientation = wxPORTRAIT);
	452	};
	453	#endif
	454
	455	//---------------------------------------------------------------------------
	456
	457	#ifdef __WXMSW__
	458	class wxMetaFileDC : public wxDC {
	459	public:
	460	wxMetaFileDC(const wxString& filename = wxPyEmptyStr);
	461	wxMetaFile* Close();
	462	};
	463	#endif
	464
	465	//---------------------------------------------------------------------------
	466	//---------------------------------------------------------------------------
	467
	468
	469	%readonly
	470	%{
	471	#if 0
	472	%}
	473	extern wxFont *wxNORMAL_FONT;
	474	extern wxFont *wxSMALL_FONT;
	475	extern wxFont *wxITALIC_FONT;
	476	extern wxFont *wxSWISS_FONT;
	477
	478	extern wxPen *wxRED_PEN;
	479	extern wxPen *wxCYAN_PEN;
	480	extern wxPen *wxGREEN_PEN;
	481	extern wxPen *wxBLACK_PEN;
	482	extern wxPen *wxWHITE_PEN;
	483	extern wxPen *wxTRANSPARENT_PEN;
	484	extern wxPen *wxBLACK_DASHED_PEN;
	485	extern wxPen *wxGREY_PEN;
	486	extern wxPen *wxMEDIUM_GREY_PEN;
	487	extern wxPen *wxLIGHT_GREY_PEN;
	488
	489	extern wxBrush *wxBLUE_BRUSH;
	490	extern wxBrush *wxGREEN_BRUSH;
	491	extern wxBrush *wxWHITE_BRUSH;
	492	extern wxBrush *wxBLACK_BRUSH;
	493	extern wxBrush *wxTRANSPARENT_BRUSH;
	494	extern wxBrush *wxCYAN_BRUSH;
	495	extern wxBrush *wxRED_BRUSH;
	496	extern wxBrush *wxGREY_BRUSH;
	497	extern wxBrush *wxMEDIUM_GREY_BRUSH;
	498	extern wxBrush *wxLIGHT_GREY_BRUSH;
	499
	500	extern wxColour *wxBLACK;
	501	extern wxColour *wxWHITE;
	502	extern wxColour *wxRED;
	503	extern wxColour *wxBLUE;
	504	extern wxColour *wxGREEN;
	505	extern wxColour *wxCYAN;
	506	extern wxColour *wxLIGHT_GREY;
	507
	508	extern wxCursor *wxSTANDARD_CURSOR;
	509	extern wxCursor *wxHOURGLASS_CURSOR;
	510	extern wxCursor *wxCROSS_CURSOR;
	511
	512	extern wxBitmap wxNullBitmap;
	513	extern wxIcon wxNullIcon;
	514	extern wxCursor wxNullCursor;
	515	extern wxPen wxNullPen;
	516	extern wxBrush wxNullBrush;
	517	extern wxPalette wxNullPalette;
	518	extern wxFont wxNullFont;
	519	extern wxColour wxNullColour;
	520
	521	%readwrite
	522	%{
	523	#endif
	524	%}
	525
	526	//---------------------------------------------------------------------------
	527
	528	class wxPalette {
	529	public:
	530	wxPalette(int LCOUNT, byte* LIST, byte* LIST, byte* LIST);
	531	~wxPalette();
	532
	533	int GetPixel(byte red, byte green, byte blue);
	534	bool GetRGB(int pixel, byte* OUTPUT, byte* OUTPUT, byte* OUTPUT);
	535	bool Ok();
	536	};
	537
	538	//---------------------------------------------------------------------------
	539
	540	enum {
	541	wxIMAGELIST_DRAW_NORMAL ,
	542	wxIMAGELIST_DRAW_TRANSPARENT,
	543	wxIMAGELIST_DRAW_SELECTED,
	544	wxIMAGELIST_DRAW_FOCUSED,
	545	wxIMAGE_LIST_NORMAL,
	546	wxIMAGE_LIST_SMALL,
	547	wxIMAGE_LIST_STATE
	548	};
	549
	550	class wxImageList {
	551	public:
	552	wxImageList(int width, int height, const bool mask=TRUE, int initialCount=1);
	553	~wxImageList();
	554
	555	#ifdef __WXMSW__
	556	int Add(const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
	557	%name(AddWithColourMask)int Add(const wxBitmap& bitmap, const wxColour& maskColour);
	558	%name(AddIcon)int Add(const wxIcon& icon);
	559	bool Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
	560	%name(ReplaceIcon)bool Replace(int index, const wxIcon& icon);
	561	#else
	562	int Add(const wxBitmap& bitmap);
	563	bool Replace(int index, const wxBitmap& bitmap);
	564	#endif
	565
	566	bool Draw(int index, wxDC& dc, int x, int x, int flags = wxIMAGELIST_DRAW_NORMAL,
	567	const bool solidBackground = FALSE);
	568
	569	int GetImageCount();
	570	bool Remove(int index);
	571	bool RemoveAll();
	572	};
	573
	574
	575	//---------------------------------------------------------------------------
	576