
/* ========================== 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 <Carbon/Carbon.h>

#ifdef USE_TOOLBOX_OBJECT_GLUE
extern PyObject *_WinObj_New(WindowRef);
extern PyObject *_WinObj_WhichWindow(WindowRef);
extern int _WinObj_Convert(PyObject *, WindowRef *);

#define WinObj_New _WinObj_New
#define WinObj_WhichWindow _WinObj_WhichWindow
#define WinObj_Convert _WinObj_Convert
#endif

/* Classic calls that we emulate in carbon mode */
#define GetWindowUpdateRgn(win, rgn) GetWindowRegion((win), kWindowUpdateRgn, (rgn))
#define GetWindowStructureRgn(win, rgn) GetWindowRegion((win), kWindowStructureRgn, (rgn))
#define GetWindowContentRgn(win, rgn) GetWindowRegion((win), kWindowContentRgn, (rgn))

/* Function to dispose a window, with a "normal" calling sequence */
static void
PyMac_AutoDisposeWindow(WindowPtr w)
{
    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, &region))
        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, &region))
        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",
                          &regionCode))
        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&",
                          &regionCode,
                          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, "<Window object at 0x%8.8x for 0x%8.8x>", (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 ========================= */

