#include <wx/resource.h>
#include <wx/tooltip.h>
#include <wx/busyinfo.h>
+#include <wx/geometry.h>
%}
//----------------------------------------------------------------------
//---------------------------------------------------------------------------
+%{
+ // Put some wx default wxChar* values into wxStrings.
+ static const wxString wxPyEmptyString(wxT(""));
+%}
+//---------------------------------------------------------------------------
+
+class wxObject {
+public:
+
+ %addmethods {
+ wxString GetClassName() {
+ return self->GetClassInfo()->GetClassName();
+ }
+
+ void Destroy() {
+ delete self;
+ }
+ }
+};
+
+//---------------------------------------------------------------------------
class wxSize {
public:
%addmethods {
PyObject* asTuple() {
+ wxPyBeginBlockThreads();
PyObject* tup = PyTuple_New(2);
PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
+ wxPyEndBlockThreads();
return tup;
}
+
+ bool __eq__(PyObject* obj) {
+ wxSize tmp;
+ wxSize* ptr = &tmp;
+ if (obj == Py_None) return FALSE;
+ wxPyBLOCK_THREADS(bool success = wxSize_helper(obj, &ptr); PyErr_Clear());
+ if (! success) return FALSE;
+ return *self == *ptr;
+ }
+ bool __ne__(PyObject* obj) {
+ wxSize tmp;
+ wxSize* ptr = &tmp;
+ if (obj == Py_None) return TRUE;
+ wxPyBLOCK_THREADS(bool success = wxSize_helper(obj, &ptr); PyErr_Clear());
+ if (! success) return TRUE;
+ return *self != *ptr;
+ }
+
}
- %pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
- %pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
+
+ %pragma(python) addtoclass = "
+ def __str__(self): return str(self.asTuple())
+ def __repr__(self): return 'wxSize'+str(self.asTuple())
+ def __len__(self): return len(self.asTuple())
+ def __getitem__(self, index): return self.asTuple()[index]
+ def __setitem__(self, index, val):
+ if index == 0: self.width = val
+ elif index == 1: self.height = val
+ else: raise IndexError
+ def __nonzero__(self): return self.asTuple() != (0,0)
+ def __getinitargs__(self): return ()
+ def __getstate__(self): return self.asTuple()
+ def __setstate__(self, state): self.Set(*state)
+"
};
self->y = y;
}
PyObject* asTuple() {
+ wxPyBeginBlockThreads();
PyObject* tup = PyTuple_New(2);
PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
+ wxPyEndBlockThreads();
return tup;
}
+
+ wxRealPoint __add__(const wxRealPoint& p) {
+ return *self + p;
+ }
+
+ wxRealPoint __sub__(const wxRealPoint& p) {
+ return *self - p;
+ }
+
+ bool __eq__(PyObject* obj) {
+ wxRealPoint tmp;
+ wxRealPoint* ptr = &tmp;
+ if (obj == Py_None) return FALSE;
+ wxPyBLOCK_THREADS(bool success = wxRealPoint_helper(obj, &ptr); PyErr_Clear());
+ if (! success) return FALSE;
+ return *self == *ptr;
+ }
+ bool __ne__(PyObject* obj) {
+ wxRealPoint tmp;
+ wxRealPoint* ptr = &tmp;
+ if (obj == Py_None) return TRUE;
+ wxPyBLOCK_THREADS(bool success = wxRealPoint_helper(obj, &ptr); PyErr_Clear());
+ if (! success) return TRUE;
+ return *self != *ptr;
+ }
+
}
- %pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
- %pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
+
+ %pragma(python) addtoclass = "
+ def __str__(self): return str(self.asTuple())
+ def __repr__(self): return 'wxRealPoint'+str(self.asTuple())
+ def __len__(self): return len(self.asTuple())
+ def __getitem__(self, index): return self.asTuple()[index]
+ def __setitem__(self, index, val):
+ if index == 0: self.width = val
+ elif index == 1: self.height = val
+ else: raise IndexError
+ def __nonzero__(self): return self.asTuple() != (0.0, 0.0)
+ def __getinitargs__(self): return ()
+ def __getstate__(self): return self.asTuple()
+ def __setstate__(self, state): self.Set(*state)
+"
};
self->y = y;
}
PyObject* asTuple() {
+ wxPyBeginBlockThreads();
PyObject* tup = PyTuple_New(2);
PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
+ wxPyEndBlockThreads();
return tup;
}
+
+ wxPoint __add__(const wxPoint& p) {
+ return *self + p;
+ }
+
+ wxPoint __sub__(const wxPoint& p) {
+ return *self - p;
+ }
+
+ bool __eq__(PyObject* obj) {
+ wxPoint tmp;
+ wxPoint* ptr = &tmp;
+ if (obj == Py_None) return FALSE;
+ wxPyBLOCK_THREADS(bool success = wxPoint_helper(obj, &ptr); PyErr_Clear());
+ if (! success) return FALSE;
+ return *self == *ptr;
+ }
+ bool __ne__(PyObject* obj) {
+ wxPoint tmp;
+ wxPoint* ptr = &tmp;
+ if (obj == Py_None) return TRUE;
+ wxPyBLOCK_THREADS(bool success = wxPoint_helper(obj, &ptr); PyErr_Clear());
+ if (! success) return TRUE;
+ return *self != *ptr;
+ }
+
}
- %pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
- %pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
+
+ %pragma(python) addtoclass = "
+ def __str__(self): return str(self.asTuple())
+ def __repr__(self): return 'wxPoint'+str(self.asTuple())
+ def __len__(self): return len(self.asTuple())
+ def __getitem__(self, index): return self.asTuple()[index]
+ def __setitem__(self, index, val):
+ if index == 0: self.x = val
+ elif index == 1: self.y = val
+ else: raise IndexError
+ def __nonzero__(self): return self.asTuple() != (0,0)
+ def __getinitargs__(self): return ()
+ def __getstate__(self): return self.asTuple()
+ def __setstate__(self, state): self.Set(*state)
+"
};
//---------------------------------------------------------------------------
class wxRect {
public:
- wxRect(int x=0, int y=0, int w=0, int h=0);
+ wxRect(int x=0, int y=0, int width=0, int height=0);
// TODO: do this one too... wxRect(const wxPoint& pos, const wxSize& size);
~wxRect();
wxPoint GetPosition();
wxSize GetSize();
+ void SetPosition( const wxPoint &p );
+ void SetSize( const wxSize &s );
int GetLeft();
int GetTop();
void SetTop(int top);
void SetBottom(int bottom);
+ void Deflate(int dx, int dy);
void Inflate(int dx, int dy);
- bool Inside(int cx, int cy);
+ %name(InsideXY)bool Inside(int cx, int cy);
+ bool Inside(const wxPoint& pt);
+ bool Intersects(const wxRect& rect);
+ %name(OffsetXY) void Offset(int dx, int dy);
+ void Offset(const wxPoint& pt);
int x, y, width, height;
%addmethods {
+ void Set(int x=0, int y=0, int width=0, int height=0) {
+ self->x = x;
+ self->y = y;
+ self->width = width;
+ self->height = height;
+ }
+
PyObject* asTuple() {
+ wxPyBeginBlockThreads();
PyObject* tup = PyTuple_New(4);
PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
+ wxPyEndBlockThreads();
return tup;
}
- wxRect __add__(const wxRect* rect) {
- if (! rect) return *self;
- return *self + *rect;
+ wxRect __add__(const wxRect& rect) {
+ return *self + rect;
}
- int __cmp__(const wxRect* rect) {
- if (! rect) return 0;
- return *self == *rect;
+ bool __eq__(PyObject* obj) {
+ wxRect tmp;
+ wxRect* ptr = &tmp;
+ if (obj == Py_None) return FALSE;
+ wxPyBLOCK_THREADS(bool success = wxRect_helper(obj, &ptr); PyErr_Clear());
+ if (! success) return FALSE;
+ return *self == *ptr;
+ }
+ bool __ne__(PyObject* obj) {
+ wxRect tmp;
+ wxRect* ptr = &tmp;
+ if (obj == Py_None) return TRUE;
+ wxPyBLOCK_THREADS(bool success = wxRect_helper(obj, &ptr); PyErr_Clear());
+ if (! success) return TRUE;
+ return *self != *ptr;
}
+
}
- %pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
- %pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
%pragma(python) addtoclass = "
+ def __str__(self): return str(self.asTuple())
+ def __repr__(self): return 'wxRect'+str(self.asTuple())
+ def __len__(self): return len(self.asTuple())
+ def __getitem__(self, index): return self.asTuple()[index]
+ def __setitem__(self, index, val):
+ if index == 0: self.x = val
+ elif index == 1: self.y = val
+ elif index == 2: self.width = val
+ elif index == 3: self.height = val
+ else: raise IndexError
+ def __nonzero__(self): return self.asTuple() != (0,0,0,0)
+ def __getinitargs__(self): return ()
+ def __getstate__(self): return self.asTuple()
+ def __setstate__(self, state): self.Set(*state)
+
# override the __getattr__ made by SWIG
def __getattr__(self, name):
d = {
dest = reg1.GetBox();
if (dest != wxRect(0,0,0,0)) {
- bool doSave = wxPyRestoreThread();
+ wxPyBeginBlockThreads();
wxRect* newRect = new wxRect(dest);
- obj = wxPyConstructObject((void*)newRect, "wxRect");
- PyObject_SetAttrString(obj, "thisown", PyInt_FromLong(1));
- wxPySaveThread(doSave);
+ obj = wxPyConstructObject((void*)newRect, wxT("wxRect"));
+ PyObject* one = PyInt_FromLong(1);
+ PyObject_SetAttrString(obj, "thisown", one);
+ Py_DECREF(one);
+ wxPyEndBlockThreads();
return obj;
}
Py_INCREF(Py_None);
%}
+
+//---------------------------------------------------------------------------
+// wxPoint2Ds represent a point or a vector in a 2d coordinate system
+
+class wxPoint2DDouble
+{
+public:
+ double m_x;
+ double m_y;
+
+ %name(x)double m_x;
+ %name(y)double m_y;
+
+ wxPoint2DDouble( double x=0 , double y=0 );
+ %name(wxPoint2DDoubleCopy)wxPoint2DDouble( const wxPoint2DDouble &pt );
+ %name(wxPoint2DDoubleFromPoint)wxPoint2DDouble( const wxPoint &pt );
+
+ // two different conversions to integers, floor and rounding
+ void GetFloor( int* OUTPUT , int* OUTPUT ) const;
+ void GetRounded( int* OUTPUT , int* OUTPUT ) const;
+
+ double GetVectorLength() const;
+ double GetVectorAngle() const ;
+ void SetVectorLength( double length );
+ void SetVectorAngle( double degrees );
+ // LinkError: void SetPolarCoordinates( double angle , double length );
+ // LinkError: void Normalize();
+ %pragma(python) addtoclass = "
+ def SetPolarCoordinates(self, angle, length):
+ self.SetVectorLength(length)
+ self.SetVectorAngle(angle)
+ def Normalize(self):
+ self.SetVectorLength(1.0)
+ "
+
+ double GetDistance( const wxPoint2DDouble &pt ) const;
+ double GetDistanceSquare( const wxPoint2DDouble &pt ) const;
+ double GetDotProduct( const wxPoint2DDouble &vec ) const;
+ double GetCrossProduct( const wxPoint2DDouble &vec ) const;
+
+ %addmethods {
+ void Set( double x=0 , double y=0 ) {
+ self->m_x = x;
+ self->m_y = y;
+ }
+
+ // the reflection of this point
+ wxPoint2DDouble __neg__() { return -(*self); }
+
+ wxPoint2DDouble& __iadd__(const wxPoint2DDouble& pt) { return (*self) += pt; }
+ wxPoint2DDouble& __isub__(const wxPoint2DDouble& pt) { return (*self) -= pt; }
+ wxPoint2DDouble& __imul__(const wxPoint2DDouble& pt) { return (*self) *= pt; }
+ wxPoint2DDouble& __idiv__(const wxPoint2DDouble& pt) { return (*self) /= pt; }
+
+ // TODO:
+ //wxPoint2DDouble& operator*=(double n);
+ //wxPoint2DDouble& operator*=(int n);
+ //wxPoint2DDouble& operator/=(double n);
+ //wxPoint2DDouble& operator/=(int n);
+
+ bool __eq__(PyObject* obj) {
+ wxPoint2DDouble tmp;
+ wxPoint2DDouble* ptr = &tmp;
+ if (obj == Py_None) return FALSE;
+ wxPyBLOCK_THREADS(bool success = wxPoint2DDouble_helper(obj, &ptr); PyErr_Clear());
+ if (! success) return FALSE;
+ return *self == *ptr;
+ }
+ bool __ne__(PyObject* obj) {
+ wxPoint2DDouble tmp;
+ wxPoint2DDouble* ptr = &tmp;
+ if (obj == Py_None) return TRUE;
+ wxPyBLOCK_THREADS(bool success = wxPoint2DDouble_helper(obj, &ptr); PyErr_Clear());
+ if (! success) return TRUE;
+ return *self != *ptr;
+ }
+
+
+ PyObject* asTuple() {
+ wxPyBeginBlockThreads();
+ PyObject* tup = PyTuple_New(2);
+ PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
+ PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
+ wxPyEndBlockThreads();
+ return tup;
+ }
+ }
+
+ %pragma(python) addtoclass = "
+ def __str__(self): return str(self.asTuple())
+ def __repr__(self): return 'wxPoint2DDouble'+str(self.asTuple())
+ def __len__(self): return len(self.asTuple())
+ def __getitem__(self, index): return self.asTuple()[index]
+ def __setitem__(self, index, val):
+ if index == 0: self.m_x = val
+ elif index == 1: self.m_yt = val
+ else: raise IndexError
+ def __nonzero__(self): return self.asTuple() != (0.0, 0.0)
+ def __getinitargs__(self): return ()
+ def __getstate__(self): return self.asTuple()
+ def __setstate__(self, state): self.Set(*state)
+"
+};
+
+
//---------------------------------------------------------------------------
// Miscellaneous functions
long wxNewId();
void wxRegisterId(long id);
-%name(NewId) long wxNewId();
-%name(RegisterId) void wxRegisterId(long id);
+long wxGetCurrentId();
void wxBell();
-void wxDisplaySize(int *OUTPUT, int *OUTPUT);
void wxEndBusyCursor();
-long wxExecute(const wxString& command, int sync = FALSE);
+
long wxGetElapsedTime(bool resetTimer = TRUE);
#ifdef __WXMSW__
long wxGetFreeMemory();
void wxGetMousePosition(int* OUTPUT, int* OUTPUT);
bool wxIsBusy();
wxString wxNow();
-bool wxShell(const wxString& command = wxPyEmptyStr);
+bool wxShell(const wxString& command = wxPyEmptyString);
void wxStartTimer();
int wxGetOsVersion(int *OUTPUT, int *OUTPUT);
+wxString wxGetOsDescription();
+
+enum wxShutdownFlags
+{
+ wxSHUTDOWN_POWEROFF, // power off the computer
+ wxSHUTDOWN_REBOOT // shutdown and reboot
+};
+
+// Shutdown or reboot the PC
+bool wxShutdown(wxShutdownFlags wFlags);
+
void wxSleep(int secs);
+void wxUsleep(unsigned long milliseconds);
bool wxYield();
-bool wxSafeYield();
+bool wxYieldIfNeeded();
void wxEnableTopLevelWindows(bool enable);
-%inline %{
- char* wxGetResource(char *section, char *entry, char *file = NULL) {
- char * retval;
+#ifdef wxUSE_RESOURCES
+inline %{
+ wxString wxGetResource(const wxString& section, const wxString& entry,
+ const wxString& file = wxPyEmptyString) {
+ wxChar* retval;
wxGetResource(section, entry, &retval, file);
return retval;
}
%}
+#endif
wxString wxStripMenuCodes(const wxString& in);
+
+wxString wxGetEmailAddress();
+wxString wxGetHostName();
+wxString wxGetFullHostName();
+wxString wxGetUserId();
+wxString wxGetUserName();
+wxString wxGetHomeDir();
+wxString wxGetUserHome(const wxString& user = wxPyEmptyString);
+
+unsigned long wxGetProcessId();
+
+// When wxApp gets the virtual method magic then enable this.
+// bool wxHandleFatalExceptions(bool doIt = TRUE);
+
//----------------------------------------------------------------------
enum wxEdge { wxLeft, wxTop, wxRight, wxBottom, wxWidth, wxHeight,
wxAbsolute };
-class wxIndividualLayoutConstraint {
+class wxIndividualLayoutConstraint : public wxObject {
public:
// wxIndividualLayoutConstraint();
// ~wxIndividualLayoutConstraint();
};
-class wxLayoutConstraints {
+class wxLayoutConstraints : public wxObject {
public:
wxLayoutConstraints();
}
-//---------------------------------------------------------------------------
-// Regions, etc.
-
-enum wxRegionContain {
- wxOutRegion, wxPartRegion, wxInRegion
-};
-
-
-class wxRegion {
-public:
- wxRegion();
- ~wxRegion();
-
- void Clear();
- wxRegionContain Contains(long x, long y);
- %name(ContainsPoint)wxRegionContain Contains(const wxPoint& pt);
- %name(ContainsRect)wxRegionContain Contains(const wxRect& rect);
- %name(ContainsRectDim)wxRegionContain Contains(long x, long y, long w, long h);
-
- wxRect GetBox();
-
- bool Intersect(long x, long y, long width, long height);
- %name(IntersectRect)bool Intersect(const wxRect& rect);
- %name(IntersectRegion)bool Intersect(const wxRegion& region);
-
- bool IsEmpty();
-
- bool Union(long x, long y, long width, long height);
- %name(UnionRect)bool Union(const wxRect& rect);
- %name(UnionRegion)bool Union(const wxRegion& region);
-
- bool Subtract(long x, long y, long width, long height);
- %name(SubtractRect)bool Subtract(const wxRect& rect);
- %name(SubtractRegion)bool Subtract(const wxRegion& region);
-
- bool Xor(long x, long y, long width, long height);
- %name(XorRect)bool Xor(const wxRect& rect);
- %name(XorRegion)bool Xor(const wxRegion& region);
-};
-
-
-
-class wxRegionIterator {
-public:
- wxRegionIterator(const wxRegion& region);
- ~wxRegionIterator();
-
- long GetX();
- long GetY();
- long GetW();
- long GetWidth();
- long GetH();
- long GetHeight();
- wxRect GetRect();
- bool HaveRects();
- void Reset();
-
- %addmethods {
- void Next() {
- (*self) ++;
- }
- };
-};
-
-
//---------------------------------------------------------------------------
// Accelerator Entry and Table
};
-class wxAcceleratorTable {
+class wxAcceleratorTable : public wxObject {
public:
// Can also accept a list of 3-tuples
wxAcceleratorTable(int LCOUNT, wxAcceleratorEntry* choices);
};
+wxAcceleratorEntry *wxGetAccelFromString(const wxString& label);
%readonly
%{
//---------------------------------------------------------------------------
-class wxBusyInfo {
+class wxBusyInfo : public wxObject {
public:
wxBusyInfo(const wxString& message);
~wxBusyInfo();
};
-
//---------------------------------------------------------------------------
+
projects / wxWidgets.git / blobdiff