2001-08-23 11:02:09 -03:00
|
|
|
|
|
|
|
/* ========================== Module _Win =========================== */
|
|
|
|
|
|
|
|
#include "Python.h"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#include "pymactoolbox.h"
|
|
|
|
|
|
|
|
/* Macro to test whether a weak-loaded CFM function exists */
|
|
|
|
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
|
2003-04-22 10:55:23 -03:00
|
|
|
PyErr_SetString(PyExc_NotImplementedError, \
|
|
|
|
"Not available in this shared library/OS version"); \
|
|
|
|
return NULL; \
|
2001-08-23 11:02:09 -03:00
|
|
|
}} while(0)
|
|
|
|
|
|
|
|
|
|
|
|
#include <Carbon/Carbon.h>
|
|
|
|
|
|
|
|
#ifdef USE_TOOLBOX_OBJECT_GLUE
|
|
|
|
extern PyObject *_WinObj_New(WindowRef);
|
|
|
|
extern PyObject *_WinObj_WhichWindow(WindowRef);
|
|
|
|
extern int _WinObj_Convert(PyObject *, WindowRef *);
|
|
|
|
|
|
|
|
#define WinObj_New _WinObj_New
|
|
|
|
#define WinObj_WhichWindow _WinObj_WhichWindow
|
|
|
|
#define WinObj_Convert _WinObj_Convert
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Classic calls that we emulate in carbon mode */
|
|
|
|
#define GetWindowUpdateRgn(win, rgn) GetWindowRegion((win), kWindowUpdateRgn, (rgn))
|
|
|
|
#define GetWindowStructureRgn(win, rgn) GetWindowRegion((win), kWindowStructureRgn, (rgn))
|
|
|
|
#define GetWindowContentRgn(win, rgn) GetWindowRegion((win), kWindowContentRgn, (rgn))
|
|
|
|
|
|
|
|
/* Function to dispose a window, with a "normal" calling sequence */
|
|
|
|
static void
|
|
|
|
PyMac_AutoDisposeWindow(WindowPtr w)
|
|
|
|
{
|
2005-07-03 17:59:44 -03:00
|
|
|
DisposeWindow(w);
|
2001-08-23 11:02:09 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_Error;
|
|
|
|
|
|
|
|
/* ----------------------- Object type Window ----------------------- */
|
|
|
|
|
|
|
|
PyTypeObject Window_Type;
|
|
|
|
|
2007-12-18 22:45:37 -04:00
|
|
|
#define WinObj_Check(x) (Py_TYPE(x) == &Window_Type || PyObject_TypeCheck((x), &Window_Type))
|
2001-08-23 11:02:09 -03:00
|
|
|
|
|
|
|
typedef struct WindowObject {
|
|
|
|
PyObject_HEAD
|
|
|
|
WindowPtr ob_itself;
|
|
|
|
void (*ob_freeit)(WindowPtr ptr);
|
|
|
|
} WindowObject;
|
|
|
|
|
|
|
|
PyObject *WinObj_New(WindowPtr itself)
|
|
|
|
{
|
|
|
|
WindowObject *it;
|
|
|
|
if (itself == NULL) return PyMac_Error(resNotFound);
|
2002-12-03 19:40:22 -04:00
|
|
|
/* XXXX Or should we use WhichWindow code here? */
|
2001-08-23 11:02:09 -03:00
|
|
|
it = PyObject_NEW(WindowObject, &Window_Type);
|
|
|
|
if (it == NULL) return NULL;
|
|
|
|
it->ob_itself = itself;
|
|
|
|
it->ob_freeit = NULL;
|
|
|
|
if (GetWRefCon(itself) == 0)
|
|
|
|
{
|
|
|
|
SetWRefCon(itself, (long)it);
|
|
|
|
it->ob_freeit = PyMac_AutoDisposeWindow;
|
|
|
|
}
|
|
|
|
return (PyObject *)it;
|
|
|
|
}
|
2005-07-03 17:59:44 -03:00
|
|
|
|
2001-09-04 19:19:18 -03:00
|
|
|
int WinObj_Convert(PyObject *v, WindowPtr *p_itself)
|
2001-08-23 11:02:09 -03:00
|
|
|
{
|
|
|
|
|
|
|
|
if (v == Py_None) { *p_itself = NULL; return 1; }
|
2007-12-02 10:31:20 -04:00
|
|
|
if (PyLong_Check(v)) { *p_itself = (WindowPtr)PyLong_AsLong(v); return 1; }
|
2001-08-23 11:02:09 -03:00
|
|
|
|
|
|
|
{
|
|
|
|
DialogRef dlg;
|
|
|
|
if (DlgObj_Convert(v, &dlg) && dlg) {
|
|
|
|
*p_itself = GetDialogWindow(dlg);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
PyErr_Clear();
|
|
|
|
}
|
|
|
|
if (!WinObj_Check(v))
|
|
|
|
{
|
|
|
|
PyErr_SetString(PyExc_TypeError, "Window required");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
*p_itself = ((WindowObject *)v)->ob_itself;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void WinObj_dealloc(WindowObject *self)
|
|
|
|
{
|
|
|
|
if (self->ob_freeit && self->ob_itself)
|
|
|
|
{
|
|
|
|
SetWRefCon(self->ob_itself, 0);
|
|
|
|
self->ob_freeit(self->ob_itself);
|
|
|
|
}
|
|
|
|
self->ob_itself = NULL;
|
|
|
|
self->ob_freeit = NULL;
|
2007-12-18 22:45:37 -04:00
|
|
|
Py_TYPE(self)->tp_free((PyObject *)self);
|
2001-08-23 11:02:09 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowOwnerCount(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
UInt32 outCount;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowOwnerCount
|
|
|
|
PyMac_PRECHECK(GetWindowOwnerCount);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowOwnerCount(_self->ob_itself,
|
|
|
|
&outCount);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("l",
|
|
|
|
outCount);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_CloneWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef CloneWindow
|
|
|
|
PyMac_PRECHECK(CloneWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = CloneWindow(_self->ob_itself);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
2001-12-18 11:39:38 -04:00
|
|
|
static PyObject *WinObj_GetWindowRetainCount(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
ItemCount _rv;
|
|
|
|
#ifndef GetWindowRetainCount
|
|
|
|
PyMac_PRECHECK(GetWindowRetainCount);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = GetWindowRetainCount(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("l",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_RetainWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
#ifndef RetainWindow
|
|
|
|
PyMac_PRECHECK(RetainWindow);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = RetainWindow(_self->ob_itself);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_ReleaseWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
#ifndef ReleaseWindow
|
|
|
|
PyMac_PRECHECK(ReleaseWindow);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = ReleaseWindow(_self->ob_itself);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
2001-08-23 11:02:09 -03:00
|
|
|
|
|
|
|
static PyObject *WinObj_ReshapeCustomWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef ReshapeCustomWindow
|
|
|
|
PyMac_PRECHECK(ReshapeCustomWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = ReshapeCustomWindow(_self->ob_itself);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
2001-12-18 11:39:38 -04:00
|
|
|
static PyObject *WinObj_GetWindowWidgetHilite(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowDefPartCode outHilite;
|
|
|
|
#ifndef GetWindowWidgetHilite
|
|
|
|
PyMac_PRECHECK(GetWindowWidgetHilite);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowWidgetHilite(_self->ob_itself,
|
|
|
|
&outHilite);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("h",
|
|
|
|
outHilite);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
2001-08-23 11:02:09 -03:00
|
|
|
static PyObject *WinObj_GetWindowClass(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowClass outClass;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowClass
|
|
|
|
PyMac_PRECHECK(GetWindowClass);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowClass(_self->ob_itself,
|
|
|
|
&outClass);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("l",
|
|
|
|
outClass);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowAttributes(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowAttributes outAttributes;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowAttributes
|
|
|
|
PyMac_PRECHECK(GetWindowAttributes);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowAttributes(_self->ob_itself,
|
|
|
|
&outAttributes);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("l",
|
|
|
|
outAttributes);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_ChangeWindowAttributes(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowAttributes setTheseAttributes;
|
|
|
|
WindowAttributes clearTheseAttributes;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef ChangeWindowAttributes
|
|
|
|
PyMac_PRECHECK(ChangeWindowAttributes);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "ll",
|
|
|
|
&setTheseAttributes,
|
|
|
|
&clearTheseAttributes))
|
|
|
|
return NULL;
|
|
|
|
_err = ChangeWindowAttributes(_self->ob_itself,
|
|
|
|
setTheseAttributes,
|
|
|
|
clearTheseAttributes);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
2001-12-18 11:39:38 -04:00
|
|
|
|
|
|
|
static PyObject *WinObj_SetWindowClass(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowClass inWindowClass;
|
|
|
|
#ifndef SetWindowClass
|
|
|
|
PyMac_PRECHECK(SetWindowClass);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, "l",
|
|
|
|
&inWindowClass))
|
|
|
|
return NULL;
|
|
|
|
_err = SetWindowClass(_self->ob_itself,
|
|
|
|
inWindowClass);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SetWindowModality(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowModality inModalKind;
|
|
|
|
WindowPtr inUnavailableWindow;
|
|
|
|
#ifndef SetWindowModality
|
|
|
|
PyMac_PRECHECK(SetWindowModality);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, "lO&",
|
|
|
|
&inModalKind,
|
|
|
|
WinObj_Convert, &inUnavailableWindow))
|
|
|
|
return NULL;
|
|
|
|
_err = SetWindowModality(_self->ob_itself,
|
|
|
|
inModalKind,
|
|
|
|
inUnavailableWindow);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowModality(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowModality outModalKind;
|
|
|
|
WindowPtr outUnavailableWindow;
|
|
|
|
#ifndef GetWindowModality
|
|
|
|
PyMac_PRECHECK(GetWindowModality);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowModality(_self->ob_itself,
|
|
|
|
&outModalKind,
|
|
|
|
&outUnavailableWindow);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("lO&",
|
|
|
|
outModalKind,
|
|
|
|
WinObj_WhichWindow, outUnavailableWindow);
|
|
|
|
return _res;
|
|
|
|
}
|
2001-08-23 11:02:09 -03:00
|
|
|
|
|
|
|
static PyObject *WinObj_SetWindowContentColor(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
RGBColor color;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetWindowContentColor
|
|
|
|
PyMac_PRECHECK(SetWindowContentColor);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
QdRGB_Convert, &color))
|
|
|
|
return NULL;
|
|
|
|
_err = SetWindowContentColor(_self->ob_itself,
|
|
|
|
&color);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowContentColor(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
RGBColor color;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowContentColor
|
|
|
|
PyMac_PRECHECK(GetWindowContentColor);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowContentColor(_self->ob_itself,
|
|
|
|
&color);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
QdRGB_New, &color);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowContentPattern(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
PixPatHandle outPixPat;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowContentPattern
|
|
|
|
PyMac_PRECHECK(GetWindowContentPattern);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
ResObj_Convert, &outPixPat))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowContentPattern(_self->ob_itself,
|
|
|
|
outPixPat);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SetWindowContentPattern(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
PixPatHandle pixPat;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetWindowContentPattern
|
|
|
|
PyMac_PRECHECK(SetWindowContentPattern);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
ResObj_Convert, &pixPat))
|
|
|
|
return NULL;
|
|
|
|
_err = SetWindowContentPattern(_self->ob_itself,
|
|
|
|
pixPat);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_ScrollWindowRect(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
Rect inScrollRect;
|
|
|
|
SInt16 inHPixels;
|
|
|
|
SInt16 inVPixels;
|
|
|
|
ScrollWindowOptions inOptions;
|
|
|
|
RgnHandle outExposedRgn;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef ScrollWindowRect
|
|
|
|
PyMac_PRECHECK(ScrollWindowRect);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&hhlO&",
|
|
|
|
PyMac_GetRect, &inScrollRect,
|
|
|
|
&inHPixels,
|
|
|
|
&inVPixels,
|
|
|
|
&inOptions,
|
|
|
|
ResObj_Convert, &outExposedRgn))
|
|
|
|
return NULL;
|
|
|
|
_err = ScrollWindowRect(_self->ob_itself,
|
|
|
|
&inScrollRect,
|
|
|
|
inHPixels,
|
|
|
|
inVPixels,
|
|
|
|
inOptions,
|
|
|
|
outExposedRgn);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_ScrollWindowRegion(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
RgnHandle inScrollRgn;
|
|
|
|
SInt16 inHPixels;
|
|
|
|
SInt16 inVPixels;
|
|
|
|
ScrollWindowOptions inOptions;
|
|
|
|
RgnHandle outExposedRgn;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef ScrollWindowRegion
|
|
|
|
PyMac_PRECHECK(ScrollWindowRegion);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&hhlO&",
|
|
|
|
ResObj_Convert, &inScrollRgn,
|
|
|
|
&inHPixels,
|
|
|
|
&inVPixels,
|
|
|
|
&inOptions,
|
|
|
|
ResObj_Convert, &outExposedRgn))
|
|
|
|
return NULL;
|
|
|
|
_err = ScrollWindowRegion(_self->ob_itself,
|
|
|
|
inScrollRgn,
|
|
|
|
inHPixels,
|
|
|
|
inVPixels,
|
|
|
|
inOptions,
|
|
|
|
outExposedRgn);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_ClipAbove(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef ClipAbove
|
|
|
|
PyMac_PRECHECK(ClipAbove);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
ClipAbove(_self->ob_itself);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_PaintOne(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
RgnHandle clobberedRgn;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef PaintOne
|
|
|
|
PyMac_PRECHECK(PaintOne);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
ResObj_Convert, &clobberedRgn))
|
|
|
|
return NULL;
|
|
|
|
PaintOne(_self->ob_itself,
|
|
|
|
clobberedRgn);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_PaintBehind(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
RgnHandle clobberedRgn;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef PaintBehind
|
|
|
|
PyMac_PRECHECK(PaintBehind);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
ResObj_Convert, &clobberedRgn))
|
|
|
|
return NULL;
|
|
|
|
PaintBehind(_self->ob_itself,
|
|
|
|
clobberedRgn);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_CalcVis(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef CalcVis
|
|
|
|
PyMac_PRECHECK(CalcVis);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
CalcVis(_self->ob_itself);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_CalcVisBehind(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
RgnHandle clobberedRgn;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef CalcVisBehind
|
|
|
|
PyMac_PRECHECK(CalcVisBehind);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
ResObj_Convert, &clobberedRgn))
|
|
|
|
return NULL;
|
|
|
|
CalcVisBehind(_self->ob_itself,
|
|
|
|
clobberedRgn);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_BringToFront(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef BringToFront
|
|
|
|
PyMac_PRECHECK(BringToFront);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
BringToFront(_self->ob_itself);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SendBehind(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
WindowPtr behindWindow;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SendBehind
|
|
|
|
PyMac_PRECHECK(SendBehind);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
WinObj_Convert, &behindWindow))
|
|
|
|
return NULL;
|
|
|
|
SendBehind(_self->ob_itself,
|
|
|
|
behindWindow);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SelectWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SelectWindow
|
|
|
|
PyMac_PRECHECK(SelectWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
SelectWindow(_self->ob_itself);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetNextWindowOfClass(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
WindowPtr _rv;
|
|
|
|
WindowClass inWindowClass;
|
|
|
|
Boolean mustBeVisible;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetNextWindowOfClass
|
|
|
|
PyMac_PRECHECK(GetNextWindowOfClass);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "lb",
|
|
|
|
&inWindowClass,
|
|
|
|
&mustBeVisible))
|
|
|
|
return NULL;
|
|
|
|
_rv = GetNextWindowOfClass(_self->ob_itself,
|
|
|
|
inWindowClass,
|
|
|
|
mustBeVisible);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
WinObj_New, _rv);
|
|
|
|
return _res;
|
|
|
|
}
|
2001-12-18 11:39:38 -04:00
|
|
|
|
|
|
|
static PyObject *WinObj_SetWindowAlternateTitle(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
CFStringRef inTitle;
|
|
|
|
#ifndef SetWindowAlternateTitle
|
|
|
|
PyMac_PRECHECK(SetWindowAlternateTitle);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
CFStringRefObj_Convert, &inTitle))
|
|
|
|
return NULL;
|
|
|
|
_err = SetWindowAlternateTitle(_self->ob_itself,
|
|
|
|
inTitle);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_CopyWindowAlternateTitle(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
CFStringRef outTitle;
|
|
|
|
#ifndef CopyWindowAlternateTitle
|
|
|
|
PyMac_PRECHECK(CopyWindowAlternateTitle);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = CopyWindowAlternateTitle(_self->ob_itself,
|
|
|
|
&outTitle);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
CFStringRefObj_New, outTitle);
|
|
|
|
return _res;
|
|
|
|
}
|
2001-08-23 11:02:09 -03:00
|
|
|
|
|
|
|
static PyObject *WinObj_HiliteWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean fHilite;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef HiliteWindow
|
|
|
|
PyMac_PRECHECK(HiliteWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
|
|
&fHilite))
|
|
|
|
return NULL;
|
|
|
|
HiliteWindow(_self->ob_itself,
|
|
|
|
fHilite);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SetWRefCon(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
long data;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetWRefCon
|
|
|
|
PyMac_PRECHECK(SetWRefCon);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "l",
|
|
|
|
&data))
|
|
|
|
return NULL;
|
|
|
|
SetWRefCon(_self->ob_itself,
|
|
|
|
data);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWRefCon(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
long _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWRefCon
|
|
|
|
PyMac_PRECHECK(GetWRefCon);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = GetWRefCon(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("l",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SetWindowPic(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
PicHandle pic;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetWindowPic
|
|
|
|
PyMac_PRECHECK(SetWindowPic);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
ResObj_Convert, &pic))
|
|
|
|
return NULL;
|
|
|
|
SetWindowPic(_self->ob_itself,
|
|
|
|
pic);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowPic(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
PicHandle _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowPic
|
|
|
|
PyMac_PRECHECK(GetWindowPic);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = GetWindowPic(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
ResObj_New, _rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWVariant(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
short _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWVariant
|
|
|
|
PyMac_PRECHECK(GetWVariant);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = GetWVariant(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("h",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowFeatures(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
UInt32 outFeatures;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowFeatures
|
|
|
|
PyMac_PRECHECK(GetWindowFeatures);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowFeatures(_self->ob_itself,
|
|
|
|
&outFeatures);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("l",
|
|
|
|
outFeatures);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowRegion(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowRegionCode inRegionCode;
|
|
|
|
RgnHandle ioWinRgn;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowRegion
|
|
|
|
PyMac_PRECHECK(GetWindowRegion);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "HO&",
|
|
|
|
&inRegionCode,
|
|
|
|
ResObj_Convert, &ioWinRgn))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowRegion(_self->ob_itself,
|
|
|
|
inRegionCode,
|
|
|
|
ioWinRgn);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
2001-12-18 11:39:38 -04:00
|
|
|
static PyObject *WinObj_GetWindowStructureWidths(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
Rect outRect;
|
|
|
|
#ifndef GetWindowStructureWidths
|
|
|
|
PyMac_PRECHECK(GetWindowStructureWidths);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowStructureWidths(_self->ob_itself,
|
|
|
|
&outRect);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
PyMac_BuildRect, &outRect);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
2001-08-23 11:02:09 -03:00
|
|
|
static PyObject *WinObj_BeginUpdate(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef BeginUpdate
|
|
|
|
PyMac_PRECHECK(BeginUpdate);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
BeginUpdate(_self->ob_itself);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_EndUpdate(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef EndUpdate
|
|
|
|
PyMac_PRECHECK(EndUpdate);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
EndUpdate(_self->ob_itself);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_InvalWindowRgn(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
RgnHandle region;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef InvalWindowRgn
|
|
|
|
PyMac_PRECHECK(InvalWindowRgn);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
ResObj_Convert, ®ion))
|
|
|
|
return NULL;
|
|
|
|
_err = InvalWindowRgn(_self->ob_itself,
|
|
|
|
region);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_InvalWindowRect(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
Rect bounds;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef InvalWindowRect
|
|
|
|
PyMac_PRECHECK(InvalWindowRect);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
PyMac_GetRect, &bounds))
|
|
|
|
return NULL;
|
|
|
|
_err = InvalWindowRect(_self->ob_itself,
|
|
|
|
&bounds);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_ValidWindowRgn(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
RgnHandle region;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef ValidWindowRgn
|
|
|
|
PyMac_PRECHECK(ValidWindowRgn);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
ResObj_Convert, ®ion))
|
|
|
|
return NULL;
|
|
|
|
_err = ValidWindowRgn(_self->ob_itself,
|
|
|
|
region);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_ValidWindowRect(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
Rect bounds;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef ValidWindowRect
|
|
|
|
PyMac_PRECHECK(ValidWindowRect);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
PyMac_GetRect, &bounds))
|
|
|
|
return NULL;
|
|
|
|
_err = ValidWindowRect(_self->ob_itself,
|
|
|
|
&bounds);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_DrawGrowIcon(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef DrawGrowIcon
|
|
|
|
PyMac_PRECHECK(DrawGrowIcon);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
DrawGrowIcon(_self->ob_itself);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SetWTitle(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Str255 title;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetWTitle
|
|
|
|
PyMac_PRECHECK(SetWTitle);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
PyMac_GetStr255, title))
|
|
|
|
return NULL;
|
|
|
|
SetWTitle(_self->ob_itself,
|
|
|
|
title);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWTitle(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Str255 title;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWTitle
|
|
|
|
PyMac_PRECHECK(GetWTitle);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
GetWTitle(_self->ob_itself,
|
|
|
|
title);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
PyMac_BuildStr255, title);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
2001-12-18 11:39:38 -04:00
|
|
|
static PyObject *WinObj_SetWindowTitleWithCFString(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
CFStringRef inString;
|
|
|
|
#ifndef SetWindowTitleWithCFString
|
|
|
|
PyMac_PRECHECK(SetWindowTitleWithCFString);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
CFStringRefObj_Convert, &inString))
|
|
|
|
return NULL;
|
|
|
|
_err = SetWindowTitleWithCFString(_self->ob_itself,
|
|
|
|
inString);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_CopyWindowTitleAsCFString(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
CFStringRef outString;
|
|
|
|
#ifndef CopyWindowTitleAsCFString
|
|
|
|
PyMac_PRECHECK(CopyWindowTitleAsCFString);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = CopyWindowTitleAsCFString(_self->ob_itself,
|
|
|
|
&outString);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
CFStringRefObj_New, outString);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
2001-08-23 11:02:09 -03:00
|
|
|
static PyObject *WinObj_SetWindowProxyFSSpec(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
FSSpec inFile;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetWindowProxyFSSpec
|
|
|
|
PyMac_PRECHECK(SetWindowProxyFSSpec);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
PyMac_GetFSSpec, &inFile))
|
|
|
|
return NULL;
|
|
|
|
_err = SetWindowProxyFSSpec(_self->ob_itself,
|
|
|
|
&inFile);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowProxyFSSpec(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
FSSpec outFile;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowProxyFSSpec
|
|
|
|
PyMac_PRECHECK(GetWindowProxyFSSpec);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowProxyFSSpec(_self->ob_itself,
|
|
|
|
&outFile);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
2002-03-18 11:41:32 -04:00
|
|
|
PyMac_BuildFSSpec, &outFile);
|
2001-08-23 11:02:09 -03:00
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SetWindowProxyAlias(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
2003-12-03 19:20:13 -04:00
|
|
|
AliasHandle inAlias;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetWindowProxyAlias
|
|
|
|
PyMac_PRECHECK(SetWindowProxyAlias);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
2003-12-03 19:20:13 -04:00
|
|
|
ResObj_Convert, &inAlias))
|
2001-08-23 11:02:09 -03:00
|
|
|
return NULL;
|
|
|
|
_err = SetWindowProxyAlias(_self->ob_itself,
|
2003-12-03 19:20:13 -04:00
|
|
|
inAlias);
|
2001-08-23 11:02:09 -03:00
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowProxyAlias(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
AliasHandle alias;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowProxyAlias
|
|
|
|
PyMac_PRECHECK(GetWindowProxyAlias);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowProxyAlias(_self->ob_itself,
|
|
|
|
&alias);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
ResObj_New, alias);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SetWindowProxyCreatorAndType(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
OSType fileCreator;
|
|
|
|
OSType fileType;
|
|
|
|
SInt16 vRefNum;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetWindowProxyCreatorAndType
|
|
|
|
PyMac_PRECHECK(SetWindowProxyCreatorAndType);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&O&h",
|
|
|
|
PyMac_GetOSType, &fileCreator,
|
|
|
|
PyMac_GetOSType, &fileType,
|
|
|
|
&vRefNum))
|
|
|
|
return NULL;
|
|
|
|
_err = SetWindowProxyCreatorAndType(_self->ob_itself,
|
|
|
|
fileCreator,
|
|
|
|
fileType,
|
|
|
|
vRefNum);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowProxyIcon(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
IconRef outIcon;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowProxyIcon
|
|
|
|
PyMac_PRECHECK(GetWindowProxyIcon);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowProxyIcon(_self->ob_itself,
|
|
|
|
&outIcon);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
ResObj_New, outIcon);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SetWindowProxyIcon(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
IconRef icon;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetWindowProxyIcon
|
|
|
|
PyMac_PRECHECK(SetWindowProxyIcon);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
ResObj_Convert, &icon))
|
|
|
|
return NULL;
|
|
|
|
_err = SetWindowProxyIcon(_self->ob_itself,
|
|
|
|
icon);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_RemoveWindowProxy(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef RemoveWindowProxy
|
|
|
|
PyMac_PRECHECK(RemoveWindowProxy);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = RemoveWindowProxy(_self->ob_itself);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_BeginWindowProxyDrag(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
DragReference outNewDrag;
|
|
|
|
RgnHandle outDragOutlineRgn;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef BeginWindowProxyDrag
|
|
|
|
PyMac_PRECHECK(BeginWindowProxyDrag);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
ResObj_Convert, &outDragOutlineRgn))
|
|
|
|
return NULL;
|
|
|
|
_err = BeginWindowProxyDrag(_self->ob_itself,
|
|
|
|
&outNewDrag,
|
|
|
|
outDragOutlineRgn);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
DragObj_New, outNewDrag);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_EndWindowProxyDrag(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
DragReference theDrag;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef EndWindowProxyDrag
|
|
|
|
PyMac_PRECHECK(EndWindowProxyDrag);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
DragObj_Convert, &theDrag))
|
|
|
|
return NULL;
|
|
|
|
_err = EndWindowProxyDrag(_self->ob_itself,
|
|
|
|
theDrag);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_TrackWindowProxyFromExistingDrag(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
Point startPt;
|
|
|
|
DragReference drag;
|
|
|
|
RgnHandle inDragOutlineRgn;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef TrackWindowProxyFromExistingDrag
|
|
|
|
PyMac_PRECHECK(TrackWindowProxyFromExistingDrag);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&O&O&",
|
|
|
|
PyMac_GetPoint, &startPt,
|
|
|
|
DragObj_Convert, &drag,
|
|
|
|
ResObj_Convert, &inDragOutlineRgn))
|
|
|
|
return NULL;
|
|
|
|
_err = TrackWindowProxyFromExistingDrag(_self->ob_itself,
|
|
|
|
startPt,
|
|
|
|
drag,
|
|
|
|
inDragOutlineRgn);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_TrackWindowProxyDrag(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
Point startPt;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef TrackWindowProxyDrag
|
|
|
|
PyMac_PRECHECK(TrackWindowProxyDrag);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
PyMac_GetPoint, &startPt))
|
|
|
|
return NULL;
|
|
|
|
_err = TrackWindowProxyDrag(_self->ob_itself,
|
|
|
|
startPt);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_IsWindowModified(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef IsWindowModified
|
|
|
|
PyMac_PRECHECK(IsWindowModified);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = IsWindowModified(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("b",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SetWindowModified(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
Boolean modified;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetWindowModified
|
|
|
|
PyMac_PRECHECK(SetWindowModified);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
|
|
&modified))
|
|
|
|
return NULL;
|
|
|
|
_err = SetWindowModified(_self->ob_itself,
|
|
|
|
modified);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_IsWindowPathSelectClick(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean _rv;
|
|
|
|
EventRecord event;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef IsWindowPathSelectClick
|
|
|
|
PyMac_PRECHECK(IsWindowPathSelectClick);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
PyMac_GetEventRecord, &event))
|
|
|
|
return NULL;
|
|
|
|
_rv = IsWindowPathSelectClick(_self->ob_itself,
|
|
|
|
&event);
|
|
|
|
_res = Py_BuildValue("b",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_WindowPathSelect(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
MenuHandle menu;
|
|
|
|
SInt32 outMenuResult;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef WindowPathSelect
|
|
|
|
PyMac_PRECHECK(WindowPathSelect);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
MenuObj_Convert, &menu))
|
|
|
|
return NULL;
|
|
|
|
_err = WindowPathSelect(_self->ob_itself,
|
|
|
|
menu,
|
|
|
|
&outMenuResult);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("l",
|
|
|
|
outMenuResult);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_HiliteWindowFrameForDrag(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
Boolean hilited;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef HiliteWindowFrameForDrag
|
|
|
|
PyMac_PRECHECK(HiliteWindowFrameForDrag);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
|
|
&hilited))
|
|
|
|
return NULL;
|
|
|
|
_err = HiliteWindowFrameForDrag(_self->ob_itself,
|
|
|
|
hilited);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_TransitionWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
2003-12-03 19:20:13 -04:00
|
|
|
WindowTransitionEffect inEffect;
|
|
|
|
WindowTransitionAction inAction;
|
|
|
|
Rect inRect;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef TransitionWindow
|
|
|
|
PyMac_PRECHECK(TransitionWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "llO&",
|
2003-12-03 19:20:13 -04:00
|
|
|
&inEffect,
|
|
|
|
&inAction,
|
|
|
|
PyMac_GetRect, &inRect))
|
2001-08-23 11:02:09 -03:00
|
|
|
return NULL;
|
|
|
|
_err = TransitionWindow(_self->ob_itself,
|
2003-12-03 19:20:13 -04:00
|
|
|
inEffect,
|
|
|
|
inAction,
|
|
|
|
&inRect);
|
2001-08-23 11:02:09 -03:00
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
2001-12-18 11:39:38 -04:00
|
|
|
static PyObject *WinObj_TransitionWindowAndParent(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
2003-12-03 19:20:13 -04:00
|
|
|
WindowPtr inParentWindow;
|
|
|
|
WindowTransitionEffect inEffect;
|
|
|
|
WindowTransitionAction inAction;
|
|
|
|
Rect inRect;
|
2001-12-18 11:39:38 -04:00
|
|
|
#ifndef TransitionWindowAndParent
|
|
|
|
PyMac_PRECHECK(TransitionWindowAndParent);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, "O&llO&",
|
2003-12-03 19:20:13 -04:00
|
|
|
WinObj_Convert, &inParentWindow,
|
|
|
|
&inEffect,
|
|
|
|
&inAction,
|
|
|
|
PyMac_GetRect, &inRect))
|
2001-12-18 11:39:38 -04:00
|
|
|
return NULL;
|
|
|
|
_err = TransitionWindowAndParent(_self->ob_itself,
|
2003-12-03 19:20:13 -04:00
|
|
|
inParentWindow,
|
|
|
|
inEffect,
|
|
|
|
inAction,
|
|
|
|
&inRect);
|
2001-12-18 11:39:38 -04:00
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
2001-08-23 11:02:09 -03:00
|
|
|
static PyObject *WinObj_MacMoveWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
short hGlobal;
|
|
|
|
short vGlobal;
|
|
|
|
Boolean front;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef MacMoveWindow
|
|
|
|
PyMac_PRECHECK(MacMoveWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "hhb",
|
|
|
|
&hGlobal,
|
|
|
|
&vGlobal,
|
|
|
|
&front))
|
|
|
|
return NULL;
|
|
|
|
MacMoveWindow(_self->ob_itself,
|
|
|
|
hGlobal,
|
|
|
|
vGlobal,
|
|
|
|
front);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SizeWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
short w;
|
|
|
|
short h;
|
|
|
|
Boolean fUpdate;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SizeWindow
|
|
|
|
PyMac_PRECHECK(SizeWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "hhb",
|
|
|
|
&w,
|
|
|
|
&h,
|
|
|
|
&fUpdate))
|
|
|
|
return NULL;
|
|
|
|
SizeWindow(_self->ob_itself,
|
|
|
|
w,
|
|
|
|
h,
|
|
|
|
fUpdate);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GrowWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
long _rv;
|
|
|
|
Point startPt;
|
|
|
|
Rect bBox;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GrowWindow
|
|
|
|
PyMac_PRECHECK(GrowWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
|
|
PyMac_GetPoint, &startPt,
|
|
|
|
PyMac_GetRect, &bBox))
|
|
|
|
return NULL;
|
|
|
|
_rv = GrowWindow(_self->ob_itself,
|
|
|
|
startPt,
|
|
|
|
&bBox);
|
|
|
|
_res = Py_BuildValue("l",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_DragWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Point startPt;
|
|
|
|
Rect boundsRect;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef DragWindow
|
|
|
|
PyMac_PRECHECK(DragWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
|
|
PyMac_GetPoint, &startPt,
|
|
|
|
PyMac_GetRect, &boundsRect))
|
|
|
|
return NULL;
|
|
|
|
DragWindow(_self->ob_itself,
|
|
|
|
startPt,
|
|
|
|
&boundsRect);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_ZoomWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
WindowPartCode partCode;
|
|
|
|
Boolean front;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef ZoomWindow
|
|
|
|
PyMac_PRECHECK(ZoomWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "hb",
|
|
|
|
&partCode,
|
|
|
|
&front))
|
|
|
|
return NULL;
|
|
|
|
ZoomWindow(_self->ob_itself,
|
|
|
|
partCode,
|
|
|
|
front);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_IsWindowCollapsable(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef IsWindowCollapsable
|
|
|
|
PyMac_PRECHECK(IsWindowCollapsable);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = IsWindowCollapsable(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("b",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_IsWindowCollapsed(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef IsWindowCollapsed
|
|
|
|
PyMac_PRECHECK(IsWindowCollapsed);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = IsWindowCollapsed(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("b",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_CollapseWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
Boolean collapse;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef CollapseWindow
|
|
|
|
PyMac_PRECHECK(CollapseWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
|
|
&collapse))
|
|
|
|
return NULL;
|
|
|
|
_err = CollapseWindow(_self->ob_itself,
|
|
|
|
collapse);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowBounds(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowRegionCode regionCode;
|
|
|
|
Rect globalBounds;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowBounds
|
|
|
|
PyMac_PRECHECK(GetWindowBounds);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "H",
|
|
|
|
®ionCode))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowBounds(_self->ob_itself,
|
|
|
|
regionCode,
|
|
|
|
&globalBounds);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
PyMac_BuildRect, &globalBounds);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_ResizeWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean _rv;
|
2003-12-03 19:20:13 -04:00
|
|
|
Point inStartPoint;
|
|
|
|
Rect inSizeConstraints;
|
|
|
|
Rect outNewContentRect;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef ResizeWindow
|
|
|
|
PyMac_PRECHECK(ResizeWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
2003-12-03 19:20:13 -04:00
|
|
|
PyMac_GetPoint, &inStartPoint,
|
|
|
|
PyMac_GetRect, &inSizeConstraints))
|
2001-08-23 11:02:09 -03:00
|
|
|
return NULL;
|
|
|
|
_rv = ResizeWindow(_self->ob_itself,
|
2003-12-03 19:20:13 -04:00
|
|
|
inStartPoint,
|
|
|
|
&inSizeConstraints,
|
|
|
|
&outNewContentRect);
|
2001-08-23 11:02:09 -03:00
|
|
|
_res = Py_BuildValue("bO&",
|
|
|
|
_rv,
|
2003-12-03 19:20:13 -04:00
|
|
|
PyMac_BuildRect, &outNewContentRect);
|
2001-08-23 11:02:09 -03:00
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SetWindowBounds(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowRegionCode regionCode;
|
|
|
|
Rect globalBounds;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetWindowBounds
|
|
|
|
PyMac_PRECHECK(SetWindowBounds);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "HO&",
|
|
|
|
®ionCode,
|
|
|
|
PyMac_GetRect, &globalBounds))
|
|
|
|
return NULL;
|
|
|
|
_err = SetWindowBounds(_self->ob_itself,
|
|
|
|
regionCode,
|
|
|
|
&globalBounds);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_RepositionWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowPtr parentWindow;
|
|
|
|
WindowPositionMethod method;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef RepositionWindow
|
|
|
|
PyMac_PRECHECK(RepositionWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&l",
|
|
|
|
WinObj_Convert, &parentWindow,
|
|
|
|
&method))
|
|
|
|
return NULL;
|
|
|
|
_err = RepositionWindow(_self->ob_itself,
|
|
|
|
parentWindow,
|
|
|
|
method);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_MoveWindowStructure(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
short hGlobal;
|
|
|
|
short vGlobal;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef MoveWindowStructure
|
|
|
|
PyMac_PRECHECK(MoveWindowStructure);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "hh",
|
|
|
|
&hGlobal,
|
|
|
|
&vGlobal))
|
|
|
|
return NULL;
|
|
|
|
_err = MoveWindowStructure(_self->ob_itself,
|
|
|
|
hGlobal,
|
|
|
|
vGlobal);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_IsWindowInStandardState(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean _rv;
|
2003-12-03 19:20:13 -04:00
|
|
|
Point inIdealSize;
|
|
|
|
Rect outIdealStandardState;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef IsWindowInStandardState
|
|
|
|
PyMac_PRECHECK(IsWindowInStandardState);
|
|
|
|
#endif
|
2003-12-03 19:20:13 -04:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
PyMac_GetPoint, &inIdealSize))
|
2001-08-23 11:02:09 -03:00
|
|
|
return NULL;
|
|
|
|
_rv = IsWindowInStandardState(_self->ob_itself,
|
2003-12-03 19:20:13 -04:00
|
|
|
&inIdealSize,
|
|
|
|
&outIdealStandardState);
|
|
|
|
_res = Py_BuildValue("bO&",
|
2001-08-23 11:02:09 -03:00
|
|
|
_rv,
|
2003-12-03 19:20:13 -04:00
|
|
|
PyMac_BuildRect, &outIdealStandardState);
|
2001-08-23 11:02:09 -03:00
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_ZoomWindowIdeal(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
2003-12-03 19:20:13 -04:00
|
|
|
WindowPartCode inPartCode;
|
2001-08-23 11:02:09 -03:00
|
|
|
Point ioIdealSize;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef ZoomWindowIdeal
|
|
|
|
PyMac_PRECHECK(ZoomWindowIdeal);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "h",
|
2003-12-03 19:20:13 -04:00
|
|
|
&inPartCode))
|
2001-08-23 11:02:09 -03:00
|
|
|
return NULL;
|
|
|
|
_err = ZoomWindowIdeal(_self->ob_itself,
|
2003-12-03 19:20:13 -04:00
|
|
|
inPartCode,
|
2001-08-23 11:02:09 -03:00
|
|
|
&ioIdealSize);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
PyMac_BuildPoint, ioIdealSize);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowIdealUserState(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
2003-12-03 19:20:13 -04:00
|
|
|
Rect outUserState;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowIdealUserState
|
|
|
|
PyMac_PRECHECK(GetWindowIdealUserState);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowIdealUserState(_self->ob_itself,
|
2003-12-03 19:20:13 -04:00
|
|
|
&outUserState);
|
2001-08-23 11:02:09 -03:00
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
2003-12-03 19:20:13 -04:00
|
|
|
PyMac_BuildRect, &outUserState);
|
2001-08-23 11:02:09 -03:00
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SetWindowIdealUserState(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
2003-12-03 19:20:13 -04:00
|
|
|
Rect inUserState;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetWindowIdealUserState
|
|
|
|
PyMac_PRECHECK(SetWindowIdealUserState);
|
|
|
|
#endif
|
2001-12-18 11:39:38 -04:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
2003-12-03 19:20:13 -04:00
|
|
|
PyMac_GetRect, &inUserState))
|
2001-08-23 11:02:09 -03:00
|
|
|
return NULL;
|
|
|
|
_err = SetWindowIdealUserState(_self->ob_itself,
|
2003-12-03 19:20:13 -04:00
|
|
|
&inUserState);
|
2001-08-23 11:02:09 -03:00
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
2001-12-18 11:39:38 -04:00
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowGreatestAreaDevice(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowRegionCode inRegion;
|
|
|
|
GDHandle outGreatestDevice;
|
|
|
|
Rect outGreatestDeviceRect;
|
|
|
|
#ifndef GetWindowGreatestAreaDevice
|
|
|
|
PyMac_PRECHECK(GetWindowGreatestAreaDevice);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, "H",
|
|
|
|
&inRegion))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowGreatestAreaDevice(_self->ob_itself,
|
|
|
|
inRegion,
|
|
|
|
&outGreatestDevice,
|
|
|
|
&outGreatestDeviceRect);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&O&",
|
|
|
|
ResObj_New, outGreatestDevice,
|
|
|
|
PyMac_BuildRect, &outGreatestDeviceRect);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_ConstrainWindowToScreen(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowRegionCode inRegionCode;
|
|
|
|
WindowConstrainOptions inOptions;
|
|
|
|
Rect inScreenRect;
|
|
|
|
Rect outStructure;
|
|
|
|
#ifndef ConstrainWindowToScreen
|
|
|
|
PyMac_PRECHECK(ConstrainWindowToScreen);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, "HlO&",
|
|
|
|
&inRegionCode,
|
|
|
|
&inOptions,
|
|
|
|
PyMac_GetRect, &inScreenRect))
|
|
|
|
return NULL;
|
|
|
|
_err = ConstrainWindowToScreen(_self->ob_itself,
|
|
|
|
inRegionCode,
|
|
|
|
inOptions,
|
|
|
|
&inScreenRect,
|
|
|
|
&outStructure);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
2001-08-23 11:02:09 -03:00
|
|
|
_res = Py_BuildValue("O&",
|
2001-12-18 11:39:38 -04:00
|
|
|
PyMac_BuildRect, &outStructure);
|
2001-08-23 11:02:09 -03:00
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_HideWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef HideWindow
|
|
|
|
PyMac_PRECHECK(HideWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
HideWindow(_self->ob_itself);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_MacShowWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef MacShowWindow
|
|
|
|
PyMac_PRECHECK(MacShowWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
MacShowWindow(_self->ob_itself);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_ShowHide(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean showFlag;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef ShowHide
|
|
|
|
PyMac_PRECHECK(ShowHide);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
|
|
&showFlag))
|
|
|
|
return NULL;
|
|
|
|
ShowHide(_self->ob_itself,
|
|
|
|
showFlag);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
2001-12-18 11:39:38 -04:00
|
|
|
static PyObject *WinObj_MacIsWindowVisible(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean _rv;
|
|
|
|
#ifndef MacIsWindowVisible
|
|
|
|
PyMac_PRECHECK(MacIsWindowVisible);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = MacIsWindowVisible(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("b",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_ShowSheetWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowPtr inParentWindow;
|
|
|
|
#ifndef ShowSheetWindow
|
|
|
|
PyMac_PRECHECK(ShowSheetWindow);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
WinObj_Convert, &inParentWindow))
|
|
|
|
return NULL;
|
|
|
|
_err = ShowSheetWindow(_self->ob_itself,
|
|
|
|
inParentWindow);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_HideSheetWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
#ifndef HideSheetWindow
|
|
|
|
PyMac_PRECHECK(HideSheetWindow);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = HideSheetWindow(_self->ob_itself);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetSheetWindowParent(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowPtr outParentWindow;
|
|
|
|
#ifndef GetSheetWindowParent
|
|
|
|
PyMac_PRECHECK(GetSheetWindowParent);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = GetSheetWindowParent(_self->ob_itself,
|
|
|
|
&outParentWindow);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
WinObj_WhichWindow, outParentWindow);
|
|
|
|
return _res;
|
|
|
|
}
|
2001-08-23 11:02:09 -03:00
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowPropertyAttributes(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
OSType propertyCreator;
|
|
|
|
OSType propertyTag;
|
|
|
|
UInt32 attributes;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowPropertyAttributes
|
|
|
|
PyMac_PRECHECK(GetWindowPropertyAttributes);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
|
|
PyMac_GetOSType, &propertyCreator,
|
|
|
|
PyMac_GetOSType, &propertyTag))
|
|
|
|
return NULL;
|
|
|
|
_err = GetWindowPropertyAttributes(_self->ob_itself,
|
|
|
|
propertyCreator,
|
|
|
|
propertyTag,
|
|
|
|
&attributes);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("l",
|
|
|
|
attributes);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_ChangeWindowPropertyAttributes(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
OSType propertyCreator;
|
|
|
|
OSType propertyTag;
|
|
|
|
UInt32 attributesToSet;
|
|
|
|
UInt32 attributesToClear;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef ChangeWindowPropertyAttributes
|
|
|
|
PyMac_PRECHECK(ChangeWindowPropertyAttributes);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&O&ll",
|
|
|
|
PyMac_GetOSType, &propertyCreator,
|
|
|
|
PyMac_GetOSType, &propertyTag,
|
|
|
|
&attributesToSet,
|
|
|
|
&attributesToClear))
|
|
|
|
return NULL;
|
|
|
|
_err = ChangeWindowPropertyAttributes(_self->ob_itself,
|
|
|
|
propertyCreator,
|
|
|
|
propertyTag,
|
|
|
|
attributesToSet,
|
|
|
|
attributesToClear);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_TrackBox(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean _rv;
|
|
|
|
Point thePt;
|
|
|
|
WindowPartCode partCode;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef TrackBox
|
|
|
|
PyMac_PRECHECK(TrackBox);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&h",
|
|
|
|
PyMac_GetPoint, &thePt,
|
|
|
|
&partCode))
|
|
|
|
return NULL;
|
|
|
|
_rv = TrackBox(_self->ob_itself,
|
|
|
|
thePt,
|
|
|
|
partCode);
|
|
|
|
_res = Py_BuildValue("b",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_TrackGoAway(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean _rv;
|
|
|
|
Point thePt;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef TrackGoAway
|
|
|
|
PyMac_PRECHECK(TrackGoAway);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
PyMac_GetPoint, &thePt))
|
|
|
|
return NULL;
|
|
|
|
_rv = TrackGoAway(_self->ob_itself,
|
|
|
|
thePt);
|
|
|
|
_res = Py_BuildValue("b",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowPort(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
CGrafPtr _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowPort
|
|
|
|
PyMac_PRECHECK(GetWindowPort);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = GetWindowPort(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
GrafObj_New, _rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
2003-12-03 19:20:13 -04:00
|
|
|
static PyObject *WinObj_GetWindowStructurePort(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
CGrafPtr _rv;
|
|
|
|
#ifndef GetWindowStructurePort
|
|
|
|
PyMac_PRECHECK(GetWindowStructurePort);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = GetWindowStructurePort(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
GrafObj_New, _rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
2001-08-23 11:02:09 -03:00
|
|
|
static PyObject *WinObj_GetWindowKind(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
short _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowKind
|
|
|
|
PyMac_PRECHECK(GetWindowKind);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = GetWindowKind(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("h",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_IsWindowHilited(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef IsWindowHilited
|
|
|
|
PyMac_PRECHECK(IsWindowHilited);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = IsWindowHilited(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("b",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_IsWindowUpdatePending(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef IsWindowUpdatePending
|
|
|
|
PyMac_PRECHECK(IsWindowUpdatePending);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = IsWindowUpdatePending(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("b",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_MacGetNextWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
WindowPtr _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef MacGetNextWindow
|
|
|
|
PyMac_PRECHECK(MacGetNextWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = MacGetNextWindow(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
WinObj_New, _rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowStandardState(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Rect rect;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowStandardState
|
|
|
|
PyMac_PRECHECK(GetWindowStandardState);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
GetWindowStandardState(_self->ob_itself,
|
|
|
|
&rect);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
PyMac_BuildRect, &rect);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowUserState(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Rect rect;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowUserState
|
|
|
|
PyMac_PRECHECK(GetWindowUserState);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
GetWindowUserState(_self->ob_itself,
|
|
|
|
&rect);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
PyMac_BuildRect, &rect);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SetWindowKind(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
short kind;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetWindowKind
|
|
|
|
PyMac_PRECHECK(SetWindowKind);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
|
|
&kind))
|
|
|
|
return NULL;
|
|
|
|
SetWindowKind(_self->ob_itself,
|
|
|
|
kind);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SetWindowStandardState(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Rect rect;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetWindowStandardState
|
|
|
|
PyMac_PRECHECK(SetWindowStandardState);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
PyMac_GetRect, &rect))
|
|
|
|
return NULL;
|
|
|
|
SetWindowStandardState(_self->ob_itself,
|
|
|
|
&rect);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SetWindowUserState(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Rect rect;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetWindowUserState
|
|
|
|
PyMac_PRECHECK(SetWindowUserState);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
PyMac_GetRect, &rect))
|
|
|
|
return NULL;
|
|
|
|
SetWindowUserState(_self->ob_itself,
|
|
|
|
&rect);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_SetPortWindowPort(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef SetPortWindowPort
|
|
|
|
PyMac_PRECHECK(SetPortWindowPort);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
SetPortWindowPort(_self->ob_itself);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowPortBounds(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Rect bounds;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowPortBounds
|
|
|
|
PyMac_PRECHECK(GetWindowPortBounds);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
GetWindowPortBounds(_self->ob_itself,
|
|
|
|
&bounds);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
PyMac_BuildRect, &bounds);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_IsWindowVisible(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef IsWindowVisible
|
|
|
|
PyMac_PRECHECK(IsWindowVisible);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = IsWindowVisible(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("b",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowStructureRgn(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
RgnHandle r;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowStructureRgn
|
|
|
|
PyMac_PRECHECK(GetWindowStructureRgn);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
ResObj_Convert, &r))
|
|
|
|
return NULL;
|
|
|
|
GetWindowStructureRgn(_self->ob_itself,
|
|
|
|
r);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowContentRgn(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
RgnHandle r;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowContentRgn
|
|
|
|
PyMac_PRECHECK(GetWindowContentRgn);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
ResObj_Convert, &r))
|
|
|
|
return NULL;
|
|
|
|
GetWindowContentRgn(_self->ob_itself,
|
|
|
|
r);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetWindowUpdateRgn(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
RgnHandle r;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowUpdateRgn
|
|
|
|
PyMac_PRECHECK(GetWindowUpdateRgn);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
ResObj_Convert, &r))
|
|
|
|
return NULL;
|
|
|
|
GetWindowUpdateRgn(_self->ob_itself,
|
|
|
|
r);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_GetNextWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
WindowPtr _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetNextWindow
|
|
|
|
PyMac_PRECHECK(GetNextWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = GetNextWindow(_self->ob_itself);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
WinObj_WhichWindow, _rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_MoveWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
short hGlobal;
|
|
|
|
short vGlobal;
|
|
|
|
Boolean front;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef MoveWindow
|
|
|
|
PyMac_PRECHECK(MoveWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "hhb",
|
|
|
|
&hGlobal,
|
|
|
|
&vGlobal,
|
|
|
|
&front))
|
|
|
|
return NULL;
|
|
|
|
MoveWindow(_self->ob_itself,
|
|
|
|
hGlobal,
|
|
|
|
vGlobal,
|
|
|
|
front);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *WinObj_ShowWindow(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef ShowWindow
|
|
|
|
PyMac_PRECHECK(ShowWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
ShowWindow(_self->ob_itself);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
2003-04-22 10:55:23 -03:00
|
|
|
static PyObject *WinObj_AutoDispose(WindowObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
|
|
|
|
int onoff, old = 0;
|
|
|
|
if (!PyArg_ParseTuple(_args, "i", &onoff))
|
2005-07-03 17:59:44 -03:00
|
|
|
return NULL;
|
2003-04-22 10:55:23 -03:00
|
|
|
if ( _self->ob_freeit )
|
2005-07-03 17:59:44 -03:00
|
|
|
old = 1;
|
2003-04-22 10:55:23 -03:00
|
|
|
if ( onoff )
|
2005-07-03 17:59:44 -03:00
|
|
|
_self->ob_freeit = PyMac_AutoDisposeWindow;
|
2003-04-22 10:55:23 -03:00
|
|
|
else
|
2005-07-03 17:59:44 -03:00
|
|
|
_self->ob_freeit = NULL;
|
2003-04-22 10:55:23 -03:00
|
|
|
_res = Py_BuildValue("i", old);
|
|
|
|
return _res;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2001-08-23 11:02:09 -03:00
|
|
|
static PyMethodDef WinObj_methods[] = {
|
|
|
|
{"GetWindowOwnerCount", (PyCFunction)WinObj_GetWindowOwnerCount, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (UInt32 outCount)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"CloneWindow", (PyCFunction)WinObj_CloneWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"GetWindowRetainCount", (PyCFunction)WinObj_GetWindowRetainCount, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (ItemCount _rv)")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"RetainWindow", (PyCFunction)WinObj_RetainWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"ReleaseWindow", (PyCFunction)WinObj_ReleaseWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"ReshapeCustomWindow", (PyCFunction)WinObj_ReshapeCustomWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"GetWindowWidgetHilite", (PyCFunction)WinObj_GetWindowWidgetHilite, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (WindowDefPartCode outHilite)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowClass", (PyCFunction)WinObj_GetWindowClass, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (WindowClass outClass)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowAttributes", (PyCFunction)WinObj_GetWindowAttributes, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (WindowAttributes outAttributes)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"ChangeWindowAttributes", (PyCFunction)WinObj_ChangeWindowAttributes, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(WindowAttributes setTheseAttributes, WindowAttributes clearTheseAttributes) -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"SetWindowClass", (PyCFunction)WinObj_SetWindowClass, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(WindowClass inWindowClass) -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"SetWindowModality", (PyCFunction)WinObj_SetWindowModality, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(WindowModality inModalKind, WindowPtr inUnavailableWindow) -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"GetWindowModality", (PyCFunction)WinObj_GetWindowModality, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (WindowModality outModalKind, WindowPtr outUnavailableWindow)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetWindowContentColor", (PyCFunction)WinObj_SetWindowContentColor, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(RGBColor color) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowContentColor", (PyCFunction)WinObj_GetWindowContentColor, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (RGBColor color)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowContentPattern", (PyCFunction)WinObj_GetWindowContentPattern, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(PixPatHandle outPixPat) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetWindowContentPattern", (PyCFunction)WinObj_SetWindowContentPattern, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(PixPatHandle pixPat) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"ScrollWindowRect", (PyCFunction)WinObj_ScrollWindowRect, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Rect inScrollRect, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"ScrollWindowRegion", (PyCFunction)WinObj_ScrollWindowRegion, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(RgnHandle inScrollRgn, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"ClipAbove", (PyCFunction)WinObj_ClipAbove, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"PaintOne", (PyCFunction)WinObj_PaintOne, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(RgnHandle clobberedRgn) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"PaintBehind", (PyCFunction)WinObj_PaintBehind, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(RgnHandle clobberedRgn) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"CalcVis", (PyCFunction)WinObj_CalcVis, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"CalcVisBehind", (PyCFunction)WinObj_CalcVisBehind, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(RgnHandle clobberedRgn) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"BringToFront", (PyCFunction)WinObj_BringToFront, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SendBehind", (PyCFunction)WinObj_SendBehind, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(WindowPtr behindWindow) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SelectWindow", (PyCFunction)WinObj_SelectWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetNextWindowOfClass", (PyCFunction)WinObj_GetNextWindowOfClass, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"SetWindowAlternateTitle", (PyCFunction)WinObj_SetWindowAlternateTitle, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(CFStringRef inTitle) -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"CopyWindowAlternateTitle", (PyCFunction)WinObj_CopyWindowAlternateTitle, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (CFStringRef outTitle)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"HiliteWindow", (PyCFunction)WinObj_HiliteWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Boolean fHilite) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetWRefCon", (PyCFunction)WinObj_SetWRefCon, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(long data) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWRefCon", (PyCFunction)WinObj_GetWRefCon, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (long _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetWindowPic", (PyCFunction)WinObj_SetWindowPic, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(PicHandle pic) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowPic", (PyCFunction)WinObj_GetWindowPic, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (PicHandle _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWVariant", (PyCFunction)WinObj_GetWVariant, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (short _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowFeatures", (PyCFunction)WinObj_GetWindowFeatures, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (UInt32 outFeatures)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowRegion", (PyCFunction)WinObj_GetWindowRegion, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(WindowRegionCode inRegionCode, RgnHandle ioWinRgn) -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"GetWindowStructureWidths", (PyCFunction)WinObj_GetWindowStructureWidths, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (Rect outRect)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"BeginUpdate", (PyCFunction)WinObj_BeginUpdate, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"EndUpdate", (PyCFunction)WinObj_EndUpdate, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"InvalWindowRgn", (PyCFunction)WinObj_InvalWindowRgn, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(RgnHandle region) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"InvalWindowRect", (PyCFunction)WinObj_InvalWindowRect, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Rect bounds) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"ValidWindowRgn", (PyCFunction)WinObj_ValidWindowRgn, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(RgnHandle region) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"ValidWindowRect", (PyCFunction)WinObj_ValidWindowRect, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Rect bounds) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"DrawGrowIcon", (PyCFunction)WinObj_DrawGrowIcon, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetWTitle", (PyCFunction)WinObj_SetWTitle, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Str255 title) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWTitle", (PyCFunction)WinObj_GetWTitle, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (Str255 title)")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"SetWindowTitleWithCFString", (PyCFunction)WinObj_SetWindowTitleWithCFString, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(CFStringRef inString) -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"CopyWindowTitleAsCFString", (PyCFunction)WinObj_CopyWindowTitleAsCFString, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (CFStringRef outString)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetWindowProxyFSSpec", (PyCFunction)WinObj_SetWindowProxyFSSpec, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(FSSpec inFile) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowProxyFSSpec", (PyCFunction)WinObj_GetWindowProxyFSSpec, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (FSSpec outFile)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetWindowProxyAlias", (PyCFunction)WinObj_SetWindowProxyAlias, 1,
|
2003-12-03 19:20:13 -04:00
|
|
|
PyDoc_STR("(AliasHandle inAlias) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowProxyAlias", (PyCFunction)WinObj_GetWindowProxyAlias, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (AliasHandle alias)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetWindowProxyCreatorAndType", (PyCFunction)WinObj_SetWindowProxyCreatorAndType, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(OSType fileCreator, OSType fileType, SInt16 vRefNum) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowProxyIcon", (PyCFunction)WinObj_GetWindowProxyIcon, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (IconRef outIcon)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetWindowProxyIcon", (PyCFunction)WinObj_SetWindowProxyIcon, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(IconRef icon) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"RemoveWindowProxy", (PyCFunction)WinObj_RemoveWindowProxy, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"BeginWindowProxyDrag", (PyCFunction)WinObj_BeginWindowProxyDrag, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(RgnHandle outDragOutlineRgn) -> (DragReference outNewDrag)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"EndWindowProxyDrag", (PyCFunction)WinObj_EndWindowProxyDrag, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(DragReference theDrag) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"TrackWindowProxyFromExistingDrag", (PyCFunction)WinObj_TrackWindowProxyFromExistingDrag, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Point startPt, DragReference drag, RgnHandle inDragOutlineRgn) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"TrackWindowProxyDrag", (PyCFunction)WinObj_TrackWindowProxyDrag, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Point startPt) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"IsWindowModified", (PyCFunction)WinObj_IsWindowModified, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (Boolean _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetWindowModified", (PyCFunction)WinObj_SetWindowModified, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Boolean modified) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"IsWindowPathSelectClick", (PyCFunction)WinObj_IsWindowPathSelectClick, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(EventRecord event) -> (Boolean _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"WindowPathSelect", (PyCFunction)WinObj_WindowPathSelect, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(MenuHandle menu) -> (SInt32 outMenuResult)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"HiliteWindowFrameForDrag", (PyCFunction)WinObj_HiliteWindowFrameForDrag, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Boolean hilited) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"TransitionWindow", (PyCFunction)WinObj_TransitionWindow, 1,
|
2003-12-03 19:20:13 -04:00
|
|
|
PyDoc_STR("(WindowTransitionEffect inEffect, WindowTransitionAction inAction, Rect inRect) -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"TransitionWindowAndParent", (PyCFunction)WinObj_TransitionWindowAndParent, 1,
|
2003-12-03 19:20:13 -04:00
|
|
|
PyDoc_STR("(WindowPtr inParentWindow, WindowTransitionEffect inEffect, WindowTransitionAction inAction, Rect inRect) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"MacMoveWindow", (PyCFunction)WinObj_MacMoveWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(short hGlobal, short vGlobal, Boolean front) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SizeWindow", (PyCFunction)WinObj_SizeWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(short w, short h, Boolean fUpdate) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GrowWindow", (PyCFunction)WinObj_GrowWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Point startPt, Rect bBox) -> (long _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"DragWindow", (PyCFunction)WinObj_DragWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Point startPt, Rect boundsRect) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"ZoomWindow", (PyCFunction)WinObj_ZoomWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(WindowPartCode partCode, Boolean front) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"IsWindowCollapsable", (PyCFunction)WinObj_IsWindowCollapsable, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (Boolean _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"IsWindowCollapsed", (PyCFunction)WinObj_IsWindowCollapsed, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (Boolean _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"CollapseWindow", (PyCFunction)WinObj_CollapseWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Boolean collapse) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowBounds", (PyCFunction)WinObj_GetWindowBounds, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(WindowRegionCode regionCode) -> (Rect globalBounds)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"ResizeWindow", (PyCFunction)WinObj_ResizeWindow, 1,
|
2003-12-03 19:20:13 -04:00
|
|
|
PyDoc_STR("(Point inStartPoint, Rect inSizeConstraints) -> (Boolean _rv, Rect outNewContentRect)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetWindowBounds", (PyCFunction)WinObj_SetWindowBounds, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(WindowRegionCode regionCode, Rect globalBounds) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"RepositionWindow", (PyCFunction)WinObj_RepositionWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(WindowPtr parentWindow, WindowPositionMethod method) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"MoveWindowStructure", (PyCFunction)WinObj_MoveWindowStructure, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(short hGlobal, short vGlobal) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"IsWindowInStandardState", (PyCFunction)WinObj_IsWindowInStandardState, 1,
|
2003-12-03 19:20:13 -04:00
|
|
|
PyDoc_STR("(Point inIdealSize) -> (Boolean _rv, Rect outIdealStandardState)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"ZoomWindowIdeal", (PyCFunction)WinObj_ZoomWindowIdeal, 1,
|
2003-12-03 19:20:13 -04:00
|
|
|
PyDoc_STR("(WindowPartCode inPartCode) -> (Point ioIdealSize)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowIdealUserState", (PyCFunction)WinObj_GetWindowIdealUserState, 1,
|
2003-12-03 19:20:13 -04:00
|
|
|
PyDoc_STR("() -> (Rect outUserState)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetWindowIdealUserState", (PyCFunction)WinObj_SetWindowIdealUserState, 1,
|
2003-12-03 19:20:13 -04:00
|
|
|
PyDoc_STR("(Rect inUserState) -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"GetWindowGreatestAreaDevice", (PyCFunction)WinObj_GetWindowGreatestAreaDevice, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(WindowRegionCode inRegion) -> (GDHandle outGreatestDevice, Rect outGreatestDeviceRect)")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"ConstrainWindowToScreen", (PyCFunction)WinObj_ConstrainWindowToScreen, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(WindowRegionCode inRegionCode, WindowConstrainOptions inOptions, Rect inScreenRect) -> (Rect outStructure)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"HideWindow", (PyCFunction)WinObj_HideWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"MacShowWindow", (PyCFunction)WinObj_MacShowWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"ShowHide", (PyCFunction)WinObj_ShowHide, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Boolean showFlag) -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"MacIsWindowVisible", (PyCFunction)WinObj_MacIsWindowVisible, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (Boolean _rv)")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"ShowSheetWindow", (PyCFunction)WinObj_ShowSheetWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(WindowPtr inParentWindow) -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"HideSheetWindow", (PyCFunction)WinObj_HideSheetWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"GetSheetWindowParent", (PyCFunction)WinObj_GetSheetWindowParent, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (WindowPtr outParentWindow)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowPropertyAttributes", (PyCFunction)WinObj_GetWindowPropertyAttributes, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"ChangeWindowPropertyAttributes", (PyCFunction)WinObj_ChangeWindowPropertyAttributes, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"TrackBox", (PyCFunction)WinObj_TrackBox, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Point thePt, WindowPartCode partCode) -> (Boolean _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"TrackGoAway", (PyCFunction)WinObj_TrackGoAway, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Point thePt) -> (Boolean _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowPort", (PyCFunction)WinObj_GetWindowPort, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (CGrafPtr _rv)")},
|
2003-12-03 19:20:13 -04:00
|
|
|
{"GetWindowStructurePort", (PyCFunction)WinObj_GetWindowStructurePort, 1,
|
|
|
|
PyDoc_STR("() -> (CGrafPtr _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowKind", (PyCFunction)WinObj_GetWindowKind, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (short _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"IsWindowHilited", (PyCFunction)WinObj_IsWindowHilited, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (Boolean _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"IsWindowUpdatePending", (PyCFunction)WinObj_IsWindowUpdatePending, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (Boolean _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"MacGetNextWindow", (PyCFunction)WinObj_MacGetNextWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (WindowPtr _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowStandardState", (PyCFunction)WinObj_GetWindowStandardState, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (Rect rect)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowUserState", (PyCFunction)WinObj_GetWindowUserState, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (Rect rect)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetWindowKind", (PyCFunction)WinObj_SetWindowKind, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(short kind) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetWindowStandardState", (PyCFunction)WinObj_SetWindowStandardState, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Rect rect) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetWindowUserState", (PyCFunction)WinObj_SetWindowUserState, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Rect rect) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"SetPortWindowPort", (PyCFunction)WinObj_SetPortWindowPort, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowPortBounds", (PyCFunction)WinObj_GetWindowPortBounds, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (Rect bounds)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"IsWindowVisible", (PyCFunction)WinObj_IsWindowVisible, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (Boolean _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowStructureRgn", (PyCFunction)WinObj_GetWindowStructureRgn, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(RgnHandle r) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowContentRgn", (PyCFunction)WinObj_GetWindowContentRgn, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(RgnHandle r) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowUpdateRgn", (PyCFunction)WinObj_GetWindowUpdateRgn, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(RgnHandle r) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetNextWindow", (PyCFunction)WinObj_GetNextWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (WindowPtr _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"MoveWindow", (PyCFunction)WinObj_MoveWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(short hGlobal, short vGlobal, Boolean front) -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"ShowWindow", (PyCFunction)WinObj_ShowWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2003-04-22 10:55:23 -03:00
|
|
|
{"AutoDispose", (PyCFunction)WinObj_AutoDispose, 1,
|
|
|
|
PyDoc_STR("(int)->int. Automatically DisposeHandle the object on Python object cleanup")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{NULL, NULL, 0}
|
|
|
|
};
|
|
|
|
|
2002-11-29 19:40:48 -04:00
|
|
|
#define WinObj_getsetlist NULL
|
2001-08-23 11:02:09 -03:00
|
|
|
|
2002-12-03 19:40:22 -04:00
|
|
|
|
2001-08-23 11:02:09 -03:00
|
|
|
static int WinObj_compare(WindowObject *self, WindowObject *other)
|
|
|
|
{
|
|
|
|
if ( self->ob_itself > other->ob_itself ) return 1;
|
|
|
|
if ( self->ob_itself < other->ob_itself ) return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject * WinObj_repr(WindowObject *self)
|
|
|
|
{
|
|
|
|
char buf[100];
|
2001-09-05 07:31:52 -03:00
|
|
|
sprintf(buf, "<Window object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
|
2007-05-18 14:15:44 -03:00
|
|
|
return PyUnicode_FromString(buf);
|
2001-08-23 11:02:09 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int WinObj_hash(WindowObject *self)
|
|
|
|
{
|
|
|
|
return (int)self->ob_itself;
|
|
|
|
}
|
2002-12-03 19:40:22 -04:00
|
|
|
#define WinObj_tp_init 0
|
|
|
|
|
|
|
|
#define WinObj_tp_alloc PyType_GenericAlloc
|
|
|
|
|
2005-07-03 17:59:44 -03:00
|
|
|
static PyObject *WinObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
|
2002-12-03 19:40:22 -04:00
|
|
|
{
|
2005-07-03 17:59:44 -03:00
|
|
|
PyObject *_self;
|
2002-12-03 19:40:22 -04:00
|
|
|
WindowPtr itself;
|
|
|
|
char *kw[] = {"itself", 0};
|
|
|
|
|
2005-07-03 17:59:44 -03:00
|
|
|
if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, WinObj_Convert, &itself)) return NULL;
|
|
|
|
if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
|
|
|
|
((WindowObject *)_self)->ob_itself = itself;
|
|
|
|
return _self;
|
2002-12-03 19:40:22 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
#define WinObj_tp_free PyObject_Del
|
|
|
|
|
2001-08-23 11:02:09 -03:00
|
|
|
|
|
|
|
PyTypeObject Window_Type = {
|
2007-07-22 11:41:55 -03:00
|
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
2001-12-08 14:02:58 -04:00
|
|
|
"_Win.Window", /*tp_name*/
|
2001-08-23 11:02:09 -03:00
|
|
|
sizeof(WindowObject), /*tp_basicsize*/
|
|
|
|
0, /*tp_itemsize*/
|
|
|
|
/* methods */
|
|
|
|
(destructor) WinObj_dealloc, /*tp_dealloc*/
|
|
|
|
0, /*tp_print*/
|
2002-11-29 19:40:48 -04:00
|
|
|
(getattrfunc)0, /*tp_getattr*/
|
|
|
|
(setattrfunc)0, /*tp_setattr*/
|
2001-08-23 11:02:09 -03:00
|
|
|
(cmpfunc) WinObj_compare, /*tp_compare*/
|
|
|
|
(reprfunc) WinObj_repr, /*tp_repr*/
|
|
|
|
(PyNumberMethods *)0, /* tp_as_number */
|
|
|
|
(PySequenceMethods *)0, /* tp_as_sequence */
|
|
|
|
(PyMappingMethods *)0, /* tp_as_mapping */
|
|
|
|
(hashfunc) WinObj_hash, /*tp_hash*/
|
2002-11-29 19:40:48 -04:00
|
|
|
0, /*tp_call*/
|
|
|
|
0, /*tp_str*/
|
|
|
|
PyObject_GenericGetAttr, /*tp_getattro*/
|
|
|
|
PyObject_GenericSetAttr, /*tp_setattro */
|
2002-12-03 19:40:22 -04:00
|
|
|
0, /*tp_as_buffer*/
|
|
|
|
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
|
|
|
|
0, /*tp_doc*/
|
|
|
|
0, /*tp_traverse*/
|
|
|
|
0, /*tp_clear*/
|
|
|
|
0, /*tp_richcompare*/
|
|
|
|
0, /*tp_weaklistoffset*/
|
|
|
|
0, /*tp_iter*/
|
|
|
|
0, /*tp_iternext*/
|
2002-11-29 19:40:48 -04:00
|
|
|
WinObj_methods, /* tp_methods */
|
2002-12-03 19:40:22 -04:00
|
|
|
0, /*tp_members*/
|
2002-11-29 19:40:48 -04:00
|
|
|
WinObj_getsetlist, /*tp_getset*/
|
2002-12-03 19:40:22 -04:00
|
|
|
0, /*tp_base*/
|
|
|
|
0, /*tp_dict*/
|
|
|
|
0, /*tp_descr_get*/
|
|
|
|
0, /*tp_descr_set*/
|
|
|
|
0, /*tp_dictoffset*/
|
|
|
|
WinObj_tp_init, /* tp_init */
|
|
|
|
WinObj_tp_alloc, /* tp_alloc */
|
|
|
|
WinObj_tp_new, /* tp_new */
|
|
|
|
WinObj_tp_free, /* tp_free */
|
2001-08-23 11:02:09 -03:00
|
|
|
};
|
|
|
|
|
|
|
|
/* --------------------- End object type Window --------------------- */
|
|
|
|
|
|
|
|
|
|
|
|
static PyObject *Win_GetNewCWindow(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
WindowPtr _rv;
|
|
|
|
short windowID;
|
|
|
|
WindowPtr behind;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetNewCWindow
|
|
|
|
PyMac_PRECHECK(GetNewCWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "hO&",
|
|
|
|
&windowID,
|
|
|
|
WinObj_Convert, &behind))
|
|
|
|
return NULL;
|
|
|
|
_rv = GetNewCWindow(windowID,
|
|
|
|
(void *)0,
|
|
|
|
behind);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
WinObj_New, _rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_NewWindow(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
WindowPtr _rv;
|
|
|
|
Rect boundsRect;
|
|
|
|
Str255 title;
|
|
|
|
Boolean visible;
|
|
|
|
short theProc;
|
|
|
|
WindowPtr behind;
|
|
|
|
Boolean goAwayFlag;
|
|
|
|
long refCon;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef NewWindow
|
|
|
|
PyMac_PRECHECK(NewWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
|
|
|
|
PyMac_GetRect, &boundsRect,
|
|
|
|
PyMac_GetStr255, title,
|
|
|
|
&visible,
|
|
|
|
&theProc,
|
|
|
|
WinObj_Convert, &behind,
|
|
|
|
&goAwayFlag,
|
|
|
|
&refCon))
|
|
|
|
return NULL;
|
|
|
|
_rv = NewWindow((void *)0,
|
|
|
|
&boundsRect,
|
|
|
|
title,
|
|
|
|
visible,
|
|
|
|
theProc,
|
|
|
|
behind,
|
|
|
|
goAwayFlag,
|
|
|
|
refCon);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
WinObj_New, _rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_GetNewWindow(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
WindowPtr _rv;
|
|
|
|
short windowID;
|
|
|
|
WindowPtr behind;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetNewWindow
|
|
|
|
PyMac_PRECHECK(GetNewWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "hO&",
|
|
|
|
&windowID,
|
|
|
|
WinObj_Convert, &behind))
|
|
|
|
return NULL;
|
|
|
|
_rv = GetNewWindow(windowID,
|
|
|
|
(void *)0,
|
|
|
|
behind);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
WinObj_New, _rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_NewCWindow(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
WindowPtr _rv;
|
|
|
|
Rect boundsRect;
|
|
|
|
Str255 title;
|
|
|
|
Boolean visible;
|
|
|
|
short procID;
|
|
|
|
WindowPtr behind;
|
|
|
|
Boolean goAwayFlag;
|
|
|
|
long refCon;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef NewCWindow
|
|
|
|
PyMac_PRECHECK(NewCWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
|
|
|
|
PyMac_GetRect, &boundsRect,
|
|
|
|
PyMac_GetStr255, title,
|
|
|
|
&visible,
|
|
|
|
&procID,
|
|
|
|
WinObj_Convert, &behind,
|
|
|
|
&goAwayFlag,
|
|
|
|
&refCon))
|
|
|
|
return NULL;
|
|
|
|
_rv = NewCWindow((void *)0,
|
|
|
|
&boundsRect,
|
|
|
|
title,
|
|
|
|
visible,
|
|
|
|
procID,
|
|
|
|
behind,
|
|
|
|
goAwayFlag,
|
|
|
|
refCon);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
WinObj_New, _rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_CreateNewWindow(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
WindowClass windowClass;
|
|
|
|
WindowAttributes attributes;
|
|
|
|
Rect contentBounds;
|
|
|
|
WindowPtr outWindow;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef CreateNewWindow
|
|
|
|
PyMac_PRECHECK(CreateNewWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "llO&",
|
|
|
|
&windowClass,
|
|
|
|
&attributes,
|
|
|
|
PyMac_GetRect, &contentBounds))
|
|
|
|
return NULL;
|
|
|
|
_err = CreateNewWindow(windowClass,
|
|
|
|
attributes,
|
|
|
|
&contentBounds,
|
|
|
|
&outWindow);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
2002-06-05 14:41:03 -03:00
|
|
|
WinObj_New, outWindow);
|
2001-08-23 11:02:09 -03:00
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_CreateWindowFromResource(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
SInt16 resID;
|
|
|
|
WindowPtr outWindow;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef CreateWindowFromResource
|
|
|
|
PyMac_PRECHECK(CreateWindowFromResource);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
|
|
&resID))
|
|
|
|
return NULL;
|
|
|
|
_err = CreateWindowFromResource(resID,
|
|
|
|
&outWindow);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
2002-06-05 14:41:03 -03:00
|
|
|
WinObj_New, outWindow);
|
2001-08-23 11:02:09 -03:00
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_ShowFloatingWindows(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef ShowFloatingWindows
|
|
|
|
PyMac_PRECHECK(ShowFloatingWindows);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = ShowFloatingWindows();
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_HideFloatingWindows(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef HideFloatingWindows
|
|
|
|
PyMac_PRECHECK(HideFloatingWindows);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = HideFloatingWindows();
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_AreFloatingWindowsVisible(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef AreFloatingWindowsVisible
|
|
|
|
PyMac_PRECHECK(AreFloatingWindowsVisible);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = AreFloatingWindowsVisible();
|
|
|
|
_res = Py_BuildValue("b",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_CheckUpdate(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
Boolean _rv;
|
|
|
|
EventRecord theEvent;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef CheckUpdate
|
|
|
|
PyMac_PRECHECK(CheckUpdate);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = CheckUpdate(&theEvent);
|
|
|
|
_res = Py_BuildValue("bO&",
|
|
|
|
_rv,
|
|
|
|
PyMac_BuildEventRecord, &theEvent);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_MacFindWindow(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
WindowPartCode _rv;
|
|
|
|
Point thePoint;
|
|
|
|
WindowPtr window;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef MacFindWindow
|
|
|
|
PyMac_PRECHECK(MacFindWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
PyMac_GetPoint, &thePoint))
|
|
|
|
return NULL;
|
|
|
|
_rv = MacFindWindow(thePoint,
|
|
|
|
&window);
|
|
|
|
_res = Py_BuildValue("hO&",
|
|
|
|
_rv,
|
|
|
|
WinObj_WhichWindow, window);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_FrontWindow(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
WindowPtr _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef FrontWindow
|
|
|
|
PyMac_PRECHECK(FrontWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = FrontWindow();
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
WinObj_WhichWindow, _rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_FrontNonFloatingWindow(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
WindowPtr _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef FrontNonFloatingWindow
|
|
|
|
PyMac_PRECHECK(FrontNonFloatingWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = FrontNonFloatingWindow();
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
WinObj_WhichWindow, _rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_GetFrontWindowOfClass(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
WindowPtr _rv;
|
|
|
|
WindowClass inWindowClass;
|
|
|
|
Boolean mustBeVisible;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetFrontWindowOfClass
|
|
|
|
PyMac_PRECHECK(GetFrontWindowOfClass);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "lb",
|
|
|
|
&inWindowClass,
|
|
|
|
&mustBeVisible))
|
|
|
|
return NULL;
|
|
|
|
_rv = GetFrontWindowOfClass(inWindowClass,
|
|
|
|
mustBeVisible);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
WinObj_New, _rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_FindWindowOfClass(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
Point where;
|
|
|
|
WindowClass inWindowClass;
|
|
|
|
WindowPtr outWindow;
|
|
|
|
WindowPartCode outWindowPart;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef FindWindowOfClass
|
|
|
|
PyMac_PRECHECK(FindWindowOfClass);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&l",
|
|
|
|
PyMac_GetPoint, &where,
|
|
|
|
&inWindowClass))
|
|
|
|
return NULL;
|
|
|
|
_err = FindWindowOfClass(&where,
|
|
|
|
inWindowClass,
|
|
|
|
&outWindow,
|
|
|
|
&outWindowPart);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&h",
|
|
|
|
WinObj_WhichWindow, outWindow,
|
|
|
|
outWindowPart);
|
|
|
|
return _res;
|
|
|
|
}
|
2001-12-18 11:39:38 -04:00
|
|
|
|
|
|
|
static PyObject *Win_CreateStandardWindowMenu(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
OptionBits inOptions;
|
|
|
|
MenuHandle outMenu;
|
|
|
|
#ifndef CreateStandardWindowMenu
|
|
|
|
PyMac_PRECHECK(CreateStandardWindowMenu);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, "l",
|
|
|
|
&inOptions))
|
|
|
|
return NULL;
|
|
|
|
_err = CreateStandardWindowMenu(inOptions,
|
|
|
|
&outMenu);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
MenuObj_New, outMenu);
|
|
|
|
return _res;
|
|
|
|
}
|
2001-08-23 11:02:09 -03:00
|
|
|
|
|
|
|
static PyObject *Win_CollapseAllWindows(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
Boolean collapse;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef CollapseAllWindows
|
|
|
|
PyMac_PRECHECK(CollapseAllWindows);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
|
|
&collapse))
|
|
|
|
return NULL;
|
|
|
|
_err = CollapseAllWindows(collapse);
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
2001-12-18 11:39:38 -04:00
|
|
|
static PyObject *Win_GetAvailableWindowPositioningBounds(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
GDHandle inDevice;
|
2003-12-03 19:20:13 -04:00
|
|
|
Rect outAvailableRect;
|
2001-12-18 11:39:38 -04:00
|
|
|
#ifndef GetAvailableWindowPositioningBounds
|
|
|
|
PyMac_PRECHECK(GetAvailableWindowPositioningBounds);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
ResObj_Convert, &inDevice))
|
|
|
|
return NULL;
|
|
|
|
_err = GetAvailableWindowPositioningBounds(inDevice,
|
2003-12-03 19:20:13 -04:00
|
|
|
&outAvailableRect);
|
2001-12-18 11:39:38 -04:00
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
_res = Py_BuildValue("O&",
|
2003-12-03 19:20:13 -04:00
|
|
|
PyMac_BuildRect, &outAvailableRect);
|
2001-12-18 11:39:38 -04:00
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_DisableScreenUpdates(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
#ifndef DisableScreenUpdates
|
|
|
|
PyMac_PRECHECK(DisableScreenUpdates);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = DisableScreenUpdates();
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_EnableScreenUpdates(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
|
|
#ifndef EnableScreenUpdates
|
|
|
|
PyMac_PRECHECK(EnableScreenUpdates);
|
|
|
|
#endif
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_err = EnableScreenUpdates();
|
|
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
_res = Py_None;
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
2001-08-23 11:02:09 -03:00
|
|
|
static PyObject *Win_PinRect(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
long _rv;
|
|
|
|
Rect theRect;
|
|
|
|
Point thePt;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef PinRect
|
|
|
|
PyMac_PRECHECK(PinRect);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
|
|
PyMac_GetRect, &theRect,
|
|
|
|
PyMac_GetPoint, &thePt))
|
|
|
|
return NULL;
|
|
|
|
_rv = PinRect(&theRect,
|
|
|
|
thePt);
|
|
|
|
_res = Py_BuildValue("l",
|
|
|
|
_rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_GetGrayRgn(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
RgnHandle _rv;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetGrayRgn
|
|
|
|
PyMac_PRECHECK(GetGrayRgn);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
|
|
return NULL;
|
|
|
|
_rv = GetGrayRgn();
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
ResObj_New, _rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_GetWindowFromPort(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
WindowPtr _rv;
|
|
|
|
CGrafPtr port;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef GetWindowFromPort
|
|
|
|
PyMac_PRECHECK(GetWindowFromPort);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
GrafObj_Convert, &port))
|
|
|
|
return NULL;
|
|
|
|
_rv = GetWindowFromPort(port);
|
|
|
|
_res = Py_BuildValue("O&",
|
|
|
|
WinObj_New, _rv);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_WhichWindow(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
|
|
|
|
long ptr;
|
|
|
|
|
|
|
|
if ( !PyArg_ParseTuple(_args, "i", &ptr) )
|
2005-07-03 17:59:44 -03:00
|
|
|
return NULL;
|
2001-09-05 07:31:52 -03:00
|
|
|
_res = WinObj_WhichWindow((WindowPtr)ptr);
|
|
|
|
return _res;
|
2001-08-23 11:02:09 -03:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *Win_FindWindow(PyObject *_self, PyObject *_args)
|
|
|
|
{
|
|
|
|
PyObject *_res = NULL;
|
|
|
|
short _rv;
|
|
|
|
Point thePoint;
|
|
|
|
WindowPtr theWindow;
|
2001-11-30 10:16:36 -04:00
|
|
|
#ifndef FindWindow
|
|
|
|
PyMac_PRECHECK(FindWindow);
|
|
|
|
#endif
|
2001-08-23 11:02:09 -03:00
|
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
|
|
PyMac_GetPoint, &thePoint))
|
|
|
|
return NULL;
|
|
|
|
_rv = FindWindow(thePoint,
|
|
|
|
&theWindow);
|
|
|
|
_res = Py_BuildValue("hO&",
|
|
|
|
_rv,
|
|
|
|
WinObj_WhichWindow, theWindow);
|
|
|
|
return _res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyMethodDef Win_methods[] = {
|
|
|
|
{"GetNewCWindow", (PyCFunction)Win_GetNewCWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"NewWindow", (PyCFunction)Win_NewWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetNewWindow", (PyCFunction)Win_GetNewWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"NewCWindow", (PyCFunction)Win_NewCWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"CreateNewWindow", (PyCFunction)Win_CreateNewWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(WindowClass windowClass, WindowAttributes attributes, Rect contentBounds) -> (WindowPtr outWindow)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"CreateWindowFromResource", (PyCFunction)Win_CreateWindowFromResource, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(SInt16 resID) -> (WindowPtr outWindow)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"ShowFloatingWindows", (PyCFunction)Win_ShowFloatingWindows, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"HideFloatingWindows", (PyCFunction)Win_HideFloatingWindows, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"AreFloatingWindowsVisible", (PyCFunction)Win_AreFloatingWindowsVisible, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (Boolean _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"CheckUpdate", (PyCFunction)Win_CheckUpdate, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (Boolean _rv, EventRecord theEvent)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"MacFindWindow", (PyCFunction)Win_MacFindWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Point thePoint) -> (WindowPartCode _rv, WindowPtr window)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"FrontWindow", (PyCFunction)Win_FrontWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (WindowPtr _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"FrontNonFloatingWindow", (PyCFunction)Win_FrontNonFloatingWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (WindowPtr _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetFrontWindowOfClass", (PyCFunction)Win_GetFrontWindowOfClass, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"FindWindowOfClass", (PyCFunction)Win_FindWindowOfClass, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Point where, WindowClass inWindowClass) -> (WindowPtr outWindow, WindowPartCode outWindowPart)")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"CreateStandardWindowMenu", (PyCFunction)Win_CreateStandardWindowMenu, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(OptionBits inOptions) -> (MenuHandle outMenu)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"CollapseAllWindows", (PyCFunction)Win_CollapseAllWindows, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Boolean collapse) -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"GetAvailableWindowPositioningBounds", (PyCFunction)Win_GetAvailableWindowPositioningBounds, 1,
|
2003-12-03 19:20:13 -04:00
|
|
|
PyDoc_STR("(GDHandle inDevice) -> (Rect outAvailableRect)")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"DisableScreenUpdates", (PyCFunction)Win_DisableScreenUpdates, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-12-18 11:39:38 -04:00
|
|
|
{"EnableScreenUpdates", (PyCFunction)Win_EnableScreenUpdates, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> None")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"PinRect", (PyCFunction)Win_PinRect, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Rect theRect, Point thePt) -> (long _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetGrayRgn", (PyCFunction)Win_GetGrayRgn, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("() -> (RgnHandle _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"GetWindowFromPort", (PyCFunction)Win_GetWindowFromPort, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(CGrafPtr port) -> (WindowPtr _rv)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"WhichWindow", (PyCFunction)Win_WhichWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("Resolve an integer WindowPtr address to a Window object")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{"FindWindow", (PyCFunction)Win_FindWindow, 1,
|
2002-08-16 06:09:31 -03:00
|
|
|
PyDoc_STR("(Point thePoint) -> (short _rv, WindowPtr theWindow)")},
|
2001-08-23 11:02:09 -03:00
|
|
|
{NULL, NULL, 0}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return the object corresponding to the window, or NULL */
|
|
|
|
|
|
|
|
PyObject *
|
|
|
|
WinObj_WhichWindow(WindowPtr w)
|
|
|
|
{
|
2005-07-03 17:59:44 -03:00
|
|
|
PyObject *it;
|
|
|
|
|
|
|
|
if (w == NULL) {
|
|
|
|
it = Py_None;
|
|
|
|
Py_INCREF(it);
|
|
|
|
} else {
|
|
|
|
it = (PyObject *) GetWRefCon(w);
|
|
|
|
if (it == NULL || !IsPointerValid((Ptr)it) || ((WindowObject *)it)->ob_itself != w || !WinObj_Check(it)) {
|
|
|
|
it = WinObj_New(w);
|
|
|
|
((WindowObject *)it)->ob_freeit = NULL;
|
|
|
|
} else {
|
|
|
|
Py_INCREF(it);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return it;
|
2001-08-23 11:02:09 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void init_Win(void)
|
|
|
|
{
|
|
|
|
PyObject *m;
|
|
|
|
PyObject *d;
|
|
|
|
|
|
|
|
|
|
|
|
|
2005-07-03 17:59:44 -03:00
|
|
|
PyMac_INIT_TOOLBOX_OBJECT_NEW(WindowPtr, WinObj_New);
|
|
|
|
PyMac_INIT_TOOLBOX_OBJECT_NEW(WindowPtr, WinObj_WhichWindow);
|
|
|
|
PyMac_INIT_TOOLBOX_OBJECT_CONVERT(WindowPtr, WinObj_Convert);
|
2001-08-23 11:02:09 -03:00
|
|
|
|
|
|
|
|
|
|
|
m = Py_InitModule("_Win", Win_methods);
|
|
|
|
d = PyModule_GetDict(m);
|
|
|
|
Win_Error = PyMac_GetOSErrException();
|
|
|
|
if (Win_Error == NULL ||
|
|
|
|
PyDict_SetItemString(d, "Error", Win_Error) != 0)
|
|
|
|
return;
|
2007-12-18 22:45:37 -04:00
|
|
|
Py_TYPE(&Window_Type) = &PyType_Type;
|
2002-12-23 19:16:25 -04:00
|
|
|
if (PyType_Ready(&Window_Type) < 0) return;
|
2001-08-23 11:02:09 -03:00
|
|
|
Py_INCREF(&Window_Type);
|
2002-12-03 19:40:22 -04:00
|
|
|
PyModule_AddObject(m, "Window", (PyObject *)&Window_Type);
|
|
|
|
/* Backward-compatible name */
|
|
|
|
Py_INCREF(&Window_Type);
|
|
|
|
PyModule_AddObject(m, "WindowType", (PyObject *)&Window_Type);
|
2001-08-23 11:02:09 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ======================== End module _Win ========================= */
|
|
|
|
|