/* ========================== 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 ) {\ 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; } static PyMethodDef Win_methods[] = { {"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} }; /* 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; } void init_Win(void) { PyObject *m; 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); 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; 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); } /* ======================== End module _Win ========================= */