%{
#include "helpers.h"
-#include <wx/resource.h>
#include <wx/tooltip.h>
#include <wx/busyinfo.h>
+#include <wx/geometry.h>
%}
//----------------------------------------------------------------------
%import _defs.i
+//---------------------------------------------------------------------------
%{
- static wxString wxPyEmptyStr("");
+ // Put some wx default wxChar* values into wxStrings.
+ static const wxString wxPyEmptyString(wxT(""));
%}
-
//---------------------------------------------------------------------------
public:
%addmethods {
- const char* GetClassName() {
+ wxString GetClassName() {
return self->GetClassInfo()->GetClassName();
}
void SetWidth(long w);
void SetHeight(long h);
+ void IncTo(const wxSize& sz);
+ void DecTo(const wxSize& sz);
+
%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;
}
- int __cmp__(const wxSize* sz) {
- if (! sz) return 1;
- if (*self == *sz) return 0;
- return -1;
+ 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())
- def __repr__(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) {
- if (! p) return *self;
- return *self + *p;
+ wxRealPoint __add__(const wxRealPoint& p) {
+ return *self + p;
}
- wxRealPoint __sub__(const wxRealPoint* p) {
- if (! p) return *self;
- return *self - *p;
+ wxRealPoint __sub__(const wxRealPoint& p) {
+ return *self - p;
}
- int __cmp__(const wxRealPoint* p) {
- if (! p) return 1;
- if (*self == *p) return 0;
- return -1;
+ 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())
- def __repr__(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) {
- if (! p) return *self;
- return *self + *p;
+ wxPoint __add__(const wxPoint& p) {
+ return *self + p;
}
- wxPoint __sub__(const wxPoint* p) {
- if (! p) return *self;
- return *self - *p;
+ wxPoint __sub__(const wxPoint& p) {
+ return *self - p;
}
- int __cmp__(const wxPoint* p) {
- if (! p) return 1;
- if (*self == *p) return 0;
- return -1;
+ 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())
- def __repr__(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 1;
- if (*self == *rect) return 0;
- return -1;
+ 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())
- def __repr__(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):
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):
dest = reg1.GetBox();
if (dest != wxRect(0,0,0,0)) {
- bool doSave = wxPyRestoreThread();
+ wxPyBeginBlockThreads();
wxRect* newRect = new wxRect(dest);
- obj = wxPyConstructObject((void*)newRect, "wxRect");
+ obj = wxPyConstructObject((void*)newRect, wxT("wxRect"));
PyObject* one = PyInt_FromLong(1);
PyObject_SetAttrString(obj, "thisown", one);
Py_DECREF(one);
- wxPySaveThread(doSave);
+ 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 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 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 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);
+
+void wxTrap();
//----------------------------------------------------------------------
#if 0 // we want to use the definition from the header, not the
// one SWIG will generate.
%}
+// See also wxPy_ReinitStockObjects in helpers.cpp
extern wxAcceleratorTable wxNullAcceleratorTable;
%{
#endif
~wxBusyInfo();
};
+
//---------------------------------------------------------------------------
projects / wxWidgets.git / blobdiff