diff -r ffa851df0825 -r 2fb8b9db1c86 symbian-qemu-0.9.1-12/python-2.6.1/Mac/Modules/win/_Winmodule.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/symbian-qemu-0.9.1-12/python-2.6.1/Mac/Modules/win/_Winmodule.c Fri Jul 31 15:01:17 2009 +0100 @@ -0,0 +1,3265 @@ + +/* ========================== Module _Win =========================== */ + +#include "Python.h" + +#ifndef __LP64__ + +#include "pymactoolbox.h" + +/* Macro to test whether a weak-loaded CFM function exists */ +#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\ + PyErr_SetString(PyExc_NotImplementedError, \ + "Not available in this shared library/OS version"); \ + return NULL; \ + }} while(0) + + +#include + +#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) +{ + DisposeWindow(w); +} + +static PyObject *Win_Error; + +/* ----------------------- Object type Window ----------------------- */ + +PyTypeObject Window_Type; + +#define WinObj_Check(x) ((x)->ob_type == &Window_Type || PyObject_TypeCheck((x), &Window_Type)) + +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); + /* XXXX Or should we use WhichWindow code here? */ + 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; +} + +int WinObj_Convert(PyObject *v, WindowPtr *p_itself) +{ + + if (v == Py_None) { *p_itself = NULL; return 1; } + if (PyInt_Check(v)) { *p_itself = (WindowPtr)PyInt_AsLong(v); return 1; } + + { + 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; + self->ob_type->tp_free((PyObject *)self); +} + +static PyObject *WinObj_GetWindowOwnerCount(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + UInt32 outCount; +#ifndef GetWindowOwnerCount + PyMac_PRECHECK(GetWindowOwnerCount); +#endif + 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; +#ifndef CloneWindow + PyMac_PRECHECK(CloneWindow); +#endif + 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; +} + +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; +} + +static PyObject *WinObj_ReshapeCustomWindow(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; +#ifndef ReshapeCustomWindow + PyMac_PRECHECK(ReshapeCustomWindow); +#endif + 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; +} + +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; +} + +static PyObject *WinObj_GetWindowClass(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + WindowClass outClass; +#ifndef GetWindowClass + PyMac_PRECHECK(GetWindowClass); +#endif + 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; +#ifndef GetWindowAttributes + PyMac_PRECHECK(GetWindowAttributes); +#endif + 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; +#ifndef ChangeWindowAttributes + PyMac_PRECHECK(ChangeWindowAttributes); +#endif + 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; +} + +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; +} + +static PyObject *WinObj_SetWindowContentColor(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + RGBColor color; +#ifndef SetWindowContentColor + PyMac_PRECHECK(SetWindowContentColor); +#endif + 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; +#ifndef GetWindowContentColor + PyMac_PRECHECK(GetWindowContentColor); +#endif + 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; +#ifndef GetWindowContentPattern + PyMac_PRECHECK(GetWindowContentPattern); +#endif + 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; +#ifndef SetWindowContentPattern + PyMac_PRECHECK(SetWindowContentPattern); +#endif + 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; +#ifndef ScrollWindowRect + PyMac_PRECHECK(ScrollWindowRect); +#endif + 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; +#ifndef ScrollWindowRegion + PyMac_PRECHECK(ScrollWindowRegion); +#endif + 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; +#ifndef ClipAbove + PyMac_PRECHECK(ClipAbove); +#endif + 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; +#ifndef PaintOne + PyMac_PRECHECK(PaintOne); +#endif + 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; +#ifndef PaintBehind + PyMac_PRECHECK(PaintBehind); +#endif + 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; +#ifndef CalcVis + PyMac_PRECHECK(CalcVis); +#endif + 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; +#ifndef CalcVisBehind + PyMac_PRECHECK(CalcVisBehind); +#endif + 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; +#ifndef BringToFront + PyMac_PRECHECK(BringToFront); +#endif + 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; +#ifndef SendBehind + PyMac_PRECHECK(SendBehind); +#endif + 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; +#ifndef SelectWindow + PyMac_PRECHECK(SelectWindow); +#endif + 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; +#ifndef GetNextWindowOfClass + PyMac_PRECHECK(GetNextWindowOfClass); +#endif + 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; +} + +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; +} + +static PyObject *WinObj_HiliteWindow(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean fHilite; +#ifndef HiliteWindow + PyMac_PRECHECK(HiliteWindow); +#endif + 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; +#ifndef SetWRefCon + PyMac_PRECHECK(SetWRefCon); +#endif + 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; +#ifndef GetWRefCon + PyMac_PRECHECK(GetWRefCon); +#endif + 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; +#ifndef SetWindowPic + PyMac_PRECHECK(SetWindowPic); +#endif + 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; +#ifndef GetWindowPic + PyMac_PRECHECK(GetWindowPic); +#endif + 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; +#ifndef GetWVariant + PyMac_PRECHECK(GetWVariant); +#endif + 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; +#ifndef GetWindowFeatures + PyMac_PRECHECK(GetWindowFeatures); +#endif + 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; +#ifndef GetWindowRegion + PyMac_PRECHECK(GetWindowRegion); +#endif + 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; +} + +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; +} + +static PyObject *WinObj_BeginUpdate(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; +#ifndef BeginUpdate + PyMac_PRECHECK(BeginUpdate); +#endif + 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; +#ifndef EndUpdate + PyMac_PRECHECK(EndUpdate); +#endif + 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; +#ifndef InvalWindowRgn + PyMac_PRECHECK(InvalWindowRgn); +#endif + 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; +#ifndef InvalWindowRect + PyMac_PRECHECK(InvalWindowRect); +#endif + 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; +#ifndef ValidWindowRgn + PyMac_PRECHECK(ValidWindowRgn); +#endif + 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; +#ifndef ValidWindowRect + PyMac_PRECHECK(ValidWindowRect); +#endif + 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; +#ifndef DrawGrowIcon + PyMac_PRECHECK(DrawGrowIcon); +#endif + 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; +#ifndef SetWTitle + PyMac_PRECHECK(SetWTitle); +#endif + 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; +#ifndef GetWTitle + PyMac_PRECHECK(GetWTitle); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + GetWTitle(_self->ob_itself, + title); + _res = Py_BuildValue("O&", + PyMac_BuildStr255, title); + return _res; +} + +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; +} + +static PyObject *WinObj_SetWindowProxyFSSpec(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + FSSpec inFile; +#ifndef SetWindowProxyFSSpec + PyMac_PRECHECK(SetWindowProxyFSSpec); +#endif + 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; +#ifndef GetWindowProxyFSSpec + PyMac_PRECHECK(GetWindowProxyFSSpec); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = GetWindowProxyFSSpec(_self->ob_itself, + &outFile); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildFSSpec, &outFile); + return _res; +} + +static PyObject *WinObj_SetWindowProxyAlias(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + AliasHandle inAlias; +#ifndef SetWindowProxyAlias + PyMac_PRECHECK(SetWindowProxyAlias); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &inAlias)) + return NULL; + _err = SetWindowProxyAlias(_self->ob_itself, + inAlias); + 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; +#ifndef GetWindowProxyAlias + PyMac_PRECHECK(GetWindowProxyAlias); +#endif + 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; +#ifndef SetWindowProxyCreatorAndType + PyMac_PRECHECK(SetWindowProxyCreatorAndType); +#endif + 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; +#ifndef GetWindowProxyIcon + PyMac_PRECHECK(GetWindowProxyIcon); +#endif + 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; +#ifndef SetWindowProxyIcon + PyMac_PRECHECK(SetWindowProxyIcon); +#endif + 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; +#ifndef RemoveWindowProxy + PyMac_PRECHECK(RemoveWindowProxy); +#endif + 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; +#ifndef BeginWindowProxyDrag + PyMac_PRECHECK(BeginWindowProxyDrag); +#endif + 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; +#ifndef EndWindowProxyDrag + PyMac_PRECHECK(EndWindowProxyDrag); +#endif + 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; +#ifndef TrackWindowProxyFromExistingDrag + PyMac_PRECHECK(TrackWindowProxyFromExistingDrag); +#endif + 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; +#ifndef TrackWindowProxyDrag + PyMac_PRECHECK(TrackWindowProxyDrag); +#endif + 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; +#ifndef IsWindowModified + PyMac_PRECHECK(IsWindowModified); +#endif + 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; +#ifndef SetWindowModified + PyMac_PRECHECK(SetWindowModified); +#endif + 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; +#ifndef IsWindowPathSelectClick + PyMac_PRECHECK(IsWindowPathSelectClick); +#endif + 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; +#ifndef WindowPathSelect + PyMac_PRECHECK(WindowPathSelect); +#endif + 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; +#ifndef HiliteWindowFrameForDrag + PyMac_PRECHECK(HiliteWindowFrameForDrag); +#endif + 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; + WindowTransitionEffect inEffect; + WindowTransitionAction inAction; + Rect inRect; +#ifndef TransitionWindow + PyMac_PRECHECK(TransitionWindow); +#endif + if (!PyArg_ParseTuple(_args, "llO&", + &inEffect, + &inAction, + PyMac_GetRect, &inRect)) + return NULL; + _err = TransitionWindow(_self->ob_itself, + inEffect, + inAction, + &inRect); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *WinObj_TransitionWindowAndParent(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + WindowPtr inParentWindow; + WindowTransitionEffect inEffect; + WindowTransitionAction inAction; + Rect inRect; +#ifndef TransitionWindowAndParent + PyMac_PRECHECK(TransitionWindowAndParent); +#endif + if (!PyArg_ParseTuple(_args, "O&llO&", + WinObj_Convert, &inParentWindow, + &inEffect, + &inAction, + PyMac_GetRect, &inRect)) + return NULL; + _err = TransitionWindowAndParent(_self->ob_itself, + inParentWindow, + inEffect, + inAction, + &inRect); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *WinObj_MacMoveWindow(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short hGlobal; + short vGlobal; + Boolean front; +#ifndef MacMoveWindow + PyMac_PRECHECK(MacMoveWindow); +#endif + 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; +#ifndef SizeWindow + PyMac_PRECHECK(SizeWindow); +#endif + 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; +#ifndef GrowWindow + PyMac_PRECHECK(GrowWindow); +#endif + 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; +#ifndef DragWindow + PyMac_PRECHECK(DragWindow); +#endif + 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; +#ifndef ZoomWindow + PyMac_PRECHECK(ZoomWindow); +#endif + 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; +#ifndef IsWindowCollapsable + PyMac_PRECHECK(IsWindowCollapsable); +#endif + 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; +#ifndef IsWindowCollapsed + PyMac_PRECHECK(IsWindowCollapsed); +#endif + 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; +#ifndef CollapseWindow + PyMac_PRECHECK(CollapseWindow); +#endif + 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; +#ifndef GetWindowBounds + PyMac_PRECHECK(GetWindowBounds); +#endif + 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; + Point inStartPoint; + Rect inSizeConstraints; + Rect outNewContentRect; +#ifndef ResizeWindow + PyMac_PRECHECK(ResizeWindow); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetPoint, &inStartPoint, + PyMac_GetRect, &inSizeConstraints)) + return NULL; + _rv = ResizeWindow(_self->ob_itself, + inStartPoint, + &inSizeConstraints, + &outNewContentRect); + _res = Py_BuildValue("bO&", + _rv, + PyMac_BuildRect, &outNewContentRect); + return _res; +} + +static PyObject *WinObj_SetWindowBounds(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + WindowRegionCode regionCode; + Rect globalBounds; +#ifndef SetWindowBounds + PyMac_PRECHECK(SetWindowBounds); +#endif + 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; +#ifndef RepositionWindow + PyMac_PRECHECK(RepositionWindow); +#endif + 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; +#ifndef MoveWindowStructure + PyMac_PRECHECK(MoveWindowStructure); +#endif + 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; + Point inIdealSize; + Rect outIdealStandardState; +#ifndef IsWindowInStandardState + PyMac_PRECHECK(IsWindowInStandardState); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetPoint, &inIdealSize)) + return NULL; + _rv = IsWindowInStandardState(_self->ob_itself, + &inIdealSize, + &outIdealStandardState); + _res = Py_BuildValue("bO&", + _rv, + PyMac_BuildRect, &outIdealStandardState); + return _res; +} + +static PyObject *WinObj_ZoomWindowIdeal(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + WindowPartCode inPartCode; + Point ioIdealSize; +#ifndef ZoomWindowIdeal + PyMac_PRECHECK(ZoomWindowIdeal); +#endif + if (!PyArg_ParseTuple(_args, "h", + &inPartCode)) + return NULL; + _err = ZoomWindowIdeal(_self->ob_itself, + inPartCode, + &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; + Rect outUserState; +#ifndef GetWindowIdealUserState + PyMac_PRECHECK(GetWindowIdealUserState); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = GetWindowIdealUserState(_self->ob_itself, + &outUserState); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildRect, &outUserState); + return _res; +} + +static PyObject *WinObj_SetWindowIdealUserState(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + Rect inUserState; +#ifndef SetWindowIdealUserState + PyMac_PRECHECK(SetWindowIdealUserState); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetRect, &inUserState)) + return NULL; + _err = SetWindowIdealUserState(_self->ob_itself, + &inUserState); + if (_err != noErr) return PyMac_Error(_err); + 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); + _res = Py_BuildValue("O&", + PyMac_BuildRect, &outStructure); + return _res; +} + +static PyObject *WinObj_HideWindow(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; +#ifndef HideWindow + PyMac_PRECHECK(HideWindow); +#endif + 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; +#ifndef MacShowWindow + PyMac_PRECHECK(MacShowWindow); +#endif + 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; +#ifndef ShowHide + PyMac_PRECHECK(ShowHide); +#endif + if (!PyArg_ParseTuple(_args, "b", + &showFlag)) + return NULL; + ShowHide(_self->ob_itself, + showFlag); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +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; +} + +static PyObject *WinObj_GetWindowPropertyAttributes(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + OSType propertyCreator; + OSType propertyTag; + UInt32 attributes; +#ifndef GetWindowPropertyAttributes + PyMac_PRECHECK(GetWindowPropertyAttributes); +#endif + 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; +#ifndef ChangeWindowPropertyAttributes + PyMac_PRECHECK(ChangeWindowPropertyAttributes); +#endif + 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; +#ifndef TrackBox + PyMac_PRECHECK(TrackBox); +#endif + 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; +#ifndef TrackGoAway + PyMac_PRECHECK(TrackGoAway); +#endif + 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; +#ifndef GetWindowPort + PyMac_PRECHECK(GetWindowPort); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetWindowPort(_self->ob_itself); + _res = Py_BuildValue("O&", + GrafObj_New, _rv); + return _res; +} + +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; +} + +static PyObject *WinObj_GetWindowKind(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; +#ifndef GetWindowKind + PyMac_PRECHECK(GetWindowKind); +#endif + 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; +#ifndef IsWindowHilited + PyMac_PRECHECK(IsWindowHilited); +#endif + 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; +#ifndef IsWindowUpdatePending + PyMac_PRECHECK(IsWindowUpdatePending); +#endif + 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; +#ifndef MacGetNextWindow + PyMac_PRECHECK(MacGetNextWindow); +#endif + 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; +#ifndef GetWindowStandardState + PyMac_PRECHECK(GetWindowStandardState); +#endif + 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; +#ifndef GetWindowUserState + PyMac_PRECHECK(GetWindowUserState); +#endif + 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; +#ifndef SetWindowKind + PyMac_PRECHECK(SetWindowKind); +#endif + 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; +#ifndef SetWindowStandardState + PyMac_PRECHECK(SetWindowStandardState); +#endif + 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; +#ifndef SetWindowUserState + PyMac_PRECHECK(SetWindowUserState); +#endif + 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; +#ifndef SetPortWindowPort + PyMac_PRECHECK(SetPortWindowPort); +#endif + 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; +#ifndef GetWindowPortBounds + PyMac_PRECHECK(GetWindowPortBounds); +#endif + 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; +#ifndef IsWindowVisible + PyMac_PRECHECK(IsWindowVisible); +#endif + 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; +#ifndef GetWindowStructureRgn + PyMac_PRECHECK(GetWindowStructureRgn); +#endif + 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; +#ifndef GetWindowContentRgn + PyMac_PRECHECK(GetWindowContentRgn); +#endif + 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; +#ifndef GetWindowUpdateRgn + PyMac_PRECHECK(GetWindowUpdateRgn); +#endif + 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; +#ifndef GetNextWindow + PyMac_PRECHECK(GetNextWindow); +#endif + 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; +#ifndef MoveWindow + PyMac_PRECHECK(MoveWindow); +#endif + 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; +#ifndef ShowWindow + PyMac_PRECHECK(ShowWindow); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + ShowWindow(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *WinObj_AutoDispose(WindowObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + + int onoff, old = 0; + if (!PyArg_ParseTuple(_args, "i", &onoff)) + return NULL; + if ( _self->ob_freeit ) + old = 1; + if ( onoff ) + _self->ob_freeit = PyMac_AutoDisposeWindow; + else + _self->ob_freeit = NULL; + _res = Py_BuildValue("i", old); + return _res; + +} + +static PyMethodDef WinObj_methods[] = { + {"GetWindowOwnerCount", (PyCFunction)WinObj_GetWindowOwnerCount, 1, + PyDoc_STR("() -> (UInt32 outCount)")}, + {"CloneWindow", (PyCFunction)WinObj_CloneWindow, 1, + PyDoc_STR("() -> None")}, + {"GetWindowRetainCount", (PyCFunction)WinObj_GetWindowRetainCount, 1, + PyDoc_STR("() -> (ItemCount _rv)")}, + {"RetainWindow", (PyCFunction)WinObj_RetainWindow, 1, + PyDoc_STR("() -> None")}, + {"ReleaseWindow", (PyCFunction)WinObj_ReleaseWindow, 1, + PyDoc_STR("() -> None")}, + {"ReshapeCustomWindow", (PyCFunction)WinObj_ReshapeCustomWindow, 1, + PyDoc_STR("() -> None")}, + {"GetWindowWidgetHilite", (PyCFunction)WinObj_GetWindowWidgetHilite, 1, + PyDoc_STR("() -> (WindowDefPartCode outHilite)")}, + {"GetWindowClass", (PyCFunction)WinObj_GetWindowClass, 1, + PyDoc_STR("() -> (WindowClass outClass)")}, + {"GetWindowAttributes", (PyCFunction)WinObj_GetWindowAttributes, 1, + PyDoc_STR("() -> (WindowAttributes outAttributes)")}, + {"ChangeWindowAttributes", (PyCFunction)WinObj_ChangeWindowAttributes, 1, + PyDoc_STR("(WindowAttributes setTheseAttributes, WindowAttributes clearTheseAttributes) -> None")}, + {"SetWindowClass", (PyCFunction)WinObj_SetWindowClass, 1, + PyDoc_STR("(WindowClass inWindowClass) -> None")}, + {"SetWindowModality", (PyCFunction)WinObj_SetWindowModality, 1, + PyDoc_STR("(WindowModality inModalKind, WindowPtr inUnavailableWindow) -> None")}, + {"GetWindowModality", (PyCFunction)WinObj_GetWindowModality, 1, + PyDoc_STR("() -> (WindowModality outModalKind, WindowPtr outUnavailableWindow)")}, + {"SetWindowContentColor", (PyCFunction)WinObj_SetWindowContentColor, 1, + PyDoc_STR("(RGBColor color) -> None")}, + {"GetWindowContentColor", (PyCFunction)WinObj_GetWindowContentColor, 1, + PyDoc_STR("() -> (RGBColor color)")}, + {"GetWindowContentPattern", (PyCFunction)WinObj_GetWindowContentPattern, 1, + PyDoc_STR("(PixPatHandle outPixPat) -> None")}, + {"SetWindowContentPattern", (PyCFunction)WinObj_SetWindowContentPattern, 1, + PyDoc_STR("(PixPatHandle pixPat) -> None")}, + {"ScrollWindowRect", (PyCFunction)WinObj_ScrollWindowRect, 1, + PyDoc_STR("(Rect inScrollRect, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None")}, + {"ScrollWindowRegion", (PyCFunction)WinObj_ScrollWindowRegion, 1, + PyDoc_STR("(RgnHandle inScrollRgn, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None")}, + {"ClipAbove", (PyCFunction)WinObj_ClipAbove, 1, + PyDoc_STR("() -> None")}, + {"PaintOne", (PyCFunction)WinObj_PaintOne, 1, + PyDoc_STR("(RgnHandle clobberedRgn) -> None")}, + {"PaintBehind", (PyCFunction)WinObj_PaintBehind, 1, + PyDoc_STR("(RgnHandle clobberedRgn) -> None")}, + {"CalcVis", (PyCFunction)WinObj_CalcVis, 1, + PyDoc_STR("() -> None")}, + {"CalcVisBehind", (PyCFunction)WinObj_CalcVisBehind, 1, + PyDoc_STR("(RgnHandle clobberedRgn) -> None")}, + {"BringToFront", (PyCFunction)WinObj_BringToFront, 1, + PyDoc_STR("() -> None")}, + {"SendBehind", (PyCFunction)WinObj_SendBehind, 1, + PyDoc_STR("(WindowPtr behindWindow) -> None")}, + {"SelectWindow", (PyCFunction)WinObj_SelectWindow, 1, + PyDoc_STR("() -> None")}, + {"GetNextWindowOfClass", (PyCFunction)WinObj_GetNextWindowOfClass, 1, + PyDoc_STR("(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)")}, + {"SetWindowAlternateTitle", (PyCFunction)WinObj_SetWindowAlternateTitle, 1, + PyDoc_STR("(CFStringRef inTitle) -> None")}, + {"CopyWindowAlternateTitle", (PyCFunction)WinObj_CopyWindowAlternateTitle, 1, + PyDoc_STR("() -> (CFStringRef outTitle)")}, + {"HiliteWindow", (PyCFunction)WinObj_HiliteWindow, 1, + PyDoc_STR("(Boolean fHilite) -> None")}, + {"SetWRefCon", (PyCFunction)WinObj_SetWRefCon, 1, + PyDoc_STR("(long data) -> None")}, + {"GetWRefCon", (PyCFunction)WinObj_GetWRefCon, 1, + PyDoc_STR("() -> (long _rv)")}, + {"SetWindowPic", (PyCFunction)WinObj_SetWindowPic, 1, + PyDoc_STR("(PicHandle pic) -> None")}, + {"GetWindowPic", (PyCFunction)WinObj_GetWindowPic, 1, + PyDoc_STR("() -> (PicHandle _rv)")}, + {"GetWVariant", (PyCFunction)WinObj_GetWVariant, 1, + PyDoc_STR("() -> (short _rv)")}, + {"GetWindowFeatures", (PyCFunction)WinObj_GetWindowFeatures, 1, + PyDoc_STR("() -> (UInt32 outFeatures)")}, + {"GetWindowRegion", (PyCFunction)WinObj_GetWindowRegion, 1, + PyDoc_STR("(WindowRegionCode inRegionCode, RgnHandle ioWinRgn) -> None")}, + {"GetWindowStructureWidths", (PyCFunction)WinObj_GetWindowStructureWidths, 1, + PyDoc_STR("() -> (Rect outRect)")}, + {"BeginUpdate", (PyCFunction)WinObj_BeginUpdate, 1, + PyDoc_STR("() -> None")}, + {"EndUpdate", (PyCFunction)WinObj_EndUpdate, 1, + PyDoc_STR("() -> None")}, + {"InvalWindowRgn", (PyCFunction)WinObj_InvalWindowRgn, 1, + PyDoc_STR("(RgnHandle region) -> None")}, + {"InvalWindowRect", (PyCFunction)WinObj_InvalWindowRect, 1, + PyDoc_STR("(Rect bounds) -> None")}, + {"ValidWindowRgn", (PyCFunction)WinObj_ValidWindowRgn, 1, + PyDoc_STR("(RgnHandle region) -> None")}, + {"ValidWindowRect", (PyCFunction)WinObj_ValidWindowRect, 1, + PyDoc_STR("(Rect bounds) -> None")}, + {"DrawGrowIcon", (PyCFunction)WinObj_DrawGrowIcon, 1, + PyDoc_STR("() -> None")}, + {"SetWTitle", (PyCFunction)WinObj_SetWTitle, 1, + PyDoc_STR("(Str255 title) -> None")}, + {"GetWTitle", (PyCFunction)WinObj_GetWTitle, 1, + PyDoc_STR("() -> (Str255 title)")}, + {"SetWindowTitleWithCFString", (PyCFunction)WinObj_SetWindowTitleWithCFString, 1, + PyDoc_STR("(CFStringRef inString) -> None")}, + {"CopyWindowTitleAsCFString", (PyCFunction)WinObj_CopyWindowTitleAsCFString, 1, + PyDoc_STR("() -> (CFStringRef outString)")}, + {"SetWindowProxyFSSpec", (PyCFunction)WinObj_SetWindowProxyFSSpec, 1, + PyDoc_STR("(FSSpec inFile) -> None")}, + {"GetWindowProxyFSSpec", (PyCFunction)WinObj_GetWindowProxyFSSpec, 1, + PyDoc_STR("() -> (FSSpec outFile)")}, + {"SetWindowProxyAlias", (PyCFunction)WinObj_SetWindowProxyAlias, 1, + PyDoc_STR("(AliasHandle inAlias) -> None")}, + {"GetWindowProxyAlias", (PyCFunction)WinObj_GetWindowProxyAlias, 1, + PyDoc_STR("() -> (AliasHandle alias)")}, + {"SetWindowProxyCreatorAndType", (PyCFunction)WinObj_SetWindowProxyCreatorAndType, 1, + PyDoc_STR("(OSType fileCreator, OSType fileType, SInt16 vRefNum) -> None")}, + {"GetWindowProxyIcon", (PyCFunction)WinObj_GetWindowProxyIcon, 1, + PyDoc_STR("() -> (IconRef outIcon)")}, + {"SetWindowProxyIcon", (PyCFunction)WinObj_SetWindowProxyIcon, 1, + PyDoc_STR("(IconRef icon) -> None")}, + {"RemoveWindowProxy", (PyCFunction)WinObj_RemoveWindowProxy, 1, + PyDoc_STR("() -> None")}, + {"BeginWindowProxyDrag", (PyCFunction)WinObj_BeginWindowProxyDrag, 1, + PyDoc_STR("(RgnHandle outDragOutlineRgn) -> (DragReference outNewDrag)")}, + {"EndWindowProxyDrag", (PyCFunction)WinObj_EndWindowProxyDrag, 1, + PyDoc_STR("(DragReference theDrag) -> None")}, + {"TrackWindowProxyFromExistingDrag", (PyCFunction)WinObj_TrackWindowProxyFromExistingDrag, 1, + PyDoc_STR("(Point startPt, DragReference drag, RgnHandle inDragOutlineRgn) -> None")}, + {"TrackWindowProxyDrag", (PyCFunction)WinObj_TrackWindowProxyDrag, 1, + PyDoc_STR("(Point startPt) -> None")}, + {"IsWindowModified", (PyCFunction)WinObj_IsWindowModified, 1, + PyDoc_STR("() -> (Boolean _rv)")}, + {"SetWindowModified", (PyCFunction)WinObj_SetWindowModified, 1, + PyDoc_STR("(Boolean modified) -> None")}, + {"IsWindowPathSelectClick", (PyCFunction)WinObj_IsWindowPathSelectClick, 1, + PyDoc_STR("(EventRecord event) -> (Boolean _rv)")}, + {"WindowPathSelect", (PyCFunction)WinObj_WindowPathSelect, 1, + PyDoc_STR("(MenuHandle menu) -> (SInt32 outMenuResult)")}, + {"HiliteWindowFrameForDrag", (PyCFunction)WinObj_HiliteWindowFrameForDrag, 1, + PyDoc_STR("(Boolean hilited) -> None")}, + {"TransitionWindow", (PyCFunction)WinObj_TransitionWindow, 1, + PyDoc_STR("(WindowTransitionEffect inEffect, WindowTransitionAction inAction, Rect inRect) -> None")}, + {"TransitionWindowAndParent", (PyCFunction)WinObj_TransitionWindowAndParent, 1, + PyDoc_STR("(WindowPtr inParentWindow, WindowTransitionEffect inEffect, WindowTransitionAction inAction, Rect inRect) -> None")}, + {"MacMoveWindow", (PyCFunction)WinObj_MacMoveWindow, 1, + PyDoc_STR("(short hGlobal, short vGlobal, Boolean front) -> None")}, + {"SizeWindow", (PyCFunction)WinObj_SizeWindow, 1, + PyDoc_STR("(short w, short h, Boolean fUpdate) -> None")}, + {"GrowWindow", (PyCFunction)WinObj_GrowWindow, 1, + PyDoc_STR("(Point startPt, Rect bBox) -> (long _rv)")}, + {"DragWindow", (PyCFunction)WinObj_DragWindow, 1, + PyDoc_STR("(Point startPt, Rect boundsRect) -> None")}, + {"ZoomWindow", (PyCFunction)WinObj_ZoomWindow, 1, + PyDoc_STR("(WindowPartCode partCode, Boolean front) -> None")}, + {"IsWindowCollapsable", (PyCFunction)WinObj_IsWindowCollapsable, 1, + PyDoc_STR("() -> (Boolean _rv)")}, + {"IsWindowCollapsed", (PyCFunction)WinObj_IsWindowCollapsed, 1, + PyDoc_STR("() -> (Boolean _rv)")}, + {"CollapseWindow", (PyCFunction)WinObj_CollapseWindow, 1, + PyDoc_STR("(Boolean collapse) -> None")}, + {"GetWindowBounds", (PyCFunction)WinObj_GetWindowBounds, 1, + PyDoc_STR("(WindowRegionCode regionCode) -> (Rect globalBounds)")}, + {"ResizeWindow", (PyCFunction)WinObj_ResizeWindow, 1, + PyDoc_STR("(Point inStartPoint, Rect inSizeConstraints) -> (Boolean _rv, Rect outNewContentRect)")}, + {"SetWindowBounds", (PyCFunction)WinObj_SetWindowBounds, 1, + PyDoc_STR("(WindowRegionCode regionCode, Rect globalBounds) -> None")}, + {"RepositionWindow", (PyCFunction)WinObj_RepositionWindow, 1, + PyDoc_STR("(WindowPtr parentWindow, WindowPositionMethod method) -> None")}, + {"MoveWindowStructure", (PyCFunction)WinObj_MoveWindowStructure, 1, + PyDoc_STR("(short hGlobal, short vGlobal) -> None")}, + {"IsWindowInStandardState", (PyCFunction)WinObj_IsWindowInStandardState, 1, + PyDoc_STR("(Point inIdealSize) -> (Boolean _rv, Rect outIdealStandardState)")}, + {"ZoomWindowIdeal", (PyCFunction)WinObj_ZoomWindowIdeal, 1, + PyDoc_STR("(WindowPartCode inPartCode) -> (Point ioIdealSize)")}, + {"GetWindowIdealUserState", (PyCFunction)WinObj_GetWindowIdealUserState, 1, + PyDoc_STR("() -> (Rect outUserState)")}, + {"SetWindowIdealUserState", (PyCFunction)WinObj_SetWindowIdealUserState, 1, + PyDoc_STR("(Rect inUserState) -> None")}, + {"GetWindowGreatestAreaDevice", (PyCFunction)WinObj_GetWindowGreatestAreaDevice, 1, + PyDoc_STR("(WindowRegionCode inRegion) -> (GDHandle outGreatestDevice, Rect outGreatestDeviceRect)")}, + {"ConstrainWindowToScreen", (PyCFunction)WinObj_ConstrainWindowToScreen, 1, + PyDoc_STR("(WindowRegionCode inRegionCode, WindowConstrainOptions inOptions, Rect inScreenRect) -> (Rect outStructure)")}, + {"HideWindow", (PyCFunction)WinObj_HideWindow, 1, + PyDoc_STR("() -> None")}, + {"MacShowWindow", (PyCFunction)WinObj_MacShowWindow, 1, + PyDoc_STR("() -> None")}, + {"ShowHide", (PyCFunction)WinObj_ShowHide, 1, + PyDoc_STR("(Boolean showFlag) -> None")}, + {"MacIsWindowVisible", (PyCFunction)WinObj_MacIsWindowVisible, 1, + PyDoc_STR("() -> (Boolean _rv)")}, + {"ShowSheetWindow", (PyCFunction)WinObj_ShowSheetWindow, 1, + PyDoc_STR("(WindowPtr inParentWindow) -> None")}, + {"HideSheetWindow", (PyCFunction)WinObj_HideSheetWindow, 1, + PyDoc_STR("() -> None")}, + {"GetSheetWindowParent", (PyCFunction)WinObj_GetSheetWindowParent, 1, + PyDoc_STR("() -> (WindowPtr outParentWindow)")}, + {"GetWindowPropertyAttributes", (PyCFunction)WinObj_GetWindowPropertyAttributes, 1, + PyDoc_STR("(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)")}, + {"ChangeWindowPropertyAttributes", (PyCFunction)WinObj_ChangeWindowPropertyAttributes, 1, + PyDoc_STR("(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None")}, + {"TrackBox", (PyCFunction)WinObj_TrackBox, 1, + PyDoc_STR("(Point thePt, WindowPartCode partCode) -> (Boolean _rv)")}, + {"TrackGoAway", (PyCFunction)WinObj_TrackGoAway, 1, + PyDoc_STR("(Point thePt) -> (Boolean _rv)")}, + {"GetWindowPort", (PyCFunction)WinObj_GetWindowPort, 1, + PyDoc_STR("() -> (CGrafPtr _rv)")}, + {"GetWindowStructurePort", (PyCFunction)WinObj_GetWindowStructurePort, 1, + PyDoc_STR("() -> (CGrafPtr _rv)")}, + {"GetWindowKind", (PyCFunction)WinObj_GetWindowKind, 1, + PyDoc_STR("() -> (short _rv)")}, + {"IsWindowHilited", (PyCFunction)WinObj_IsWindowHilited, 1, + PyDoc_STR("() -> (Boolean _rv)")}, + {"IsWindowUpdatePending", (PyCFunction)WinObj_IsWindowUpdatePending, 1, + PyDoc_STR("() -> (Boolean _rv)")}, + {"MacGetNextWindow", (PyCFunction)WinObj_MacGetNextWindow, 1, + PyDoc_STR("() -> (WindowPtr _rv)")}, + {"GetWindowStandardState", (PyCFunction)WinObj_GetWindowStandardState, 1, + PyDoc_STR("() -> (Rect rect)")}, + {"GetWindowUserState", (PyCFunction)WinObj_GetWindowUserState, 1, + PyDoc_STR("() -> (Rect rect)")}, + {"SetWindowKind", (PyCFunction)WinObj_SetWindowKind, 1, + PyDoc_STR("(short kind) -> None")}, + {"SetWindowStandardState", (PyCFunction)WinObj_SetWindowStandardState, 1, + PyDoc_STR("(Rect rect) -> None")}, + {"SetWindowUserState", (PyCFunction)WinObj_SetWindowUserState, 1, + PyDoc_STR("(Rect rect) -> None")}, + {"SetPortWindowPort", (PyCFunction)WinObj_SetPortWindowPort, 1, + PyDoc_STR("() -> None")}, + {"GetWindowPortBounds", (PyCFunction)WinObj_GetWindowPortBounds, 1, + PyDoc_STR("() -> (Rect bounds)")}, + {"IsWindowVisible", (PyCFunction)WinObj_IsWindowVisible, 1, + PyDoc_STR("() -> (Boolean _rv)")}, + {"GetWindowStructureRgn", (PyCFunction)WinObj_GetWindowStructureRgn, 1, + PyDoc_STR("(RgnHandle r) -> None")}, + {"GetWindowContentRgn", (PyCFunction)WinObj_GetWindowContentRgn, 1, + PyDoc_STR("(RgnHandle r) -> None")}, + {"GetWindowUpdateRgn", (PyCFunction)WinObj_GetWindowUpdateRgn, 1, + PyDoc_STR("(RgnHandle r) -> None")}, + {"GetNextWindow", (PyCFunction)WinObj_GetNextWindow, 1, + PyDoc_STR("() -> (WindowPtr _rv)")}, + {"MoveWindow", (PyCFunction)WinObj_MoveWindow, 1, + PyDoc_STR("(short hGlobal, short vGlobal, Boolean front) -> None")}, + {"ShowWindow", (PyCFunction)WinObj_ShowWindow, 1, + PyDoc_STR("() -> None")}, + {"AutoDispose", (PyCFunction)WinObj_AutoDispose, 1, + PyDoc_STR("(int)->int. Automatically DisposeHandle the object on Python object cleanup")}, + {NULL, NULL, 0} +}; + +#define WinObj_getsetlist NULL + + +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]; + sprintf(buf, "", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); +} + +static int WinObj_hash(WindowObject *self) +{ + return (int)self->ob_itself; +} +#define WinObj_tp_init 0 + +#define WinObj_tp_alloc PyType_GenericAlloc + +static PyObject *WinObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) +{ + PyObject *_self; + WindowPtr itself; + char *kw[] = {"itself", 0}; + + 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; +} + +#define WinObj_tp_free PyObject_Del + + +PyTypeObject Window_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_Win.Window", /*tp_name*/ + sizeof(WindowObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) WinObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ + (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*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr, /*tp_getattro*/ + PyObject_GenericSetAttr, /*tp_setattro */ + 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*/ + WinObj_methods, /* tp_methods */ + 0, /*tp_members*/ + WinObj_getsetlist, /*tp_getset*/ + 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 */ +}; + +/* --------------------- End object type Window --------------------- */ + + +static PyObject *Win_GetNewCWindow(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + WindowPtr _rv; + short windowID; + WindowPtr behind; +#ifndef GetNewCWindow + PyMac_PRECHECK(GetNewCWindow); +#endif + 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; +#ifndef NewWindow + PyMac_PRECHECK(NewWindow); +#endif + 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; +#ifndef GetNewWindow + PyMac_PRECHECK(GetNewWindow); +#endif + 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; +#ifndef NewCWindow + PyMac_PRECHECK(NewCWindow); +#endif + 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; +#ifndef CreateNewWindow + PyMac_PRECHECK(CreateNewWindow); +#endif + 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&", + WinObj_New, outWindow); + return _res; +} + +static PyObject *Win_CreateWindowFromResource(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + SInt16 resID; + WindowPtr outWindow; +#ifndef CreateWindowFromResource + PyMac_PRECHECK(CreateWindowFromResource); +#endif + if (!PyArg_ParseTuple(_args, "h", + &resID)) + return NULL; + _err = CreateWindowFromResource(resID, + &outWindow); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + WinObj_New, outWindow); + return _res; +} + +static PyObject *Win_ShowFloatingWindows(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; +#ifndef ShowFloatingWindows + PyMac_PRECHECK(ShowFloatingWindows); +#endif + 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; +#ifndef HideFloatingWindows + PyMac_PRECHECK(HideFloatingWindows); +#endif + 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; +#ifndef AreFloatingWindowsVisible + PyMac_PRECHECK(AreFloatingWindowsVisible); +#endif + 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; +#ifndef CheckUpdate + PyMac_PRECHECK(CheckUpdate); +#endif + 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; +#ifndef MacFindWindow + PyMac_PRECHECK(MacFindWindow); +#endif + 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; +#ifndef FrontWindow + PyMac_PRECHECK(FrontWindow); +#endif + 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; +#ifndef FrontNonFloatingWindow + PyMac_PRECHECK(FrontNonFloatingWindow); +#endif + 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; +#ifndef GetFrontWindowOfClass + PyMac_PRECHECK(GetFrontWindowOfClass); +#endif + 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; +#ifndef FindWindowOfClass + PyMac_PRECHECK(FindWindowOfClass); +#endif + 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; +} + +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; +} + +static PyObject *Win_CollapseAllWindows(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + Boolean collapse; +#ifndef CollapseAllWindows + PyMac_PRECHECK(CollapseAllWindows); +#endif + 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; +} + +static PyObject *Win_GetAvailableWindowPositioningBounds(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + GDHandle inDevice; + Rect outAvailableRect; +#ifndef GetAvailableWindowPositioningBounds + PyMac_PRECHECK(GetAvailableWindowPositioningBounds); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &inDevice)) + return NULL; + _err = GetAvailableWindowPositioningBounds(inDevice, + &outAvailableRect); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildRect, &outAvailableRect); + 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; +} + +static PyObject *Win_PinRect(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + long _rv; + Rect theRect; + Point thePt; +#ifndef PinRect + PyMac_PRECHECK(PinRect); +#endif + 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; +#ifndef GetGrayRgn + PyMac_PRECHECK(GetGrayRgn); +#endif + 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; +#ifndef GetWindowFromPort + PyMac_PRECHECK(GetWindowFromPort); +#endif + 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) ) + return NULL; + _res = WinObj_WhichWindow((WindowPtr)ptr); + return _res; + +} + +static PyObject *Win_FindWindow(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; + Point thePoint; + WindowPtr theWindow; +#ifndef FindWindow + PyMac_PRECHECK(FindWindow); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetPoint, &thePoint)) + return NULL; + _rv = FindWindow(thePoint, + &theWindow); + _res = Py_BuildValue("hO&", + _rv, + WinObj_WhichWindow, theWindow); + return _res; +} +#endif /* __LP64__ */ + +static PyMethodDef Win_methods[] = { +#ifndef __LP64__ + {"GetNewCWindow", (PyCFunction)Win_GetNewCWindow, 1, + PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")}, + {"NewWindow", (PyCFunction)Win_NewWindow, 1, + PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")}, + {"GetNewWindow", (PyCFunction)Win_GetNewWindow, 1, + PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")}, + {"NewCWindow", (PyCFunction)Win_NewCWindow, 1, + PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")}, + {"CreateNewWindow", (PyCFunction)Win_CreateNewWindow, 1, + PyDoc_STR("(WindowClass windowClass, WindowAttributes attributes, Rect contentBounds) -> (WindowPtr outWindow)")}, + {"CreateWindowFromResource", (PyCFunction)Win_CreateWindowFromResource, 1, + PyDoc_STR("(SInt16 resID) -> (WindowPtr outWindow)")}, + {"ShowFloatingWindows", (PyCFunction)Win_ShowFloatingWindows, 1, + PyDoc_STR("() -> None")}, + {"HideFloatingWindows", (PyCFunction)Win_HideFloatingWindows, 1, + PyDoc_STR("() -> None")}, + {"AreFloatingWindowsVisible", (PyCFunction)Win_AreFloatingWindowsVisible, 1, + PyDoc_STR("() -> (Boolean _rv)")}, + {"CheckUpdate", (PyCFunction)Win_CheckUpdate, 1, + PyDoc_STR("() -> (Boolean _rv, EventRecord theEvent)")}, + {"MacFindWindow", (PyCFunction)Win_MacFindWindow, 1, + PyDoc_STR("(Point thePoint) -> (WindowPartCode _rv, WindowPtr window)")}, + {"FrontWindow", (PyCFunction)Win_FrontWindow, 1, + PyDoc_STR("() -> (WindowPtr _rv)")}, + {"FrontNonFloatingWindow", (PyCFunction)Win_FrontNonFloatingWindow, 1, + PyDoc_STR("() -> (WindowPtr _rv)")}, + {"GetFrontWindowOfClass", (PyCFunction)Win_GetFrontWindowOfClass, 1, + PyDoc_STR("(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)")}, + {"FindWindowOfClass", (PyCFunction)Win_FindWindowOfClass, 1, + PyDoc_STR("(Point where, WindowClass inWindowClass) -> (WindowPtr outWindow, WindowPartCode outWindowPart)")}, + {"CreateStandardWindowMenu", (PyCFunction)Win_CreateStandardWindowMenu, 1, + PyDoc_STR("(OptionBits inOptions) -> (MenuHandle outMenu)")}, + {"CollapseAllWindows", (PyCFunction)Win_CollapseAllWindows, 1, + PyDoc_STR("(Boolean collapse) -> None")}, + {"GetAvailableWindowPositioningBounds", (PyCFunction)Win_GetAvailableWindowPositioningBounds, 1, + PyDoc_STR("(GDHandle inDevice) -> (Rect outAvailableRect)")}, + {"DisableScreenUpdates", (PyCFunction)Win_DisableScreenUpdates, 1, + PyDoc_STR("() -> None")}, + {"EnableScreenUpdates", (PyCFunction)Win_EnableScreenUpdates, 1, + PyDoc_STR("() -> None")}, + {"PinRect", (PyCFunction)Win_PinRect, 1, + PyDoc_STR("(Rect theRect, Point thePt) -> (long _rv)")}, + {"GetGrayRgn", (PyCFunction)Win_GetGrayRgn, 1, + PyDoc_STR("() -> (RgnHandle _rv)")}, + {"GetWindowFromPort", (PyCFunction)Win_GetWindowFromPort, 1, + PyDoc_STR("(CGrafPtr port) -> (WindowPtr _rv)")}, + {"WhichWindow", (PyCFunction)Win_WhichWindow, 1, + PyDoc_STR("Resolve an integer WindowPtr address to a Window object")}, + {"FindWindow", (PyCFunction)Win_FindWindow, 1, + PyDoc_STR("(Point thePoint) -> (short _rv, WindowPtr theWindow)")}, + {NULL, NULL, 0} +#endif /* __LP64__ */ +}; + + + +#ifndef __LP64__ +/* Return the object corresponding to the window, or NULL */ + +PyObject * +WinObj_WhichWindow(WindowPtr w) +{ + 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; +} + +#endif /* __LP64__ */ + +void init_Win(void) +{ + PyObject *m; +#ifndef __LP64__ + PyObject *d; + + PyMac_INIT_TOOLBOX_OBJECT_NEW(WindowPtr, WinObj_New); + PyMac_INIT_TOOLBOX_OBJECT_NEW(WindowPtr, WinObj_WhichWindow); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(WindowPtr, WinObj_Convert); + +#endif /* __LP64__ */ + + m = Py_InitModule("_Win", Win_methods); +#ifndef __LP64__ + d = PyModule_GetDict(m); + Win_Error = PyMac_GetOSErrException(); + if (Win_Error == NULL || + PyDict_SetItemString(d, "Error", Win_Error) != 0) + return; + Window_Type.ob_type = &PyType_Type; + if (PyType_Ready(&Window_Type) < 0) return; + Py_INCREF(&Window_Type); + PyModule_AddObject(m, "Window", (PyObject *)&Window_Type); + /* Backward-compatible name */ + Py_INCREF(&Window_Type); + PyModule_AddObject(m, "WindowType", (PyObject *)&Window_Type); +#endif /* __LP64__ */ +} + +/* ======================== End module _Win ========================= */ +