wxPython/src/misc.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        misc.i
   3 // Purpose:     Definitions of miscelaneous functions and classes
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     7/3/97
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 1998 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 %module misc
  14
  15 %{
  16 #include "helpers.h"
  17 #include <wx/resource.h>
  18 #include <wx/tooltip.h>
  19 #include <wx/busyinfo.h>
  20 %}
  21
  22 //----------------------------------------------------------------------
  23
  24 %include typemaps.i
  25 %include my_typemaps.i
  26
  27 // Import some definitions of other classes, etc.
  28 %import _defs.i
  29
  30
  31 //---------------------------------------------------------------------------
  32 %{
  33     // Put some wx default wxChar* values into wxStrings.
  34     static const wxString wxPyEmptyString(wxT(""));
  35 %}
  36 //---------------------------------------------------------------------------
  37
  38
  39 class wxObject {
  40 public:
  41
  42     %addmethods {
  43         wxString GetClassName() {
  44             return self->GetClassInfo()->GetClassName();
  45         }
  46
  47         void Destroy() {
  48             delete self;
  49         }
  50     }
  51 };
  52
  53 //---------------------------------------------------------------------------
  54
  55 class wxSize {
  56 public:
  57     long x;
  58     long y;
  59     %name(width) long x;
  60     %name(height)long y;
  61
  62     wxSize(long w=0, long h=0);
  63     ~wxSize();
  64     void Set(long w, long h);
  65     long GetX();
  66     long GetY();
  67     long GetWidth();
  68     long GetHeight();
  69     void SetWidth(long w);
  70     void SetHeight(long h);
  71
  72     %addmethods {
  73         PyObject* asTuple() {
  74             wxPyBeginBlockThreads();
  75             PyObject* tup = PyTuple_New(2);
  76             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
  77             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
  78             wxPyEndBlockThreads();
  79             return tup;
  80         }
  81
  82         int __cmp__(const wxSize* sz) {
  83             if (! sz) return 1;
  84             if (*self == *sz) return 0;
  85             return -1;
  86         }
  87     }
  88
  89     %pragma(python) addtoclass = "
  90     def __str__(self):                   return str(self.asTuple())
  91     def __repr__(self):                  return str(self.asTuple())
  92     def __len__(self):                   return len(self.asTuple())
  93     def __getitem__(self, index):        return self.asTuple()[index]
  94     def __setitem__(self, index, val):
  95         if index == 0: self.width = val
  96         elif index == 1: self.height = val
  97         else: raise IndexError
  98 "
  99
 100 };
 101
 102 //---------------------------------------------------------------------------
 103
 104 class wxRealPoint {
 105 public:
 106     double x;
 107     double y;
 108     wxRealPoint(double x=0.0, double y=0.0);
 109     ~wxRealPoint();
 110
 111     %addmethods {
 112         void Set(double x, double y) {
 113             self->x = x;
 114             self->y = y;
 115         }
 116         PyObject* asTuple() {
 117             wxPyBeginBlockThreads();
 118             PyObject* tup = PyTuple_New(2);
 119             PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
 120             PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
 121             wxPyEndBlockThreads();
 122             return tup;
 123         }
 124
 125         wxRealPoint __add__(const wxRealPoint* p) {
 126             if (! p) return *self;
 127             return *self + *p;
 128         }
 129
 130         wxRealPoint __sub__(const wxRealPoint* p) {
 131             if (! p) return *self;
 132             return *self - *p;
 133         }
 134
 135         int __cmp__(const wxRealPoint* p) {
 136             if (! p) return 1;
 137             if (*self == *p) return 0;
 138             return -1;
 139         }
 140     }
 141     %pragma(python) addtoclass = "
 142     def __str__(self):                   return str(self.asTuple())
 143     def __repr__(self):                  return str(self.asTuple())
 144     def __len__(self):                   return len(self.asTuple())
 145     def __getitem__(self, index):        return self.asTuple()[index]
 146     def __setitem__(self, index, val):
 147         if index == 0: self.width = val
 148         elif index == 1: self.height = val
 149         else: raise IndexError
 150 "
 151 };
 152
 153
 154 class wxPoint {
 155 public:
 156     long x;
 157     long y;
 158     wxPoint(long x=0, long y=0);
 159     ~wxPoint();
 160
 161     %addmethods {
 162         void Set(long x, long y) {
 163             self->x = x;
 164             self->y = y;
 165         }
 166         PyObject* asTuple() {
 167             wxPyBeginBlockThreads();
 168             PyObject* tup = PyTuple_New(2);
 169             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
 170             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
 171             wxPyEndBlockThreads();
 172             return tup;
 173         }
 174
 175         wxPoint __add__(const wxPoint* p) {
 176             if (! p) return *self;
 177             return *self + *p;
 178         }
 179
 180         wxPoint __sub__(const wxPoint* p) {
 181             if (! p) return *self;
 182             return *self - *p;
 183         }
 184
 185         int __cmp__(const wxPoint* p) {
 186             if (! p) return 1;
 187             if (*self == *p) return 0;
 188             return -1;
 189         }
 190     }
 191     %pragma(python) addtoclass = "
 192     def __str__(self):                   return str(self.asTuple())
 193     def __repr__(self):                  return str(self.asTuple())
 194     def __len__(self):                   return len(self.asTuple())
 195     def __getitem__(self, index):        return self.asTuple()[index]
 196     def __setitem__(self, index, val):
 197         if index == 0: self.x = val
 198         elif index == 1: self.y = val
 199         else: raise IndexError
 200 "
 201 };
 202
 203 //---------------------------------------------------------------------------
 204
 205 class wxRect {
 206 public:
 207     wxRect(int x=0, int y=0, int w=0, int h=0);
 208     // TODO: do this one too... wxRect(const wxPoint& pos, const wxSize& size);
 209     ~wxRect();
 210
 211     int  GetX();
 212     void SetX(int X);
 213     int  GetY();
 214     void SetY(int Y);
 215     int  GetWidth();
 216     void SetWidth(int w);
 217     int  GetHeight();
 218     void SetHeight(int h);
 219
 220
 221     wxPoint GetPosition();
 222     wxSize GetSize();
 223     void SetPosition( const wxPoint &p );
 224     void SetSize( const wxSize &s );
 225
 226     int  GetLeft();
 227     int  GetTop();
 228     int  GetBottom();
 229     int  GetRight();
 230
 231     void SetLeft(int left);
 232     void SetRight(int right);
 233     void SetTop(int top);
 234     void SetBottom(int bottom);
 235
 236     void Inflate(int dx, int dy);
 237     bool Inside(int cx, int cy);
 238
 239     int x, y, width, height;
 240
 241     %addmethods {
 242         PyObject* asTuple() {
 243             wxPyBeginBlockThreads();
 244             PyObject* tup = PyTuple_New(4);
 245             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
 246             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
 247             PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
 248             PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
 249             wxPyEndBlockThreads();
 250             return tup;
 251         }
 252
 253         wxRect __add__(const wxRect* rect) {
 254             if (! rect) return *self;
 255             return *self + *rect;
 256         }
 257
 258         int __cmp__(const wxRect* rect) {
 259             if (! rect) return 1;
 260             if (*self == *rect) return 0;
 261             return -1;
 262         }
 263     }
 264
 265     %pragma(python) addtoclass = "
 266     def __str__(self):                   return str(self.asTuple())
 267     def __repr__(self):                  return str(self.asTuple())
 268     def __len__(self):                   return len(self.asTuple())
 269     def __getitem__(self, index):        return self.asTuple()[index]
 270     def __setitem__(self, index, val):
 271         if index == 0: self.x = val
 272         elif index == 1: self.y = val
 273         elif index == 2: self.width = val
 274         elif index == 3: self.height = val
 275         else: raise IndexError
 276
 277     # override the __getattr__ made by SWIG
 278     def __getattr__(self, name):
 279         d = {
 280             'x' : miscc.wxRect_x_get,
 281             'y' : miscc.wxRect_y_get,
 282             'width' : miscc.wxRect_width_get,
 283             'height' : miscc.wxRect_height_get,
 284             'top' : miscc.wxRect_GetTop,
 285             'bottom' : miscc.wxRect_GetBottom,
 286             'left' : miscc.wxRect_GetLeft,
 287             'right' : miscc.wxRect_GetRight,
 288             }
 289         try:
 290             func = d[name]
 291         except KeyError:
 292             raise AttributeError,name
 293         return func(self)
 294
 295     # and also the __setattr__
 296     def __setattr__(self, name, value):
 297         d = {
 298             'x' : miscc.wxRect_x_set,
 299             'y' : miscc.wxRect_y_set,
 300             'width' : miscc.wxRect_width_set,
 301             'height' : miscc.wxRect_height_set,
 302             'top' : miscc.wxRect_SetTop,
 303             'bottom' : miscc.wxRect_SetBottom,
 304             'left' : miscc.wxRect_SetLeft,
 305             'right' : miscc.wxRect_SetRight,
 306             }
 307         try:
 308             func = d[name]
 309         except KeyError:
 310             self.__dict__[name] = value
 311             return
 312         func(self, value)
 313     "
 314
 315 };
 316
 317
 318 %inline %{
 319     PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
 320         wxRegion  reg1(*r1);
 321         wxRegion  reg2(*r2);
 322         wxRect    dest(0,0,0,0);
 323         PyObject* obj;
 324
 325         reg1.Intersect(reg2);
 326         dest = reg1.GetBox();
 327
 328         if (dest != wxRect(0,0,0,0)) {
 329             wxPyBeginBlockThreads();
 330             wxRect* newRect = new wxRect(dest);
 331             obj = wxPyConstructObject((void*)newRect, "wxRect");
 332             PyObject* one = PyInt_FromLong(1);
 333             PyObject_SetAttrString(obj, "thisown", one);
 334             Py_DECREF(one);
 335             wxPyEndBlockThreads();
 336             return obj;
 337         }
 338         Py_INCREF(Py_None);
 339         return Py_None;
 340     }
 341 %}
 342
 343
 344 //---------------------------------------------------------------------------
 345 // Miscellaneous functions
 346
 347 long wxNewId();
 348 void wxRegisterId(long id);
 349 %name(NewId) long wxNewId();
 350 %name(RegisterId) void wxRegisterId(long id);
 351 long wxGetCurrentId();
 352
 353 void wxBell();
 354 void wxEndBusyCursor();
 355
 356 long wxGetElapsedTime(bool resetTimer = TRUE);
 357 #ifdef __WXMSW__
 358 long wxGetFreeMemory();
 359 #endif
 360 void wxGetMousePosition(int* OUTPUT, int* OUTPUT);
 361 bool wxIsBusy();
 362 wxString wxNow();
 363 bool wxShell(const wxString& command = wxPyEmptyString);
 364 void wxStartTimer();
 365 int wxGetOsVersion(int *OUTPUT, int *OUTPUT);
 366 wxString wxGetOsDescription();
 367
 368 enum wxShutdownFlags
 369 {
 370     wxSHUTDOWN_POWEROFF,    // power off the computer
 371     wxSHUTDOWN_REBOOT       // shutdown and reboot
 372 };
 373
 374 // Shutdown or reboot the PC
 375 bool wxShutdown(wxShutdownFlags wFlags);
 376
 377
 378 void wxSleep(int secs);
 379 void wxUsleep(unsigned long milliseconds);
 380 bool wxYield();
 381 bool wxYieldIfNeeded();
 382 void wxEnableTopLevelWindows(bool enable);
 383
 384 %inline %{
 385     wxString wxGetResource(const wxString& section, const wxString& entry,
 386                            const wxString& file = wxPyEmptyString) {
 387         wxChar * retval;
 388         wxGetResource(section, entry, &retval, file);
 389         return retval;
 390     }
 391 %}
 392
 393 wxString wxStripMenuCodes(const wxString& in);
 394
 395
 396 wxString wxGetEmailAddress();
 397 wxString wxGetHostName();
 398 wxString wxGetFullHostName();
 399 wxString wxGetUserId();
 400 wxString wxGetUserName();
 401 wxString wxGetHomeDir();
 402 wxString wxGetUserHome(const wxString& user = wxPyEmptyString);
 403
 404 unsigned long wxGetProcessId();
 405
 406 // When wxApp gets the virtual method magic then enable this.
 407 // bool wxHandleFatalExceptions(bool doIt = TRUE);
 408
 409 //----------------------------------------------------------------------
 410
 411 enum wxEdge { wxLeft, wxTop, wxRight, wxBottom, wxWidth, wxHeight,
 412               wxCentre, wxCenter = wxCentre, wxCentreX, wxCentreY };
 413 enum wxRelationship { wxUnconstrained = 0,
 414                       wxAsIs,
 415                       wxPercentOf,
 416                       wxAbove,
 417                       wxBelow,
 418                       wxLeftOf,
 419                       wxRightOf,
 420                       wxSameAs,
 421                       wxAbsolute };
 422
 423
 424 class wxIndividualLayoutConstraint : public wxObject {
 425 public:
 426 //    wxIndividualLayoutConstraint();
 427 //    ~wxIndividualLayoutConstraint();
 428
 429     void Above(wxWindow *otherWin, int margin=0);
 430     void Absolute(int value);
 431     void AsIs();
 432     void Below(wxWindow *otherWin, int margin=0);
 433     void Unconstrained();
 434     void LeftOf(wxWindow *otherWin, int margin=0);
 435     void PercentOf(wxWindow *otherWin, wxEdge edge, int percent);
 436     void RightOf(wxWindow *otherWin, int margin=0);
 437     void SameAs(wxWindow *otherWin, wxEdge edge, int margin=0);
 438     void Set(wxRelationship rel, wxWindow *otherWin, wxEdge otherEdge, int value=0, int margin=0);
 439 };
 440
 441
 442 class wxLayoutConstraints : public wxObject {
 443 public:
 444     wxLayoutConstraints();
 445
 446 %readonly
 447     wxIndividualLayoutConstraint bottom;
 448     wxIndividualLayoutConstraint centreX;
 449     wxIndividualLayoutConstraint centreY;
 450     wxIndividualLayoutConstraint height;
 451     wxIndividualLayoutConstraint left;
 452     wxIndividualLayoutConstraint right;
 453     wxIndividualLayoutConstraint top;
 454     wxIndividualLayoutConstraint width;
 455 %readwrite
 456 }
 457
 458
 459
 460 //---------------------------------------------------------------------------
 461 // Accelerator Entry and Table
 462
 463 class wxAcceleratorEntry {
 464 public:
 465     wxAcceleratorEntry(int flags = 0, int keyCode = 0, int cmd = 0);
 466     ~wxAcceleratorEntry();
 467
 468     void Set(int flags, int keyCode, int Cmd);
 469     int GetFlags();
 470     int GetKeyCode();
 471     int GetCommand();
 472 };
 473
 474
 475 class wxAcceleratorTable : public wxObject {
 476 public:
 477     // Can also accept a list of 3-tuples
 478     wxAcceleratorTable(int LCOUNT, wxAcceleratorEntry* choices);
 479     ~wxAcceleratorTable();
 480
 481 };
 482
 483 wxAcceleratorEntry *wxGetAccelFromString(const wxString& label);
 484
 485 %readonly
 486 %{
 487 #if 0  // we want to use the definition from the header, not the
 488        // one SWIG will generate.
 489 %}
 490 extern wxAcceleratorTable wxNullAcceleratorTable;
 491 %{
 492 #endif
 493 %}
 494 %readwrite
 495
 496 //---------------------------------------------------------------------------
 497
 498 class wxBusyInfo : public wxObject {
 499 public:
 500     wxBusyInfo(const wxString& message);
 501     ~wxBusyInfo();
 502 };
 503
 504
 505 //---------------------------------------------------------------------------
 506
 507
 508