[wxWidgets.git] / 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 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);

%{                              // 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);
    }
%}

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

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:
#ifdef __WXMSW__
    wxIcon(const wxString& name, long flags,
           int desiredWidth = -1, int desiredHeight = -1);
#endif
    ~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();
    int GetFontId();
    int GetPointSize();
    int GetStyle();
    bool GetUnderlined();
    int GetWeight();
#ifdef __WXMSW__
    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);
#endif
};

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

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();

#ifdef __WXMSW__
            // **** This one needs to return a list of ints (wxDash)
    int GetDashes(wxDash **dashes);
    wxBitmap* GetStipple();
#endif
    int GetJoin();
    int GetStyle();
    int GetWidth();
    bool Ok();
    void SetCap(int cap_style);
    void SetColour(wxColour& colour);
#ifdef __WXMSW__
    void SetDashes(int LCOUNT, wxDash* LIST);
    void SetStipple(wxBitmap * stipple);
#endif
    void SetJoin(int join_style);
    void SetStyle(int style);
    void SetWidth(int width);
};

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

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();
#ifdef __WXMSW__
    void SetColour(wxColour &colour);
    void SetStipple(wxBitmap *bitmap);
    void SetStyle(int style);
#endif
};

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


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

    void BeginDrawing();
    bool Blit(long xdest, long ydest, long width, long height,
                wxDC *source, long xsrc, long ysrc, long logical_func);
    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 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();
#ifdef __WXWIN__
    void FloodFill(long x, long y, const wxColour& colour, int style=wxFLOOD_SURFACE);
#endif
#ifdef __WXGTK__
    void FloodFill(long x, long y, wxColour* colour, int style=wxFLOOD_SURFACE);
#endif
    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;
        }
    }
    void GetSize(int* OUTPUT, int* OUTPUT); //void GetSize(long* OUTPUT, long* OUTPUT);
    wxColour& GetTextBackground();
    void GetTextExtent(const wxString& string, long *OUTPUT, long *OUTPUT,
                       long *OUTPUT, long *OUTPUT);
    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();


    %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);
            if (swapPalette)
                self->SetPalette(bitmap->GetPalette());
            self->Blit(x, y, bitmap->GetWidth(), bitmap->GetHeight(), memDC,
                    0, 0, self->GetLogicalFunction());
            memDC->SelectObject(wxNullBitmap);
            delete memDC;
        }
    }
};


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

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);
};

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

#ifdef __WXMSW__
class wxWindowDC : public wxDC {
public:
      wxWindowDC(wxWindow* win);
};
#endif

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

#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
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;

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

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();
};

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


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

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