1
2/* ========================== Module _Win =========================== */
3
4#include "Python.h"
5#include "pymactoolbox.h"
6
7#if APPLE_SUPPORTS_QUICKTIME
8
9
10/* Macro to test whether a weak-loaded CFM function exists */
11#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
12        PyErr_SetString(PyExc_NotImplementedError, \
13            "Not available in this shared library/OS version"); \
14        return NULL; \
15    }} while(0)
16
17
18#include <Carbon/Carbon.h>
19
20#ifdef USE_TOOLBOX_OBJECT_GLUE
21extern PyObject *_WinObj_New(WindowRef);
22extern PyObject *_WinObj_WhichWindow(WindowRef);
23extern int _WinObj_Convert(PyObject *, WindowRef *);
24
25#define WinObj_New _WinObj_New
26#define WinObj_WhichWindow _WinObj_WhichWindow
27#define WinObj_Convert _WinObj_Convert
28#endif
29
30/* Classic calls that we emulate in carbon mode */
31#define GetWindowUpdateRgn(win, rgn) GetWindowRegion((win), kWindowUpdateRgn, (rgn))
32#define GetWindowStructureRgn(win, rgn) GetWindowRegion((win), kWindowStructureRgn, (rgn))
33#define GetWindowContentRgn(win, rgn) GetWindowRegion((win), kWindowContentRgn, (rgn))
34
35/* Function to dispose a window, with a "normal" calling sequence */
36static void
37PyMac_AutoDisposeWindow(WindowPtr w)
38{
39    DisposeWindow(w);
40}
41
42static PyObject *Win_Error;
43
44/* ----------------------- Object type Window ----------------------- */
45
46PyTypeObject Window_Type;
47
48#define WinObj_Check(x) ((x)->ob_type == &Window_Type || PyObject_TypeCheck((x), &Window_Type))
49
50typedef struct WindowObject {
51    PyObject_HEAD
52    WindowPtr ob_itself;
53    void (*ob_freeit)(WindowPtr ptr);
54} WindowObject;
55
56PyObject *WinObj_New(WindowPtr itself)
57{
58    WindowObject *it;
59    if (itself == NULL) return PyMac_Error(resNotFound);
60    /* XXXX Or should we use WhichWindow code here? */
61    it = PyObject_NEW(WindowObject, &Window_Type);
62    if (it == NULL) return NULL;
63    it->ob_itself = itself;
64    it->ob_freeit = NULL;
65    if (GetWRefCon(itself) == 0)
66    {
67        SetWRefCon(itself, (long)it);
68        it->ob_freeit = PyMac_AutoDisposeWindow;
69    }
70    return (PyObject *)it;
71}
72
73int WinObj_Convert(PyObject *v, WindowPtr *p_itself)
74{
75
76    if (v == Py_None) { *p_itself = NULL; return 1; }
77    if (PyInt_Check(v)) { *p_itself = (WindowPtr)PyInt_AsLong(v); return 1; }
78
79    {
80        DialogRef dlg;
81        if (DlgObj_Convert(v, &dlg) && dlg) {
82            *p_itself = GetDialogWindow(dlg);
83            return 1;
84        }
85        PyErr_Clear();
86    }
87    if (!WinObj_Check(v))
88    {
89        PyErr_SetString(PyExc_TypeError, "Window required");
90        return 0;
91    }
92    *p_itself = ((WindowObject *)v)->ob_itself;
93    return 1;
94}
95
96static void WinObj_dealloc(WindowObject *self)
97{
98    if (self->ob_freeit && self->ob_itself)
99    {
100        SetWRefCon(self->ob_itself, 0);
101        self->ob_freeit(self->ob_itself);
102    }
103    self->ob_itself = NULL;
104    self->ob_freeit = NULL;
105    self->ob_type->tp_free((PyObject *)self);
106}
107
108static PyObject *WinObj_GetWindowOwnerCount(WindowObject *_self, PyObject *_args)
109{
110    PyObject *_res = NULL;
111    OSStatus _err;
112    UInt32 outCount;
113#ifndef GetWindowOwnerCount
114    PyMac_PRECHECK(GetWindowOwnerCount);
115#endif
116    if (!PyArg_ParseTuple(_args, ""))
117        return NULL;
118    _err = GetWindowOwnerCount(_self->ob_itself,
119                               &outCount);
120    if (_err != noErr) return PyMac_Error(_err);
121    _res = Py_BuildValue("l",
122                         outCount);
123    return _res;
124}
125
126static PyObject *WinObj_CloneWindow(WindowObject *_self, PyObject *_args)
127{
128    PyObject *_res = NULL;
129    OSStatus _err;
130#ifndef CloneWindow
131    PyMac_PRECHECK(CloneWindow);
132#endif
133    if (!PyArg_ParseTuple(_args, ""))
134        return NULL;
135    _err = CloneWindow(_self->ob_itself);
136    if (_err != noErr) return PyMac_Error(_err);
137    Py_INCREF(Py_None);
138    _res = Py_None;
139    return _res;
140}
141
142static PyObject *WinObj_GetWindowRetainCount(WindowObject *_self, PyObject *_args)
143{
144    PyObject *_res = NULL;
145    ItemCount _rv;
146#ifndef GetWindowRetainCount
147    PyMac_PRECHECK(GetWindowRetainCount);
148#endif
149    if (!PyArg_ParseTuple(_args, ""))
150        return NULL;
151    _rv = GetWindowRetainCount(_self->ob_itself);
152    _res = Py_BuildValue("l",
153                         _rv);
154    return _res;
155}
156
157static PyObject *WinObj_RetainWindow(WindowObject *_self, PyObject *_args)
158{
159    PyObject *_res = NULL;
160    OSStatus _err;
161#ifndef RetainWindow
162    PyMac_PRECHECK(RetainWindow);
163#endif
164    if (!PyArg_ParseTuple(_args, ""))
165        return NULL;
166    _err = RetainWindow(_self->ob_itself);
167    if (_err != noErr) return PyMac_Error(_err);
168    Py_INCREF(Py_None);
169    _res = Py_None;
170    return _res;
171}
172
173static PyObject *WinObj_ReleaseWindow(WindowObject *_self, PyObject *_args)
174{
175    PyObject *_res = NULL;
176    OSStatus _err;
177#ifndef ReleaseWindow
178    PyMac_PRECHECK(ReleaseWindow);
179#endif
180    if (!PyArg_ParseTuple(_args, ""))
181        return NULL;
182    _err = ReleaseWindow(_self->ob_itself);
183    if (_err != noErr) return PyMac_Error(_err);
184    Py_INCREF(Py_None);
185    _res = Py_None;
186    return _res;
187}
188
189static PyObject *WinObj_ReshapeCustomWindow(WindowObject *_self, PyObject *_args)
190{
191    PyObject *_res = NULL;
192    OSStatus _err;
193#ifndef ReshapeCustomWindow
194    PyMac_PRECHECK(ReshapeCustomWindow);
195#endif
196    if (!PyArg_ParseTuple(_args, ""))
197        return NULL;
198    _err = ReshapeCustomWindow(_self->ob_itself);
199    if (_err != noErr) return PyMac_Error(_err);
200    Py_INCREF(Py_None);
201    _res = Py_None;
202    return _res;
203}
204
205static PyObject *WinObj_GetWindowWidgetHilite(WindowObject *_self, PyObject *_args)
206{
207    PyObject *_res = NULL;
208    OSStatus _err;
209    WindowDefPartCode outHilite;
210#ifndef GetWindowWidgetHilite
211    PyMac_PRECHECK(GetWindowWidgetHilite);
212#endif
213    if (!PyArg_ParseTuple(_args, ""))
214        return NULL;
215    _err = GetWindowWidgetHilite(_self->ob_itself,
216                                 &outHilite);
217    if (_err != noErr) return PyMac_Error(_err);
218    _res = Py_BuildValue("h",
219                         outHilite);
220    return _res;
221}
222
223static PyObject *WinObj_GetWindowClass(WindowObject *_self, PyObject *_args)
224{
225    PyObject *_res = NULL;
226    OSStatus _err;
227    WindowClass outClass;
228#ifndef GetWindowClass
229    PyMac_PRECHECK(GetWindowClass);
230#endif
231    if (!PyArg_ParseTuple(_args, ""))
232        return NULL;
233    _err = GetWindowClass(_self->ob_itself,
234                          &outClass);
235    if (_err != noErr) return PyMac_Error(_err);
236    _res = Py_BuildValue("l",
237                         outClass);
238    return _res;
239}
240
241static PyObject *WinObj_GetWindowAttributes(WindowObject *_self, PyObject *_args)
242{
243    PyObject *_res = NULL;
244    OSStatus _err;
245    WindowAttributes outAttributes;
246#ifndef GetWindowAttributes
247    PyMac_PRECHECK(GetWindowAttributes);
248#endif
249    if (!PyArg_ParseTuple(_args, ""))
250        return NULL;
251    _err = GetWindowAttributes(_self->ob_itself,
252                               &outAttributes);
253    if (_err != noErr) return PyMac_Error(_err);
254    _res = Py_BuildValue("l",
255                         outAttributes);
256    return _res;
257}
258
259static PyObject *WinObj_ChangeWindowAttributes(WindowObject *_self, PyObject *_args)
260{
261    PyObject *_res = NULL;
262    OSStatus _err;
263    WindowAttributes setTheseAttributes;
264    WindowAttributes clearTheseAttributes;
265#ifndef ChangeWindowAttributes
266    PyMac_PRECHECK(ChangeWindowAttributes);
267#endif
268    if (!PyArg_ParseTuple(_args, "ll",
269                          &setTheseAttributes,
270                          &clearTheseAttributes))
271        return NULL;
272    _err = ChangeWindowAttributes(_self->ob_itself,
273                                  setTheseAttributes,
274                                  clearTheseAttributes);
275    if (_err != noErr) return PyMac_Error(_err);
276    Py_INCREF(Py_None);
277    _res = Py_None;
278    return _res;
279}
280
281static PyObject *WinObj_SetWindowClass(WindowObject *_self, PyObject *_args)
282{
283    PyObject *_res = NULL;
284    OSStatus _err;
285    WindowClass inWindowClass;
286#ifndef SetWindowClass
287    PyMac_PRECHECK(SetWindowClass);
288#endif
289    if (!PyArg_ParseTuple(_args, "l",
290                          &inWindowClass))
291        return NULL;
292    _err = SetWindowClass(_self->ob_itself,
293                          inWindowClass);
294    if (_err != noErr) return PyMac_Error(_err);
295    Py_INCREF(Py_None);
296    _res = Py_None;
297    return _res;
298}
299
300static PyObject *WinObj_SetWindowModality(WindowObject *_self, PyObject *_args)
301{
302    PyObject *_res = NULL;
303    OSStatus _err;
304    WindowModality inModalKind;
305    WindowPtr inUnavailableWindow;
306#ifndef SetWindowModality
307    PyMac_PRECHECK(SetWindowModality);
308#endif
309    if (!PyArg_ParseTuple(_args, "lO&",
310                          &inModalKind,
311                          WinObj_Convert, &inUnavailableWindow))
312        return NULL;
313    _err = SetWindowModality(_self->ob_itself,
314                             inModalKind,
315                             inUnavailableWindow);
316    if (_err != noErr) return PyMac_Error(_err);
317    Py_INCREF(Py_None);
318    _res = Py_None;
319    return _res;
320}
321
322static PyObject *WinObj_GetWindowModality(WindowObject *_self, PyObject *_args)
323{
324    PyObject *_res = NULL;
325    OSStatus _err;
326    WindowModality outModalKind;
327    WindowPtr outUnavailableWindow;
328#ifndef GetWindowModality
329    PyMac_PRECHECK(GetWindowModality);
330#endif
331    if (!PyArg_ParseTuple(_args, ""))
332        return NULL;
333    _err = GetWindowModality(_self->ob_itself,
334                             &outModalKind,
335                             &outUnavailableWindow);
336    if (_err != noErr) return PyMac_Error(_err);
337    _res = Py_BuildValue("lO&",
338                         outModalKind,
339                         WinObj_WhichWindow, outUnavailableWindow);
340    return _res;
341}
342
343static PyObject *WinObj_SetWindowContentColor(WindowObject *_self, PyObject *_args)
344{
345    PyObject *_res = NULL;
346    OSStatus _err;
347    RGBColor color;
348#ifndef SetWindowContentColor
349    PyMac_PRECHECK(SetWindowContentColor);
350#endif
351    if (!PyArg_ParseTuple(_args, "O&",
352                          QdRGB_Convert, &color))
353        return NULL;
354    _err = SetWindowContentColor(_self->ob_itself,
355                                 &color);
356    if (_err != noErr) return PyMac_Error(_err);
357    Py_INCREF(Py_None);
358    _res = Py_None;
359    return _res;
360}
361
362static PyObject *WinObj_GetWindowContentColor(WindowObject *_self, PyObject *_args)
363{
364    PyObject *_res = NULL;
365    OSStatus _err;
366    RGBColor color;
367#ifndef GetWindowContentColor
368    PyMac_PRECHECK(GetWindowContentColor);
369#endif
370    if (!PyArg_ParseTuple(_args, ""))
371        return NULL;
372    _err = GetWindowContentColor(_self->ob_itself,
373                                 &color);
374    if (_err != noErr) return PyMac_Error(_err);
375    _res = Py_BuildValue("O&",
376                         QdRGB_New, &color);
377    return _res;
378}
379
380static PyObject *WinObj_GetWindowContentPattern(WindowObject *_self, PyObject *_args)
381{
382    PyObject *_res = NULL;
383    OSStatus _err;
384    PixPatHandle outPixPat;
385#ifndef GetWindowContentPattern
386    PyMac_PRECHECK(GetWindowContentPattern);
387#endif
388    if (!PyArg_ParseTuple(_args, "O&",
389                          ResObj_Convert, &outPixPat))
390        return NULL;
391    _err = GetWindowContentPattern(_self->ob_itself,
392                                   outPixPat);
393    if (_err != noErr) return PyMac_Error(_err);
394    Py_INCREF(Py_None);
395    _res = Py_None;
396    return _res;
397}
398
399static PyObject *WinObj_SetWindowContentPattern(WindowObject *_self, PyObject *_args)
400{
401    PyObject *_res = NULL;
402    OSStatus _err;
403    PixPatHandle pixPat;
404#ifndef SetWindowContentPattern
405    PyMac_PRECHECK(SetWindowContentPattern);
406#endif
407    if (!PyArg_ParseTuple(_args, "O&",
408                          ResObj_Convert, &pixPat))
409        return NULL;
410    _err = SetWindowContentPattern(_self->ob_itself,
411                                   pixPat);
412    if (_err != noErr) return PyMac_Error(_err);
413    Py_INCREF(Py_None);
414    _res = Py_None;
415    return _res;
416}
417
418static PyObject *WinObj_ScrollWindowRect(WindowObject *_self, PyObject *_args)
419{
420    PyObject *_res = NULL;
421    OSStatus _err;
422    Rect inScrollRect;
423    SInt16 inHPixels;
424    SInt16 inVPixels;
425    ScrollWindowOptions inOptions;
426    RgnHandle outExposedRgn;
427#ifndef ScrollWindowRect
428    PyMac_PRECHECK(ScrollWindowRect);
429#endif
430    if (!PyArg_ParseTuple(_args, "O&hhlO&",
431                          PyMac_GetRect, &inScrollRect,
432                          &inHPixels,
433                          &inVPixels,
434                          &inOptions,
435                          ResObj_Convert, &outExposedRgn))
436        return NULL;
437    _err = ScrollWindowRect(_self->ob_itself,
438                            &inScrollRect,
439                            inHPixels,
440                            inVPixels,
441                            inOptions,
442                            outExposedRgn);
443    if (_err != noErr) return PyMac_Error(_err);
444    Py_INCREF(Py_None);
445    _res = Py_None;
446    return _res;
447}
448
449static PyObject *WinObj_ScrollWindowRegion(WindowObject *_self, PyObject *_args)
450{
451    PyObject *_res = NULL;
452    OSStatus _err;
453    RgnHandle inScrollRgn;
454    SInt16 inHPixels;
455    SInt16 inVPixels;
456    ScrollWindowOptions inOptions;
457    RgnHandle outExposedRgn;
458#ifndef ScrollWindowRegion
459    PyMac_PRECHECK(ScrollWindowRegion);
460#endif
461    if (!PyArg_ParseTuple(_args, "O&hhlO&",
462                          ResObj_Convert, &inScrollRgn,
463                          &inHPixels,
464                          &inVPixels,
465                          &inOptions,
466                          ResObj_Convert, &outExposedRgn))
467        return NULL;
468    _err = ScrollWindowRegion(_self->ob_itself,
469                              inScrollRgn,
470                              inHPixels,
471                              inVPixels,
472                              inOptions,
473                              outExposedRgn);
474    if (_err != noErr) return PyMac_Error(_err);
475    Py_INCREF(Py_None);
476    _res = Py_None;
477    return _res;
478}
479
480static PyObject *WinObj_ClipAbove(WindowObject *_self, PyObject *_args)
481{
482    PyObject *_res = NULL;
483#ifndef ClipAbove
484    PyMac_PRECHECK(ClipAbove);
485#endif
486    if (!PyArg_ParseTuple(_args, ""))
487        return NULL;
488    ClipAbove(_self->ob_itself);
489    Py_INCREF(Py_None);
490    _res = Py_None;
491    return _res;
492}
493
494static PyObject *WinObj_PaintOne(WindowObject *_self, PyObject *_args)
495{
496    PyObject *_res = NULL;
497    RgnHandle clobberedRgn;
498#ifndef PaintOne
499    PyMac_PRECHECK(PaintOne);
500#endif
501    if (!PyArg_ParseTuple(_args, "O&",
502                          ResObj_Convert, &clobberedRgn))
503        return NULL;
504    PaintOne(_self->ob_itself,
505             clobberedRgn);
506    Py_INCREF(Py_None);
507    _res = Py_None;
508    return _res;
509}
510
511static PyObject *WinObj_PaintBehind(WindowObject *_self, PyObject *_args)
512{
513    PyObject *_res = NULL;
514    RgnHandle clobberedRgn;
515#ifndef PaintBehind
516    PyMac_PRECHECK(PaintBehind);
517#endif
518    if (!PyArg_ParseTuple(_args, "O&",
519                          ResObj_Convert, &clobberedRgn))
520        return NULL;
521    PaintBehind(_self->ob_itself,
522                clobberedRgn);
523    Py_INCREF(Py_None);
524    _res = Py_None;
525    return _res;
526}
527
528static PyObject *WinObj_CalcVis(WindowObject *_self, PyObject *_args)
529{
530    PyObject *_res = NULL;
531#ifndef CalcVis
532    PyMac_PRECHECK(CalcVis);
533#endif
534    if (!PyArg_ParseTuple(_args, ""))
535        return NULL;
536    CalcVis(_self->ob_itself);
537    Py_INCREF(Py_None);
538    _res = Py_None;
539    return _res;
540}
541
542static PyObject *WinObj_CalcVisBehind(WindowObject *_self, PyObject *_args)
543{
544    PyObject *_res = NULL;
545    RgnHandle clobberedRgn;
546#ifndef CalcVisBehind
547    PyMac_PRECHECK(CalcVisBehind);
548#endif
549    if (!PyArg_ParseTuple(_args, "O&",
550                          ResObj_Convert, &clobberedRgn))
551        return NULL;
552    CalcVisBehind(_self->ob_itself,
553                  clobberedRgn);
554    Py_INCREF(Py_None);
555    _res = Py_None;
556    return _res;
557}
558
559static PyObject *WinObj_BringToFront(WindowObject *_self, PyObject *_args)
560{
561    PyObject *_res = NULL;
562#ifndef BringToFront
563    PyMac_PRECHECK(BringToFront);
564#endif
565    if (!PyArg_ParseTuple(_args, ""))
566        return NULL;
567    BringToFront(_self->ob_itself);
568    Py_INCREF(Py_None);
569    _res = Py_None;
570    return _res;
571}
572
573static PyObject *WinObj_SendBehind(WindowObject *_self, PyObject *_args)
574{
575    PyObject *_res = NULL;
576    WindowPtr behindWindow;
577#ifndef SendBehind
578    PyMac_PRECHECK(SendBehind);
579#endif
580    if (!PyArg_ParseTuple(_args, "O&",
581                          WinObj_Convert, &behindWindow))
582        return NULL;
583    SendBehind(_self->ob_itself,
584               behindWindow);
585    Py_INCREF(Py_None);
586    _res = Py_None;
587    return _res;
588}
589
590static PyObject *WinObj_SelectWindow(WindowObject *_self, PyObject *_args)
591{
592    PyObject *_res = NULL;
593#ifndef SelectWindow
594    PyMac_PRECHECK(SelectWindow);
595#endif
596    if (!PyArg_ParseTuple(_args, ""))
597        return NULL;
598    SelectWindow(_self->ob_itself);
599    Py_INCREF(Py_None);
600    _res = Py_None;
601    return _res;
602}
603
604static PyObject *WinObj_GetNextWindowOfClass(WindowObject *_self, PyObject *_args)
605{
606    PyObject *_res = NULL;
607    WindowPtr _rv;
608    WindowClass inWindowClass;
609    Boolean mustBeVisible;
610#ifndef GetNextWindowOfClass
611    PyMac_PRECHECK(GetNextWindowOfClass);
612#endif
613    if (!PyArg_ParseTuple(_args, "lb",
614                          &inWindowClass,
615                          &mustBeVisible))
616        return NULL;
617    _rv = GetNextWindowOfClass(_self->ob_itself,
618                               inWindowClass,
619                               mustBeVisible);
620    _res = Py_BuildValue("O&",
621                         WinObj_New, _rv);
622    return _res;
623}
624
625static PyObject *WinObj_SetWindowAlternateTitle(WindowObject *_self, PyObject *_args)
626{
627    PyObject *_res = NULL;
628    OSStatus _err;
629    CFStringRef inTitle;
630#ifndef SetWindowAlternateTitle
631    PyMac_PRECHECK(SetWindowAlternateTitle);
632#endif
633    if (!PyArg_ParseTuple(_args, "O&",
634                          CFStringRefObj_Convert, &inTitle))
635        return NULL;
636    _err = SetWindowAlternateTitle(_self->ob_itself,
637                                   inTitle);
638    if (_err != noErr) return PyMac_Error(_err);
639    Py_INCREF(Py_None);
640    _res = Py_None;
641    return _res;
642}
643
644static PyObject *WinObj_CopyWindowAlternateTitle(WindowObject *_self, PyObject *_args)
645{
646    PyObject *_res = NULL;
647    OSStatus _err;
648    CFStringRef outTitle;
649#ifndef CopyWindowAlternateTitle
650    PyMac_PRECHECK(CopyWindowAlternateTitle);
651#endif
652    if (!PyArg_ParseTuple(_args, ""))
653        return NULL;
654    _err = CopyWindowAlternateTitle(_self->ob_itself,
655                                    &outTitle);
656    if (_err != noErr) return PyMac_Error(_err);
657    _res = Py_BuildValue("O&",
658                         CFStringRefObj_New, outTitle);
659    return _res;
660}
661
662static PyObject *WinObj_HiliteWindow(WindowObject *_self, PyObject *_args)
663{
664    PyObject *_res = NULL;
665    Boolean fHilite;
666#ifndef HiliteWindow
667    PyMac_PRECHECK(HiliteWindow);
668#endif
669    if (!PyArg_ParseTuple(_args, "b",
670                          &fHilite))
671        return NULL;
672    HiliteWindow(_self->ob_itself,
673                 fHilite);
674    Py_INCREF(Py_None);
675    _res = Py_None;
676    return _res;
677}
678
679static PyObject *WinObj_SetWRefCon(WindowObject *_self, PyObject *_args)
680{
681    PyObject *_res = NULL;
682    long data;
683#ifndef SetWRefCon
684    PyMac_PRECHECK(SetWRefCon);
685#endif
686    if (!PyArg_ParseTuple(_args, "l",
687                          &data))
688        return NULL;
689    SetWRefCon(_self->ob_itself,
690               data);
691    Py_INCREF(Py_None);
692    _res = Py_None;
693    return _res;
694}
695
696static PyObject *WinObj_GetWRefCon(WindowObject *_self, PyObject *_args)
697{
698    PyObject *_res = NULL;
699    long _rv;
700#ifndef GetWRefCon
701    PyMac_PRECHECK(GetWRefCon);
702#endif
703    if (!PyArg_ParseTuple(_args, ""))
704        return NULL;
705    _rv = GetWRefCon(_self->ob_itself);
706    _res = Py_BuildValue("l",
707                         _rv);
708    return _res;
709}
710
711static PyObject *WinObj_SetWindowPic(WindowObject *_self, PyObject *_args)
712{
713    PyObject *_res = NULL;
714    PicHandle pic;
715#ifndef SetWindowPic
716    PyMac_PRECHECK(SetWindowPic);
717#endif
718    if (!PyArg_ParseTuple(_args, "O&",
719                          ResObj_Convert, &pic))
720        return NULL;
721    SetWindowPic(_self->ob_itself,
722                 pic);
723    Py_INCREF(Py_None);
724    _res = Py_None;
725    return _res;
726}
727
728static PyObject *WinObj_GetWindowPic(WindowObject *_self, PyObject *_args)
729{
730    PyObject *_res = NULL;
731    PicHandle _rv;
732#ifndef GetWindowPic
733    PyMac_PRECHECK(GetWindowPic);
734#endif
735    if (!PyArg_ParseTuple(_args, ""))
736        return NULL;
737    _rv = GetWindowPic(_self->ob_itself);
738    _res = Py_BuildValue("O&",
739                         ResObj_New, _rv);
740    return _res;
741}
742
743static PyObject *WinObj_GetWVariant(WindowObject *_self, PyObject *_args)
744{
745    PyObject *_res = NULL;
746    short _rv;
747#ifndef GetWVariant
748    PyMac_PRECHECK(GetWVariant);
749#endif
750    if (!PyArg_ParseTuple(_args, ""))
751        return NULL;
752    _rv = GetWVariant(_self->ob_itself);
753    _res = Py_BuildValue("h",
754                         _rv);
755    return _res;
756}
757
758static PyObject *WinObj_GetWindowFeatures(WindowObject *_self, PyObject *_args)
759{
760    PyObject *_res = NULL;
761    OSStatus _err;
762    UInt32 outFeatures;
763#ifndef GetWindowFeatures
764    PyMac_PRECHECK(GetWindowFeatures);
765#endif
766    if (!PyArg_ParseTuple(_args, ""))
767        return NULL;
768    _err = GetWindowFeatures(_self->ob_itself,
769                             &outFeatures);
770    if (_err != noErr) return PyMac_Error(_err);
771    _res = Py_BuildValue("l",
772                         outFeatures);
773    return _res;
774}
775
776static PyObject *WinObj_GetWindowRegion(WindowObject *_self, PyObject *_args)
777{
778    PyObject *_res = NULL;
779    OSStatus _err;
780    WindowRegionCode inRegionCode;
781    RgnHandle ioWinRgn;
782#ifndef GetWindowRegion
783    PyMac_PRECHECK(GetWindowRegion);
784#endif
785    if (!PyArg_ParseTuple(_args, "HO&",
786                          &inRegionCode,
787                          ResObj_Convert, &ioWinRgn))
788        return NULL;
789    _err = GetWindowRegion(_self->ob_itself,
790                           inRegionCode,
791                           ioWinRgn);
792    if (_err != noErr) return PyMac_Error(_err);
793    Py_INCREF(Py_None);
794    _res = Py_None;
795    return _res;
796}
797
798static PyObject *WinObj_GetWindowStructureWidths(WindowObject *_self, PyObject *_args)
799{
800    PyObject *_res = NULL;
801    OSStatus _err;
802    Rect outRect;
803#ifndef GetWindowStructureWidths
804    PyMac_PRECHECK(GetWindowStructureWidths);
805#endif
806    if (!PyArg_ParseTuple(_args, ""))
807        return NULL;
808    _err = GetWindowStructureWidths(_self->ob_itself,
809                                    &outRect);
810    if (_err != noErr) return PyMac_Error(_err);
811    _res = Py_BuildValue("O&",
812                         PyMac_BuildRect, &outRect);
813    return _res;
814}
815
816static PyObject *WinObj_BeginUpdate(WindowObject *_self, PyObject *_args)
817{
818    PyObject *_res = NULL;
819#ifndef BeginUpdate
820    PyMac_PRECHECK(BeginUpdate);
821#endif
822    if (!PyArg_ParseTuple(_args, ""))
823        return NULL;
824    BeginUpdate(_self->ob_itself);
825    Py_INCREF(Py_None);
826    _res = Py_None;
827    return _res;
828}
829
830static PyObject *WinObj_EndUpdate(WindowObject *_self, PyObject *_args)
831{
832    PyObject *_res = NULL;
833#ifndef EndUpdate
834    PyMac_PRECHECK(EndUpdate);
835#endif
836    if (!PyArg_ParseTuple(_args, ""))
837        return NULL;
838    EndUpdate(_self->ob_itself);
839    Py_INCREF(Py_None);
840    _res = Py_None;
841    return _res;
842}
843
844static PyObject *WinObj_InvalWindowRgn(WindowObject *_self, PyObject *_args)
845{
846    PyObject *_res = NULL;
847    OSStatus _err;
848    RgnHandle region;
849#ifndef InvalWindowRgn
850    PyMac_PRECHECK(InvalWindowRgn);
851#endif
852    if (!PyArg_ParseTuple(_args, "O&",
853                          ResObj_Convert, &region))
854        return NULL;
855    _err = InvalWindowRgn(_self->ob_itself,
856                          region);
857    if (_err != noErr) return PyMac_Error(_err);
858    Py_INCREF(Py_None);
859    _res = Py_None;
860    return _res;
861}
862
863static PyObject *WinObj_InvalWindowRect(WindowObject *_self, PyObject *_args)
864{
865    PyObject *_res = NULL;
866    OSStatus _err;
867    Rect bounds;
868#ifndef InvalWindowRect
869    PyMac_PRECHECK(InvalWindowRect);
870#endif
871    if (!PyArg_ParseTuple(_args, "O&",
872                          PyMac_GetRect, &bounds))
873        return NULL;
874    _err = InvalWindowRect(_self->ob_itself,
875                           &bounds);
876    if (_err != noErr) return PyMac_Error(_err);
877    Py_INCREF(Py_None);
878    _res = Py_None;
879    return _res;
880}
881
882static PyObject *WinObj_ValidWindowRgn(WindowObject *_self, PyObject *_args)
883{
884    PyObject *_res = NULL;
885    OSStatus _err;
886    RgnHandle region;
887#ifndef ValidWindowRgn
888    PyMac_PRECHECK(ValidWindowRgn);
889#endif
890    if (!PyArg_ParseTuple(_args, "O&",
891                          ResObj_Convert, &region))
892        return NULL;
893    _err = ValidWindowRgn(_self->ob_itself,
894                          region);
895    if (_err != noErr) return PyMac_Error(_err);
896    Py_INCREF(Py_None);
897    _res = Py_None;
898    return _res;
899}
900
901static PyObject *WinObj_ValidWindowRect(WindowObject *_self, PyObject *_args)
902{
903    PyObject *_res = NULL;
904    OSStatus _err;
905    Rect bounds;
906#ifndef ValidWindowRect
907    PyMac_PRECHECK(ValidWindowRect);
908#endif
909    if (!PyArg_ParseTuple(_args, "O&",
910                          PyMac_GetRect, &bounds))
911        return NULL;
912    _err = ValidWindowRect(_self->ob_itself,
913                           &bounds);
914    if (_err != noErr) return PyMac_Error(_err);
915    Py_INCREF(Py_None);
916    _res = Py_None;
917    return _res;
918}
919
920static PyObject *WinObj_DrawGrowIcon(WindowObject *_self, PyObject *_args)
921{
922    PyObject *_res = NULL;
923#ifndef DrawGrowIcon
924    PyMac_PRECHECK(DrawGrowIcon);
925#endif
926    if (!PyArg_ParseTuple(_args, ""))
927        return NULL;
928    DrawGrowIcon(_self->ob_itself);
929    Py_INCREF(Py_None);
930    _res = Py_None;
931    return _res;
932}
933
934static PyObject *WinObj_SetWTitle(WindowObject *_self, PyObject *_args)
935{
936    PyObject *_res = NULL;
937    Str255 title;
938#ifndef SetWTitle
939    PyMac_PRECHECK(SetWTitle);
940#endif
941    if (!PyArg_ParseTuple(_args, "O&",
942                          PyMac_GetStr255, title))
943        return NULL;
944    SetWTitle(_self->ob_itself,
945              title);
946    Py_INCREF(Py_None);
947    _res = Py_None;
948    return _res;
949}
950
951static PyObject *WinObj_GetWTitle(WindowObject *_self, PyObject *_args)
952{
953    PyObject *_res = NULL;
954    Str255 title;
955#ifndef GetWTitle
956    PyMac_PRECHECK(GetWTitle);
957#endif
958    if (!PyArg_ParseTuple(_args, ""))
959        return NULL;
960    GetWTitle(_self->ob_itself,
961              title);
962    _res = Py_BuildValue("O&",
963                         PyMac_BuildStr255, title);
964    return _res;
965}
966
967static PyObject *WinObj_SetWindowTitleWithCFString(WindowObject *_self, PyObject *_args)
968{
969    PyObject *_res = NULL;
970    OSStatus _err;
971    CFStringRef inString;
972#ifndef SetWindowTitleWithCFString
973    PyMac_PRECHECK(SetWindowTitleWithCFString);
974#endif
975    if (!PyArg_ParseTuple(_args, "O&",
976                          CFStringRefObj_Convert, &inString))
977        return NULL;
978    _err = SetWindowTitleWithCFString(_self->ob_itself,
979                                      inString);
980    if (_err != noErr) return PyMac_Error(_err);
981    Py_INCREF(Py_None);
982    _res = Py_None;
983    return _res;
984}
985
986static PyObject *WinObj_CopyWindowTitleAsCFString(WindowObject *_self, PyObject *_args)
987{
988    PyObject *_res = NULL;
989    OSStatus _err;
990    CFStringRef outString;
991#ifndef CopyWindowTitleAsCFString
992    PyMac_PRECHECK(CopyWindowTitleAsCFString);
993#endif
994    if (!PyArg_ParseTuple(_args, ""))
995        return NULL;
996    _err = CopyWindowTitleAsCFString(_self->ob_itself,
997                                     &outString);
998    if (_err != noErr) return PyMac_Error(_err);
999    _res = Py_BuildValue("O&",
1000                         CFStringRefObj_New, outString);
1001    return _res;
1002}
1003
1004static PyObject *WinObj_SetWindowProxyFSSpec(WindowObject *_self, PyObject *_args)
1005{
1006    PyObject *_res = NULL;
1007    OSStatus _err;
1008    FSSpec inFile;
1009#ifndef SetWindowProxyFSSpec
1010    PyMac_PRECHECK(SetWindowProxyFSSpec);
1011#endif
1012    if (!PyArg_ParseTuple(_args, "O&",
1013                          PyMac_GetFSSpec, &inFile))
1014        return NULL;
1015    _err = SetWindowProxyFSSpec(_self->ob_itself,
1016                                &inFile);
1017    if (_err != noErr) return PyMac_Error(_err);
1018    Py_INCREF(Py_None);
1019    _res = Py_None;
1020    return _res;
1021}
1022
1023static PyObject *WinObj_GetWindowProxyFSSpec(WindowObject *_self, PyObject *_args)
1024{
1025    PyObject *_res = NULL;
1026    OSStatus _err;
1027    FSSpec outFile;
1028#ifndef GetWindowProxyFSSpec
1029    PyMac_PRECHECK(GetWindowProxyFSSpec);
1030#endif
1031    if (!PyArg_ParseTuple(_args, ""))
1032        return NULL;
1033    _err = GetWindowProxyFSSpec(_self->ob_itself,
1034                                &outFile);
1035    if (_err != noErr) return PyMac_Error(_err);
1036    _res = Py_BuildValue("O&",
1037                         PyMac_BuildFSSpec, &outFile);
1038    return _res;
1039}
1040
1041static PyObject *WinObj_SetWindowProxyAlias(WindowObject *_self, PyObject *_args)
1042{
1043    PyObject *_res = NULL;
1044    OSStatus _err;
1045    AliasHandle inAlias;
1046#ifndef SetWindowProxyAlias
1047    PyMac_PRECHECK(SetWindowProxyAlias);
1048#endif
1049    if (!PyArg_ParseTuple(_args, "O&",
1050                          ResObj_Convert, &inAlias))
1051        return NULL;
1052    _err = SetWindowProxyAlias(_self->ob_itself,
1053                               inAlias);
1054    if (_err != noErr) return PyMac_Error(_err);
1055    Py_INCREF(Py_None);
1056    _res = Py_None;
1057    return _res;
1058}
1059
1060static PyObject *WinObj_GetWindowProxyAlias(WindowObject *_self, PyObject *_args)
1061{
1062    PyObject *_res = NULL;
1063    OSStatus _err;
1064    AliasHandle alias;
1065#ifndef GetWindowProxyAlias
1066    PyMac_PRECHECK(GetWindowProxyAlias);
1067#endif
1068    if (!PyArg_ParseTuple(_args, ""))
1069        return NULL;
1070    _err = GetWindowProxyAlias(_self->ob_itself,
1071                               &alias);
1072    if (_err != noErr) return PyMac_Error(_err);
1073    _res = Py_BuildValue("O&",
1074                         ResObj_New, alias);
1075    return _res;
1076}
1077
1078static PyObject *WinObj_SetWindowProxyCreatorAndType(WindowObject *_self, PyObject *_args)
1079{
1080    PyObject *_res = NULL;
1081    OSStatus _err;
1082    OSType fileCreator;
1083    OSType fileType;
1084    SInt16 vRefNum;
1085#ifndef SetWindowProxyCreatorAndType
1086    PyMac_PRECHECK(SetWindowProxyCreatorAndType);
1087#endif
1088    if (!PyArg_ParseTuple(_args, "O&O&h",
1089                          PyMac_GetOSType, &fileCreator,
1090                          PyMac_GetOSType, &fileType,
1091                          &vRefNum))
1092        return NULL;
1093    _err = SetWindowProxyCreatorAndType(_self->ob_itself,
1094                                        fileCreator,
1095                                        fileType,
1096                                        vRefNum);
1097    if (_err != noErr) return PyMac_Error(_err);
1098    Py_INCREF(Py_None);
1099    _res = Py_None;
1100    return _res;
1101}
1102
1103static PyObject *WinObj_GetWindowProxyIcon(WindowObject *_self, PyObject *_args)
1104{
1105    PyObject *_res = NULL;
1106    OSStatus _err;
1107    IconRef outIcon;
1108#ifndef GetWindowProxyIcon
1109    PyMac_PRECHECK(GetWindowProxyIcon);
1110#endif
1111    if (!PyArg_ParseTuple(_args, ""))
1112        return NULL;
1113    _err = GetWindowProxyIcon(_self->ob_itself,
1114                              &outIcon);
1115    if (_err != noErr) return PyMac_Error(_err);
1116    _res = Py_BuildValue("O&",
1117                         ResObj_New, outIcon);
1118    return _res;
1119}
1120
1121static PyObject *WinObj_SetWindowProxyIcon(WindowObject *_self, PyObject *_args)
1122{
1123    PyObject *_res = NULL;
1124    OSStatus _err;
1125    IconRef icon;
1126#ifndef SetWindowProxyIcon
1127    PyMac_PRECHECK(SetWindowProxyIcon);
1128#endif
1129    if (!PyArg_ParseTuple(_args, "O&",
1130                          ResObj_Convert, &icon))
1131        return NULL;
1132    _err = SetWindowProxyIcon(_self->ob_itself,
1133                              icon);
1134    if (_err != noErr) return PyMac_Error(_err);
1135    Py_INCREF(Py_None);
1136    _res = Py_None;
1137    return _res;
1138}
1139
1140static PyObject *WinObj_RemoveWindowProxy(WindowObject *_self, PyObject *_args)
1141{
1142    PyObject *_res = NULL;
1143    OSStatus _err;
1144#ifndef RemoveWindowProxy
1145    PyMac_PRECHECK(RemoveWindowProxy);
1146#endif
1147    if (!PyArg_ParseTuple(_args, ""))
1148        return NULL;
1149    _err = RemoveWindowProxy(_self->ob_itself);
1150    if (_err != noErr) return PyMac_Error(_err);
1151    Py_INCREF(Py_None);
1152    _res = Py_None;
1153    return _res;
1154}
1155
1156static PyObject *WinObj_BeginWindowProxyDrag(WindowObject *_self, PyObject *_args)
1157{
1158    PyObject *_res = NULL;
1159    OSStatus _err;
1160    DragReference outNewDrag;
1161    RgnHandle outDragOutlineRgn;
1162#ifndef BeginWindowProxyDrag
1163    PyMac_PRECHECK(BeginWindowProxyDrag);
1164#endif
1165    if (!PyArg_ParseTuple(_args, "O&",
1166                          ResObj_Convert, &outDragOutlineRgn))
1167        return NULL;
1168    _err = BeginWindowProxyDrag(_self->ob_itself,
1169                                &outNewDrag,
1170                                outDragOutlineRgn);
1171    if (_err != noErr) return PyMac_Error(_err);
1172    _res = Py_BuildValue("O&",
1173                         DragObj_New, outNewDrag);
1174    return _res;
1175}
1176
1177static PyObject *WinObj_EndWindowProxyDrag(WindowObject *_self, PyObject *_args)
1178{
1179    PyObject *_res = NULL;
1180    OSStatus _err;
1181    DragReference theDrag;
1182#ifndef EndWindowProxyDrag
1183    PyMac_PRECHECK(EndWindowProxyDrag);
1184#endif
1185    if (!PyArg_ParseTuple(_args, "O&",
1186                          DragObj_Convert, &theDrag))
1187        return NULL;
1188    _err = EndWindowProxyDrag(_self->ob_itself,
1189                              theDrag);
1190    if (_err != noErr) return PyMac_Error(_err);
1191    Py_INCREF(Py_None);
1192    _res = Py_None;
1193    return _res;
1194}
1195
1196static PyObject *WinObj_TrackWindowProxyFromExistingDrag(WindowObject *_self, PyObject *_args)
1197{
1198    PyObject *_res = NULL;
1199    OSStatus _err;
1200    Point startPt;
1201    DragReference drag;
1202    RgnHandle inDragOutlineRgn;
1203#ifndef TrackWindowProxyFromExistingDrag
1204    PyMac_PRECHECK(TrackWindowProxyFromExistingDrag);
1205#endif
1206    if (!PyArg_ParseTuple(_args, "O&O&O&",
1207                          PyMac_GetPoint, &startPt,
1208                          DragObj_Convert, &drag,
1209                          ResObj_Convert, &inDragOutlineRgn))
1210        return NULL;
1211    _err = TrackWindowProxyFromExistingDrag(_self->ob_itself,
1212                                            startPt,
1213                                            drag,
1214                                            inDragOutlineRgn);
1215    if (_err != noErr) return PyMac_Error(_err);
1216    Py_INCREF(Py_None);
1217    _res = Py_None;
1218    return _res;
1219}
1220
1221static PyObject *WinObj_TrackWindowProxyDrag(WindowObject *_self, PyObject *_args)
1222{
1223    PyObject *_res = NULL;
1224    OSStatus _err;
1225    Point startPt;
1226#ifndef TrackWindowProxyDrag
1227    PyMac_PRECHECK(TrackWindowProxyDrag);
1228#endif
1229    if (!PyArg_ParseTuple(_args, "O&",
1230                          PyMac_GetPoint, &startPt))
1231        return NULL;
1232    _err = TrackWindowProxyDrag(_self->ob_itself,
1233                                startPt);
1234    if (_err != noErr) return PyMac_Error(_err);
1235    Py_INCREF(Py_None);
1236    _res = Py_None;
1237    return _res;
1238}
1239
1240static PyObject *WinObj_IsWindowModified(WindowObject *_self, PyObject *_args)
1241{
1242    PyObject *_res = NULL;
1243    Boolean _rv;
1244#ifndef IsWindowModified
1245    PyMac_PRECHECK(IsWindowModified);
1246#endif
1247    if (!PyArg_ParseTuple(_args, ""))
1248        return NULL;
1249    _rv = IsWindowModified(_self->ob_itself);
1250    _res = Py_BuildValue("b",
1251                         _rv);
1252    return _res;
1253}
1254
1255static PyObject *WinObj_SetWindowModified(WindowObject *_self, PyObject *_args)
1256{
1257    PyObject *_res = NULL;
1258    OSStatus _err;
1259    Boolean modified;
1260#ifndef SetWindowModified
1261    PyMac_PRECHECK(SetWindowModified);
1262#endif
1263    if (!PyArg_ParseTuple(_args, "b",
1264                          &modified))
1265        return NULL;
1266    _err = SetWindowModified(_self->ob_itself,
1267                             modified);
1268    if (_err != noErr) return PyMac_Error(_err);
1269    Py_INCREF(Py_None);
1270    _res = Py_None;
1271    return _res;
1272}
1273
1274static PyObject *WinObj_IsWindowPathSelectClick(WindowObject *_self, PyObject *_args)
1275{
1276    PyObject *_res = NULL;
1277    Boolean _rv;
1278    EventRecord event;
1279#ifndef IsWindowPathSelectClick
1280    PyMac_PRECHECK(IsWindowPathSelectClick);
1281#endif
1282    if (!PyArg_ParseTuple(_args, "O&",
1283                          PyMac_GetEventRecord, &event))
1284        return NULL;
1285    _rv = IsWindowPathSelectClick(_self->ob_itself,
1286                                  &event);
1287    _res = Py_BuildValue("b",
1288                         _rv);
1289    return _res;
1290}
1291
1292static PyObject *WinObj_WindowPathSelect(WindowObject *_self, PyObject *_args)
1293{
1294    PyObject *_res = NULL;
1295    OSStatus _err;
1296    MenuHandle menu;
1297    SInt32 outMenuResult;
1298#ifndef WindowPathSelect
1299    PyMac_PRECHECK(WindowPathSelect);
1300#endif
1301    if (!PyArg_ParseTuple(_args, "O&",
1302                          MenuObj_Convert, &menu))
1303        return NULL;
1304    _err = WindowPathSelect(_self->ob_itself,
1305                            menu,
1306                            &outMenuResult);
1307    if (_err != noErr) return PyMac_Error(_err);
1308    _res = Py_BuildValue("l",
1309                         outMenuResult);
1310    return _res;
1311}
1312
1313static PyObject *WinObj_HiliteWindowFrameForDrag(WindowObject *_self, PyObject *_args)
1314{
1315    PyObject *_res = NULL;
1316    OSStatus _err;
1317    Boolean hilited;
1318#ifndef HiliteWindowFrameForDrag
1319    PyMac_PRECHECK(HiliteWindowFrameForDrag);
1320#endif
1321    if (!PyArg_ParseTuple(_args, "b",
1322                          &hilited))
1323        return NULL;
1324    _err = HiliteWindowFrameForDrag(_self->ob_itself,
1325                                    hilited);
1326    if (_err != noErr) return PyMac_Error(_err);
1327    Py_INCREF(Py_None);
1328    _res = Py_None;
1329    return _res;
1330}
1331
1332static PyObject *WinObj_TransitionWindow(WindowObject *_self, PyObject *_args)
1333{
1334    PyObject *_res = NULL;
1335    OSStatus _err;
1336    WindowTransitionEffect inEffect;
1337    WindowTransitionAction inAction;
1338    Rect inRect;
1339#ifndef TransitionWindow
1340    PyMac_PRECHECK(TransitionWindow);
1341#endif
1342    if (!PyArg_ParseTuple(_args, "llO&",
1343                          &inEffect,
1344                          &inAction,
1345                          PyMac_GetRect, &inRect))
1346        return NULL;
1347    _err = TransitionWindow(_self->ob_itself,
1348                            inEffect,
1349                            inAction,
1350                            &inRect);
1351    if (_err != noErr) return PyMac_Error(_err);
1352    Py_INCREF(Py_None);
1353    _res = Py_None;
1354    return _res;
1355}
1356
1357static PyObject *WinObj_TransitionWindowAndParent(WindowObject *_self, PyObject *_args)
1358{
1359    PyObject *_res = NULL;
1360    OSStatus _err;
1361    WindowPtr inParentWindow;
1362    WindowTransitionEffect inEffect;
1363    WindowTransitionAction inAction;
1364    Rect inRect;
1365#ifndef TransitionWindowAndParent
1366    PyMac_PRECHECK(TransitionWindowAndParent);
1367#endif
1368    if (!PyArg_ParseTuple(_args, "O&llO&",
1369                          WinObj_Convert, &inParentWindow,
1370                          &inEffect,
1371                          &inAction,
1372                          PyMac_GetRect, &inRect))
1373        return NULL;
1374    _err = TransitionWindowAndParent(_self->ob_itself,
1375                                     inParentWindow,
1376                                     inEffect,
1377                                     inAction,
1378                                     &inRect);
1379    if (_err != noErr) return PyMac_Error(_err);
1380    Py_INCREF(Py_None);
1381    _res = Py_None;
1382    return _res;
1383}
1384
1385static PyObject *WinObj_MacMoveWindow(WindowObject *_self, PyObject *_args)
1386{
1387    PyObject *_res = NULL;
1388    short hGlobal;
1389    short vGlobal;
1390    Boolean front;
1391#ifndef MacMoveWindow
1392    PyMac_PRECHECK(MacMoveWindow);
1393#endif
1394    if (!PyArg_ParseTuple(_args, "hhb",
1395                          &hGlobal,
1396                          &vGlobal,
1397                          &front))
1398        return NULL;
1399    MacMoveWindow(_self->ob_itself,
1400                  hGlobal,
1401                  vGlobal,
1402                  front);
1403    Py_INCREF(Py_None);
1404    _res = Py_None;
1405    return _res;
1406}
1407
1408static PyObject *WinObj_SizeWindow(WindowObject *_self, PyObject *_args)
1409{
1410    PyObject *_res = NULL;
1411    short w;
1412    short h;
1413    Boolean fUpdate;
1414#ifndef SizeWindow
1415    PyMac_PRECHECK(SizeWindow);
1416#endif
1417    if (!PyArg_ParseTuple(_args, "hhb",
1418                          &w,
1419                          &h,
1420                          &fUpdate))
1421        return NULL;
1422    SizeWindow(_self->ob_itself,
1423               w,
1424               h,
1425               fUpdate);
1426    Py_INCREF(Py_None);
1427    _res = Py_None;
1428    return _res;
1429}
1430
1431static PyObject *WinObj_GrowWindow(WindowObject *_self, PyObject *_args)
1432{
1433    PyObject *_res = NULL;
1434    long _rv;
1435    Point startPt;
1436    Rect bBox;
1437#ifndef GrowWindow
1438    PyMac_PRECHECK(GrowWindow);
1439#endif
1440    if (!PyArg_ParseTuple(_args, "O&O&",
1441                          PyMac_GetPoint, &startPt,
1442                          PyMac_GetRect, &bBox))
1443        return NULL;
1444    _rv = GrowWindow(_self->ob_itself,
1445                     startPt,
1446                     &bBox);
1447    _res = Py_BuildValue("l",
1448                         _rv);
1449    return _res;
1450}
1451
1452static PyObject *WinObj_DragWindow(WindowObject *_self, PyObject *_args)
1453{
1454    PyObject *_res = NULL;
1455    Point startPt;
1456    Rect boundsRect;
1457#ifndef DragWindow
1458    PyMac_PRECHECK(DragWindow);
1459#endif
1460    if (!PyArg_ParseTuple(_args, "O&O&",
1461                          PyMac_GetPoint, &startPt,
1462                          PyMac_GetRect, &boundsRect))
1463        return NULL;
1464    DragWindow(_self->ob_itself,
1465               startPt,
1466               &boundsRect);
1467    Py_INCREF(Py_None);
1468    _res = Py_None;
1469    return _res;
1470}
1471
1472static PyObject *WinObj_ZoomWindow(WindowObject *_self, PyObject *_args)
1473{
1474    PyObject *_res = NULL;
1475    WindowPartCode partCode;
1476    Boolean front;
1477#ifndef ZoomWindow
1478    PyMac_PRECHECK(ZoomWindow);
1479#endif
1480    if (!PyArg_ParseTuple(_args, "hb",
1481                          &partCode,
1482                          &front))
1483        return NULL;
1484    ZoomWindow(_self->ob_itself,
1485               partCode,
1486               front);
1487    Py_INCREF(Py_None);
1488    _res = Py_None;
1489    return _res;
1490}
1491
1492static PyObject *WinObj_IsWindowCollapsable(WindowObject *_self, PyObject *_args)
1493{
1494    PyObject *_res = NULL;
1495    Boolean _rv;
1496#ifndef IsWindowCollapsable
1497    PyMac_PRECHECK(IsWindowCollapsable);
1498#endif
1499    if (!PyArg_ParseTuple(_args, ""))
1500        return NULL;
1501    _rv = IsWindowCollapsable(_self->ob_itself);
1502    _res = Py_BuildValue("b",
1503                         _rv);
1504    return _res;
1505}
1506
1507static PyObject *WinObj_IsWindowCollapsed(WindowObject *_self, PyObject *_args)
1508{
1509    PyObject *_res = NULL;
1510    Boolean _rv;
1511#ifndef IsWindowCollapsed
1512    PyMac_PRECHECK(IsWindowCollapsed);
1513#endif
1514    if (!PyArg_ParseTuple(_args, ""))
1515        return NULL;
1516    _rv = IsWindowCollapsed(_self->ob_itself);
1517    _res = Py_BuildValue("b",
1518                         _rv);
1519    return _res;
1520}
1521
1522static PyObject *WinObj_CollapseWindow(WindowObject *_self, PyObject *_args)
1523{
1524    PyObject *_res = NULL;
1525    OSStatus _err;
1526    Boolean collapse;
1527#ifndef CollapseWindow
1528    PyMac_PRECHECK(CollapseWindow);
1529#endif
1530    if (!PyArg_ParseTuple(_args, "b",
1531                          &collapse))
1532        return NULL;
1533    _err = CollapseWindow(_self->ob_itself,
1534                          collapse);
1535    if (_err != noErr) return PyMac_Error(_err);
1536    Py_INCREF(Py_None);
1537    _res = Py_None;
1538    return _res;
1539}
1540
1541static PyObject *WinObj_GetWindowBounds(WindowObject *_self, PyObject *_args)
1542{
1543    PyObject *_res = NULL;
1544    OSStatus _err;
1545    WindowRegionCode regionCode;
1546    Rect globalBounds;
1547#ifndef GetWindowBounds
1548    PyMac_PRECHECK(GetWindowBounds);
1549#endif
1550    if (!PyArg_ParseTuple(_args, "H",
1551                          &regionCode))
1552        return NULL;
1553    _err = GetWindowBounds(_self->ob_itself,
1554                           regionCode,
1555                           &globalBounds);
1556    if (_err != noErr) return PyMac_Error(_err);
1557    _res = Py_BuildValue("O&",
1558                         PyMac_BuildRect, &globalBounds);
1559    return _res;
1560}
1561
1562static PyObject *WinObj_ResizeWindow(WindowObject *_self, PyObject *_args)
1563{
1564    PyObject *_res = NULL;
1565    Boolean _rv;
1566    Point inStartPoint;
1567    Rect inSizeConstraints;
1568    Rect outNewContentRect;
1569#ifndef ResizeWindow
1570    PyMac_PRECHECK(ResizeWindow);
1571#endif
1572    if (!PyArg_ParseTuple(_args, "O&O&",
1573                          PyMac_GetPoint, &inStartPoint,
1574                          PyMac_GetRect, &inSizeConstraints))
1575        return NULL;
1576    _rv = ResizeWindow(_self->ob_itself,
1577                       inStartPoint,
1578                       &inSizeConstraints,
1579                       &outNewContentRect);
1580    _res = Py_BuildValue("bO&",
1581                         _rv,
1582                         PyMac_BuildRect, &outNewContentRect);
1583    return _res;
1584}
1585
1586static PyObject *WinObj_SetWindowBounds(WindowObject *_self, PyObject *_args)
1587{
1588    PyObject *_res = NULL;
1589    OSStatus _err;
1590    WindowRegionCode regionCode;
1591    Rect globalBounds;
1592#ifndef SetWindowBounds
1593    PyMac_PRECHECK(SetWindowBounds);
1594#endif
1595    if (!PyArg_ParseTuple(_args, "HO&",
1596                          &regionCode,
1597                          PyMac_GetRect, &globalBounds))
1598        return NULL;
1599    _err = SetWindowBounds(_self->ob_itself,
1600                           regionCode,
1601                           &globalBounds);
1602    if (_err != noErr) return PyMac_Error(_err);
1603    Py_INCREF(Py_None);
1604    _res = Py_None;
1605    return _res;
1606}
1607
1608static PyObject *WinObj_RepositionWindow(WindowObject *_self, PyObject *_args)
1609{
1610    PyObject *_res = NULL;
1611    OSStatus _err;
1612    WindowPtr parentWindow;
1613    WindowPositionMethod method;
1614#ifndef RepositionWindow
1615    PyMac_PRECHECK(RepositionWindow);
1616#endif
1617    if (!PyArg_ParseTuple(_args, "O&l",
1618                          WinObj_Convert, &parentWindow,
1619                          &method))
1620        return NULL;
1621    _err = RepositionWindow(_self->ob_itself,
1622                            parentWindow,
1623                            method);
1624    if (_err != noErr) return PyMac_Error(_err);
1625    Py_INCREF(Py_None);
1626    _res = Py_None;
1627    return _res;
1628}
1629
1630static PyObject *WinObj_MoveWindowStructure(WindowObject *_self, PyObject *_args)
1631{
1632    PyObject *_res = NULL;
1633    OSStatus _err;
1634    short hGlobal;
1635    short vGlobal;
1636#ifndef MoveWindowStructure
1637    PyMac_PRECHECK(MoveWindowStructure);
1638#endif
1639    if (!PyArg_ParseTuple(_args, "hh",
1640                          &hGlobal,
1641                          &vGlobal))
1642        return NULL;
1643    _err = MoveWindowStructure(_self->ob_itself,
1644                               hGlobal,
1645                               vGlobal);
1646    if (_err != noErr) return PyMac_Error(_err);
1647    Py_INCREF(Py_None);
1648    _res = Py_None;
1649    return _res;
1650}
1651
1652static PyObject *WinObj_IsWindowInStandardState(WindowObject *_self, PyObject *_args)
1653{
1654    PyObject *_res = NULL;
1655    Boolean _rv;
1656    Point inIdealSize;
1657    Rect outIdealStandardState;
1658#ifndef IsWindowInStandardState
1659    PyMac_PRECHECK(IsWindowInStandardState);
1660#endif
1661    if (!PyArg_ParseTuple(_args, "O&",
1662                          PyMac_GetPoint, &inIdealSize))
1663        return NULL;
1664    _rv = IsWindowInStandardState(_self->ob_itself,
1665                                  &inIdealSize,
1666                                  &outIdealStandardState);
1667    _res = Py_BuildValue("bO&",
1668                         _rv,
1669                         PyMac_BuildRect, &outIdealStandardState);
1670    return _res;
1671}
1672
1673static PyObject *WinObj_ZoomWindowIdeal(WindowObject *_self, PyObject *_args)
1674{
1675    PyObject *_res = NULL;
1676    OSStatus _err;
1677    WindowPartCode inPartCode;
1678    Point ioIdealSize;
1679#ifndef ZoomWindowIdeal
1680    PyMac_PRECHECK(ZoomWindowIdeal);
1681#endif
1682    if (!PyArg_ParseTuple(_args, "h",
1683                          &inPartCode))
1684        return NULL;
1685    _err = ZoomWindowIdeal(_self->ob_itself,
1686                           inPartCode,
1687                           &ioIdealSize);
1688    if (_err != noErr) return PyMac_Error(_err);
1689    _res = Py_BuildValue("O&",
1690                         PyMac_BuildPoint, ioIdealSize);
1691    return _res;
1692}
1693
1694static PyObject *WinObj_GetWindowIdealUserState(WindowObject *_self, PyObject *_args)
1695{
1696    PyObject *_res = NULL;
1697    OSStatus _err;
1698    Rect outUserState;
1699#ifndef GetWindowIdealUserState
1700    PyMac_PRECHECK(GetWindowIdealUserState);
1701#endif
1702    if (!PyArg_ParseTuple(_args, ""))
1703        return NULL;
1704    _err = GetWindowIdealUserState(_self->ob_itself,
1705                                   &outUserState);
1706    if (_err != noErr) return PyMac_Error(_err);
1707    _res = Py_BuildValue("O&",
1708                         PyMac_BuildRect, &outUserState);
1709    return _res;
1710}
1711
1712static PyObject *WinObj_SetWindowIdealUserState(WindowObject *_self, PyObject *_args)
1713{
1714    PyObject *_res = NULL;
1715    OSStatus _err;
1716    Rect inUserState;
1717#ifndef SetWindowIdealUserState
1718    PyMac_PRECHECK(SetWindowIdealUserState);
1719#endif
1720    if (!PyArg_ParseTuple(_args, "O&",
1721                          PyMac_GetRect, &inUserState))
1722        return NULL;
1723    _err = SetWindowIdealUserState(_self->ob_itself,
1724                                   &inUserState);
1725    if (_err != noErr) return PyMac_Error(_err);
1726    Py_INCREF(Py_None);
1727    _res = Py_None;
1728    return _res;
1729}
1730
1731static PyObject *WinObj_GetWindowGreatestAreaDevice(WindowObject *_self, PyObject *_args)
1732{
1733    PyObject *_res = NULL;
1734    OSStatus _err;
1735    WindowRegionCode inRegion;
1736    GDHandle outGreatestDevice;
1737    Rect outGreatestDeviceRect;
1738#ifndef GetWindowGreatestAreaDevice
1739    PyMac_PRECHECK(GetWindowGreatestAreaDevice);
1740#endif
1741    if (!PyArg_ParseTuple(_args, "H",
1742                          &inRegion))
1743        return NULL;
1744    _err = GetWindowGreatestAreaDevice(_self->ob_itself,
1745                                       inRegion,
1746                                       &outGreatestDevice,
1747                                       &outGreatestDeviceRect);
1748    if (_err != noErr) return PyMac_Error(_err);
1749    _res = Py_BuildValue("O&O&",
1750                         ResObj_New, outGreatestDevice,
1751                         PyMac_BuildRect, &outGreatestDeviceRect);
1752    return _res;
1753}
1754
1755static PyObject *WinObj_ConstrainWindowToScreen(WindowObject *_self, PyObject *_args)
1756{
1757    PyObject *_res = NULL;
1758    OSStatus _err;
1759    WindowRegionCode inRegionCode;
1760    WindowConstrainOptions inOptions;
1761    Rect inScreenRect;
1762    Rect outStructure;
1763#ifndef ConstrainWindowToScreen
1764    PyMac_PRECHECK(ConstrainWindowToScreen);
1765#endif
1766    if (!PyArg_ParseTuple(_args, "HlO&",
1767                          &inRegionCode,
1768                          &inOptions,
1769                          PyMac_GetRect, &inScreenRect))
1770        return NULL;
1771    _err = ConstrainWindowToScreen(_self->ob_itself,
1772                                   inRegionCode,
1773                                   inOptions,
1774                                   &inScreenRect,
1775                                   &outStructure);
1776    if (_err != noErr) return PyMac_Error(_err);
1777    _res = Py_BuildValue("O&",
1778                         PyMac_BuildRect, &outStructure);
1779    return _res;
1780}
1781
1782static PyObject *WinObj_HideWindow(WindowObject *_self, PyObject *_args)
1783{
1784    PyObject *_res = NULL;
1785#ifndef HideWindow
1786    PyMac_PRECHECK(HideWindow);
1787#endif
1788    if (!PyArg_ParseTuple(_args, ""))
1789        return NULL;
1790    HideWindow(_self->ob_itself);
1791    Py_INCREF(Py_None);
1792    _res = Py_None;
1793    return _res;
1794}
1795
1796static PyObject *WinObj_MacShowWindow(WindowObject *_self, PyObject *_args)
1797{
1798    PyObject *_res = NULL;
1799#ifndef MacShowWindow
1800    PyMac_PRECHECK(MacShowWindow);
1801#endif
1802    if (!PyArg_ParseTuple(_args, ""))
1803        return NULL;
1804    MacShowWindow(_self->ob_itself);
1805    Py_INCREF(Py_None);
1806    _res = Py_None;
1807    return _res;
1808}
1809
1810static PyObject *WinObj_ShowHide(WindowObject *_self, PyObject *_args)
1811{
1812    PyObject *_res = NULL;
1813    Boolean showFlag;
1814#ifndef ShowHide
1815    PyMac_PRECHECK(ShowHide);
1816#endif
1817    if (!PyArg_ParseTuple(_args, "b",
1818                          &showFlag))
1819        return NULL;
1820    ShowHide(_self->ob_itself,
1821             showFlag);
1822    Py_INCREF(Py_None);
1823    _res = Py_None;
1824    return _res;
1825}
1826
1827static PyObject *WinObj_MacIsWindowVisible(WindowObject *_self, PyObject *_args)
1828{
1829    PyObject *_res = NULL;
1830    Boolean _rv;
1831#ifndef MacIsWindowVisible
1832    PyMac_PRECHECK(MacIsWindowVisible);
1833#endif
1834    if (!PyArg_ParseTuple(_args, ""))
1835        return NULL;
1836    _rv = MacIsWindowVisible(_self->ob_itself);
1837    _res = Py_BuildValue("b",
1838                         _rv);
1839    return _res;
1840}
1841
1842static PyObject *WinObj_ShowSheetWindow(WindowObject *_self, PyObject *_args)
1843{
1844    PyObject *_res = NULL;
1845    OSStatus _err;
1846    WindowPtr inParentWindow;
1847#ifndef ShowSheetWindow
1848    PyMac_PRECHECK(ShowSheetWindow);
1849#endif
1850    if (!PyArg_ParseTuple(_args, "O&",
1851                          WinObj_Convert, &inParentWindow))
1852        return NULL;
1853    _err = ShowSheetWindow(_self->ob_itself,
1854                           inParentWindow);
1855    if (_err != noErr) return PyMac_Error(_err);
1856    Py_INCREF(Py_None);
1857    _res = Py_None;
1858    return _res;
1859}
1860
1861static PyObject *WinObj_HideSheetWindow(WindowObject *_self, PyObject *_args)
1862{
1863    PyObject *_res = NULL;
1864    OSStatus _err;
1865#ifndef HideSheetWindow
1866    PyMac_PRECHECK(HideSheetWindow);
1867#endif
1868    if (!PyArg_ParseTuple(_args, ""))
1869        return NULL;
1870    _err = HideSheetWindow(_self->ob_itself);
1871    if (_err != noErr) return PyMac_Error(_err);
1872    Py_INCREF(Py_None);
1873    _res = Py_None;
1874    return _res;
1875}
1876
1877static PyObject *WinObj_GetSheetWindowParent(WindowObject *_self, PyObject *_args)
1878{
1879    PyObject *_res = NULL;
1880    OSStatus _err;
1881    WindowPtr outParentWindow;
1882#ifndef GetSheetWindowParent
1883    PyMac_PRECHECK(GetSheetWindowParent);
1884#endif
1885    if (!PyArg_ParseTuple(_args, ""))
1886        return NULL;
1887    _err = GetSheetWindowParent(_self->ob_itself,
1888                                &outParentWindow);
1889    if (_err != noErr) return PyMac_Error(_err);
1890    _res = Py_BuildValue("O&",
1891                         WinObj_WhichWindow, outParentWindow);
1892    return _res;
1893}
1894
1895static PyObject *WinObj_GetWindowPropertyAttributes(WindowObject *_self, PyObject *_args)
1896{
1897    PyObject *_res = NULL;
1898    OSStatus _err;
1899    OSType propertyCreator;
1900    OSType propertyTag;
1901    UInt32 attributes;
1902#ifndef GetWindowPropertyAttributes
1903    PyMac_PRECHECK(GetWindowPropertyAttributes);
1904#endif
1905    if (!PyArg_ParseTuple(_args, "O&O&",
1906                          PyMac_GetOSType, &propertyCreator,
1907                          PyMac_GetOSType, &propertyTag))
1908        return NULL;
1909    _err = GetWindowPropertyAttributes(_self->ob_itself,
1910                                       propertyCreator,
1911                                       propertyTag,
1912                                       &attributes);
1913    if (_err != noErr) return PyMac_Error(_err);
1914    _res = Py_BuildValue("l",
1915                         attributes);
1916    return _res;
1917}
1918
1919static PyObject *WinObj_ChangeWindowPropertyAttributes(WindowObject *_self, PyObject *_args)
1920{
1921    PyObject *_res = NULL;
1922    OSStatus _err;
1923    OSType propertyCreator;
1924    OSType propertyTag;
1925    UInt32 attributesToSet;
1926    UInt32 attributesToClear;
1927#ifndef ChangeWindowPropertyAttributes
1928    PyMac_PRECHECK(ChangeWindowPropertyAttributes);
1929#endif
1930    if (!PyArg_ParseTuple(_args, "O&O&ll",
1931                          PyMac_GetOSType, &propertyCreator,
1932                          PyMac_GetOSType, &propertyTag,
1933                          &attributesToSet,
1934                          &attributesToClear))
1935        return NULL;
1936    _err = ChangeWindowPropertyAttributes(_self->ob_itself,
1937                                          propertyCreator,
1938                                          propertyTag,
1939                                          attributesToSet,
1940                                          attributesToClear);
1941    if (_err != noErr) return PyMac_Error(_err);
1942    Py_INCREF(Py_None);
1943    _res = Py_None;
1944    return _res;
1945}
1946
1947static PyObject *WinObj_TrackBox(WindowObject *_self, PyObject *_args)
1948{
1949    PyObject *_res = NULL;
1950    Boolean _rv;
1951    Point thePt;
1952    WindowPartCode partCode;
1953#ifndef TrackBox
1954    PyMac_PRECHECK(TrackBox);
1955#endif
1956    if (!PyArg_ParseTuple(_args, "O&h",
1957                          PyMac_GetPoint, &thePt,
1958                          &partCode))
1959        return NULL;
1960    _rv = TrackBox(_self->ob_itself,
1961                   thePt,
1962                   partCode);
1963    _res = Py_BuildValue("b",
1964                         _rv);
1965    return _res;
1966}
1967
1968static PyObject *WinObj_TrackGoAway(WindowObject *_self, PyObject *_args)
1969{
1970    PyObject *_res = NULL;
1971    Boolean _rv;
1972    Point thePt;
1973#ifndef TrackGoAway
1974    PyMac_PRECHECK(TrackGoAway);
1975#endif
1976    if (!PyArg_ParseTuple(_args, "O&",
1977                          PyMac_GetPoint, &thePt))
1978        return NULL;
1979    _rv = TrackGoAway(_self->ob_itself,
1980                      thePt);
1981    _res = Py_BuildValue("b",
1982                         _rv);
1983    return _res;
1984}
1985
1986static PyObject *WinObj_GetWindowPort(WindowObject *_self, PyObject *_args)
1987{
1988    PyObject *_res = NULL;
1989    CGrafPtr _rv;
1990#ifndef GetWindowPort
1991    PyMac_PRECHECK(GetWindowPort);
1992#endif
1993    if (!PyArg_ParseTuple(_args, ""))
1994        return NULL;
1995    _rv = GetWindowPort(_self->ob_itself);
1996    _res = Py_BuildValue("O&",
1997                         GrafObj_New, _rv);
1998    return _res;
1999}
2000
2001static PyObject *WinObj_GetWindowStructurePort(WindowObject *_self, PyObject *_args)
2002{
2003    PyObject *_res = NULL;
2004    CGrafPtr _rv;
2005#ifndef GetWindowStructurePort
2006    PyMac_PRECHECK(GetWindowStructurePort);
2007#endif
2008    if (!PyArg_ParseTuple(_args, ""))
2009        return NULL;
2010    _rv = GetWindowStructurePort(_self->ob_itself);
2011    _res = Py_BuildValue("O&",
2012                         GrafObj_New, _rv);
2013    return _res;
2014}
2015
2016static PyObject *WinObj_GetWindowKind(WindowObject *_self, PyObject *_args)
2017{
2018    PyObject *_res = NULL;
2019    short _rv;
2020#ifndef GetWindowKind
2021    PyMac_PRECHECK(GetWindowKind);
2022#endif
2023    if (!PyArg_ParseTuple(_args, ""))
2024        return NULL;
2025    _rv = GetWindowKind(_self->ob_itself);
2026    _res = Py_BuildValue("h",
2027                         _rv);
2028    return _res;
2029}
2030
2031static PyObject *WinObj_IsWindowHilited(WindowObject *_self, PyObject *_args)
2032{
2033    PyObject *_res = NULL;
2034    Boolean _rv;
2035#ifndef IsWindowHilited
2036    PyMac_PRECHECK(IsWindowHilited);
2037#endif
2038    if (!PyArg_ParseTuple(_args, ""))
2039        return NULL;
2040    _rv = IsWindowHilited(_self->ob_itself);
2041    _res = Py_BuildValue("b",
2042                         _rv);
2043    return _res;
2044}
2045
2046static PyObject *WinObj_IsWindowUpdatePending(WindowObject *_self, PyObject *_args)
2047{
2048    PyObject *_res = NULL;
2049    Boolean _rv;
2050#ifndef IsWindowUpdatePending
2051    PyMac_PRECHECK(IsWindowUpdatePending);
2052#endif
2053    if (!PyArg_ParseTuple(_args, ""))
2054        return NULL;
2055    _rv = IsWindowUpdatePending(_self->ob_itself);
2056    _res = Py_BuildValue("b",
2057                         _rv);
2058    return _res;
2059}
2060
2061static PyObject *WinObj_MacGetNextWindow(WindowObject *_self, PyObject *_args)
2062{
2063    PyObject *_res = NULL;
2064    WindowPtr _rv;
2065#ifndef MacGetNextWindow
2066    PyMac_PRECHECK(MacGetNextWindow);
2067#endif
2068    if (!PyArg_ParseTuple(_args, ""))
2069        return NULL;
2070    _rv = MacGetNextWindow(_self->ob_itself);
2071    _res = Py_BuildValue("O&",
2072                         WinObj_New, _rv);
2073    return _res;
2074}
2075
2076static PyObject *WinObj_GetWindowStandardState(WindowObject *_self, PyObject *_args)
2077{
2078    PyObject *_res = NULL;
2079    Rect rect;
2080#ifndef GetWindowStandardState
2081    PyMac_PRECHECK(GetWindowStandardState);
2082#endif
2083    if (!PyArg_ParseTuple(_args, ""))
2084        return NULL;
2085    GetWindowStandardState(_self->ob_itself,
2086                           &rect);
2087    _res = Py_BuildValue("O&",
2088                         PyMac_BuildRect, &rect);
2089    return _res;
2090}
2091
2092static PyObject *WinObj_GetWindowUserState(WindowObject *_self, PyObject *_args)
2093{
2094    PyObject *_res = NULL;
2095    Rect rect;
2096#ifndef GetWindowUserState
2097    PyMac_PRECHECK(GetWindowUserState);
2098#endif
2099    if (!PyArg_ParseTuple(_args, ""))
2100        return NULL;
2101    GetWindowUserState(_self->ob_itself,
2102                       &rect);
2103    _res = Py_BuildValue("O&",
2104                         PyMac_BuildRect, &rect);
2105    return _res;
2106}
2107
2108static PyObject *WinObj_SetWindowKind(WindowObject *_self, PyObject *_args)
2109{
2110    PyObject *_res = NULL;
2111    short kind;
2112#ifndef SetWindowKind
2113    PyMac_PRECHECK(SetWindowKind);
2114#endif
2115    if (!PyArg_ParseTuple(_args, "h",
2116                          &kind))
2117        return NULL;
2118    SetWindowKind(_self->ob_itself,
2119                  kind);
2120    Py_INCREF(Py_None);
2121    _res = Py_None;
2122    return _res;
2123}
2124
2125static PyObject *WinObj_SetWindowStandardState(WindowObject *_self, PyObject *_args)
2126{
2127    PyObject *_res = NULL;
2128    Rect rect;
2129#ifndef SetWindowStandardState
2130    PyMac_PRECHECK(SetWindowStandardState);
2131#endif
2132    if (!PyArg_ParseTuple(_args, "O&",
2133                          PyMac_GetRect, &rect))
2134        return NULL;
2135    SetWindowStandardState(_self->ob_itself,
2136                           &rect);
2137    Py_INCREF(Py_None);
2138    _res = Py_None;
2139    return _res;
2140}
2141
2142static PyObject *WinObj_SetWindowUserState(WindowObject *_self, PyObject *_args)
2143{
2144    PyObject *_res = NULL;
2145    Rect rect;
2146#ifndef SetWindowUserState
2147    PyMac_PRECHECK(SetWindowUserState);
2148#endif
2149    if (!PyArg_ParseTuple(_args, "O&",
2150                          PyMac_GetRect, &rect))
2151        return NULL;
2152    SetWindowUserState(_self->ob_itself,
2153                       &rect);
2154    Py_INCREF(Py_None);
2155    _res = Py_None;
2156    return _res;
2157}
2158
2159static PyObject *WinObj_SetPortWindowPort(WindowObject *_self, PyObject *_args)
2160{
2161    PyObject *_res = NULL;
2162#ifndef SetPortWindowPort
2163    PyMac_PRECHECK(SetPortWindowPort);
2164#endif
2165    if (!PyArg_ParseTuple(_args, ""))
2166        return NULL;
2167    SetPortWindowPort(_self->ob_itself);
2168    Py_INCREF(Py_None);
2169    _res = Py_None;
2170    return _res;
2171}
2172
2173static PyObject *WinObj_GetWindowPortBounds(WindowObject *_self, PyObject *_args)
2174{
2175    PyObject *_res = NULL;
2176    Rect bounds;
2177#ifndef GetWindowPortBounds
2178    PyMac_PRECHECK(GetWindowPortBounds);
2179#endif
2180    if (!PyArg_ParseTuple(_args, ""))
2181        return NULL;
2182    GetWindowPortBounds(_self->ob_itself,
2183                        &bounds);
2184    _res = Py_BuildValue("O&",
2185                         PyMac_BuildRect, &bounds);
2186    return _res;
2187}
2188
2189static PyObject *WinObj_IsWindowVisible(WindowObject *_self, PyObject *_args)
2190{
2191    PyObject *_res = NULL;
2192    Boolean _rv;
2193#ifndef IsWindowVisible
2194    PyMac_PRECHECK(IsWindowVisible);
2195#endif
2196    if (!PyArg_ParseTuple(_args, ""))
2197        return NULL;
2198    _rv = IsWindowVisible(_self->ob_itself);
2199    _res = Py_BuildValue("b",
2200                         _rv);
2201    return _res;
2202}
2203
2204static PyObject *WinObj_GetWindowStructureRgn(WindowObject *_self, PyObject *_args)
2205{
2206    PyObject *_res = NULL;
2207    RgnHandle r;
2208#ifndef GetWindowStructureRgn
2209    PyMac_PRECHECK(GetWindowStructureRgn);
2210#endif
2211    if (!PyArg_ParseTuple(_args, "O&",
2212                          ResObj_Convert, &r))
2213        return NULL;
2214    GetWindowStructureRgn(_self->ob_itself,
2215                          r);
2216    Py_INCREF(Py_None);
2217    _res = Py_None;
2218    return _res;
2219}
2220
2221static PyObject *WinObj_GetWindowContentRgn(WindowObject *_self, PyObject *_args)
2222{
2223    PyObject *_res = NULL;
2224    RgnHandle r;
2225#ifndef GetWindowContentRgn
2226    PyMac_PRECHECK(GetWindowContentRgn);
2227#endif
2228    if (!PyArg_ParseTuple(_args, "O&",
2229                          ResObj_Convert, &r))
2230        return NULL;
2231    GetWindowContentRgn(_self->ob_itself,
2232                        r);
2233    Py_INCREF(Py_None);
2234    _res = Py_None;
2235    return _res;
2236}
2237
2238static PyObject *WinObj_GetWindowUpdateRgn(WindowObject *_self, PyObject *_args)
2239{
2240    PyObject *_res = NULL;
2241    RgnHandle r;
2242#ifndef GetWindowUpdateRgn
2243    PyMac_PRECHECK(GetWindowUpdateRgn);
2244#endif
2245    if (!PyArg_ParseTuple(_args, "O&",
2246                          ResObj_Convert, &r))
2247        return NULL;
2248    GetWindowUpdateRgn(_self->ob_itself,
2249                       r);
2250    Py_INCREF(Py_None);
2251    _res = Py_None;
2252    return _res;
2253}
2254
2255static PyObject *WinObj_GetNextWindow(WindowObject *_self, PyObject *_args)
2256{
2257    PyObject *_res = NULL;
2258    WindowPtr _rv;
2259#ifndef GetNextWindow
2260    PyMac_PRECHECK(GetNextWindow);
2261#endif
2262    if (!PyArg_ParseTuple(_args, ""))
2263        return NULL;
2264    _rv = GetNextWindow(_self->ob_itself);
2265    _res = Py_BuildValue("O&",
2266                         WinObj_WhichWindow, _rv);
2267    return _res;
2268}
2269
2270static PyObject *WinObj_MoveWindow(WindowObject *_self, PyObject *_args)
2271{
2272    PyObject *_res = NULL;
2273    short hGlobal;
2274    short vGlobal;
2275    Boolean front;
2276#ifndef MoveWindow
2277    PyMac_PRECHECK(MoveWindow);
2278#endif
2279    if (!PyArg_ParseTuple(_args, "hhb",
2280                          &hGlobal,
2281                          &vGlobal,
2282                          &front))
2283        return NULL;
2284    MoveWindow(_self->ob_itself,
2285               hGlobal,
2286               vGlobal,
2287               front);
2288    Py_INCREF(Py_None);
2289    _res = Py_None;
2290    return _res;
2291}
2292
2293static PyObject *WinObj_ShowWindow(WindowObject *_self, PyObject *_args)
2294{
2295    PyObject *_res = NULL;
2296#ifndef ShowWindow
2297    PyMac_PRECHECK(ShowWindow);
2298#endif
2299    if (!PyArg_ParseTuple(_args, ""))
2300        return NULL;
2301    ShowWindow(_self->ob_itself);
2302    Py_INCREF(Py_None);
2303    _res = Py_None;
2304    return _res;
2305}
2306
2307static PyObject *WinObj_AutoDispose(WindowObject *_self, PyObject *_args)
2308{
2309    PyObject *_res = NULL;
2310
2311    int onoff, old = 0;
2312    if (!PyArg_ParseTuple(_args, "i", &onoff))
2313        return NULL;
2314    if ( _self->ob_freeit )
2315        old = 1;
2316    if ( onoff )
2317        _self->ob_freeit = PyMac_AutoDisposeWindow;
2318    else
2319        _self->ob_freeit = NULL;
2320    _res = Py_BuildValue("i", old);
2321    return _res;
2322
2323}
2324
2325static PyMethodDef WinObj_methods[] = {
2326    {"GetWindowOwnerCount", (PyCFunction)WinObj_GetWindowOwnerCount, 1,
2327     PyDoc_STR("() -> (UInt32 outCount)")},
2328    {"CloneWindow", (PyCFunction)WinObj_CloneWindow, 1,
2329     PyDoc_STR("() -> None")},
2330    {"GetWindowRetainCount", (PyCFunction)WinObj_GetWindowRetainCount, 1,
2331     PyDoc_STR("() -> (ItemCount _rv)")},
2332    {"RetainWindow", (PyCFunction)WinObj_RetainWindow, 1,
2333     PyDoc_STR("() -> None")},
2334    {"ReleaseWindow", (PyCFunction)WinObj_ReleaseWindow, 1,
2335     PyDoc_STR("() -> None")},
2336    {"ReshapeCustomWindow", (PyCFunction)WinObj_ReshapeCustomWindow, 1,
2337     PyDoc_STR("() -> None")},
2338    {"GetWindowWidgetHilite", (PyCFunction)WinObj_GetWindowWidgetHilite, 1,
2339     PyDoc_STR("() -> (WindowDefPartCode outHilite)")},
2340    {"GetWindowClass", (PyCFunction)WinObj_GetWindowClass, 1,
2341     PyDoc_STR("() -> (WindowClass outClass)")},
2342    {"GetWindowAttributes", (PyCFunction)WinObj_GetWindowAttributes, 1,
2343     PyDoc_STR("() -> (WindowAttributes outAttributes)")},
2344    {"ChangeWindowAttributes", (PyCFunction)WinObj_ChangeWindowAttributes, 1,
2345     PyDoc_STR("(WindowAttributes setTheseAttributes, WindowAttributes clearTheseAttributes) -> None")},
2346    {"SetWindowClass", (PyCFunction)WinObj_SetWindowClass, 1,
2347     PyDoc_STR("(WindowClass inWindowClass) -> None")},
2348    {"SetWindowModality", (PyCFunction)WinObj_SetWindowModality, 1,
2349     PyDoc_STR("(WindowModality inModalKind, WindowPtr inUnavailableWindow) -> None")},
2350    {"GetWindowModality", (PyCFunction)WinObj_GetWindowModality, 1,
2351     PyDoc_STR("() -> (WindowModality outModalKind, WindowPtr outUnavailableWindow)")},
2352    {"SetWindowContentColor", (PyCFunction)WinObj_SetWindowContentColor, 1,
2353     PyDoc_STR("(RGBColor color) -> None")},
2354    {"GetWindowContentColor", (PyCFunction)WinObj_GetWindowContentColor, 1,
2355     PyDoc_STR("() -> (RGBColor color)")},
2356    {"GetWindowContentPattern", (PyCFunction)WinObj_GetWindowContentPattern, 1,
2357     PyDoc_STR("(PixPatHandle outPixPat) -> None")},
2358    {"SetWindowContentPattern", (PyCFunction)WinObj_SetWindowContentPattern, 1,
2359     PyDoc_STR("(PixPatHandle pixPat) -> None")},
2360    {"ScrollWindowRect", (PyCFunction)WinObj_ScrollWindowRect, 1,
2361     PyDoc_STR("(Rect inScrollRect, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None")},
2362    {"ScrollWindowRegion", (PyCFunction)WinObj_ScrollWindowRegion, 1,
2363     PyDoc_STR("(RgnHandle inScrollRgn, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None")},
2364    {"ClipAbove", (PyCFunction)WinObj_ClipAbove, 1,
2365     PyDoc_STR("() -> None")},
2366    {"PaintOne", (PyCFunction)WinObj_PaintOne, 1,
2367     PyDoc_STR("(RgnHandle clobberedRgn) -> None")},
2368    {"PaintBehind", (PyCFunction)WinObj_PaintBehind, 1,
2369     PyDoc_STR("(RgnHandle clobberedRgn) -> None")},
2370    {"CalcVis", (PyCFunction)WinObj_CalcVis, 1,
2371     PyDoc_STR("() -> None")},
2372    {"CalcVisBehind", (PyCFunction)WinObj_CalcVisBehind, 1,
2373     PyDoc_STR("(RgnHandle clobberedRgn) -> None")},
2374    {"BringToFront", (PyCFunction)WinObj_BringToFront, 1,
2375     PyDoc_STR("() -> None")},
2376    {"SendBehind", (PyCFunction)WinObj_SendBehind, 1,
2377     PyDoc_STR("(WindowPtr behindWindow) -> None")},
2378    {"SelectWindow", (PyCFunction)WinObj_SelectWindow, 1,
2379     PyDoc_STR("() -> None")},
2380    {"GetNextWindowOfClass", (PyCFunction)WinObj_GetNextWindowOfClass, 1,
2381     PyDoc_STR("(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)")},
2382    {"SetWindowAlternateTitle", (PyCFunction)WinObj_SetWindowAlternateTitle, 1,
2383     PyDoc_STR("(CFStringRef inTitle) -> None")},
2384    {"CopyWindowAlternateTitle", (PyCFunction)WinObj_CopyWindowAlternateTitle, 1,
2385     PyDoc_STR("() -> (CFStringRef outTitle)")},
2386    {"HiliteWindow", (PyCFunction)WinObj_HiliteWindow, 1,
2387     PyDoc_STR("(Boolean fHilite) -> None")},
2388    {"SetWRefCon", (PyCFunction)WinObj_SetWRefCon, 1,
2389     PyDoc_STR("(long data) -> None")},
2390    {"GetWRefCon", (PyCFunction)WinObj_GetWRefCon, 1,
2391     PyDoc_STR("() -> (long _rv)")},
2392    {"SetWindowPic", (PyCFunction)WinObj_SetWindowPic, 1,
2393     PyDoc_STR("(PicHandle pic) -> None")},
2394    {"GetWindowPic", (PyCFunction)WinObj_GetWindowPic, 1,
2395     PyDoc_STR("() -> (PicHandle _rv)")},
2396    {"GetWVariant", (PyCFunction)WinObj_GetWVariant, 1,
2397     PyDoc_STR("() -> (short _rv)")},
2398    {"GetWindowFeatures", (PyCFunction)WinObj_GetWindowFeatures, 1,
2399     PyDoc_STR("() -> (UInt32 outFeatures)")},
2400    {"GetWindowRegion", (PyCFunction)WinObj_GetWindowRegion, 1,
2401     PyDoc_STR("(WindowRegionCode inRegionCode, RgnHandle ioWinRgn) -> None")},
2402    {"GetWindowStructureWidths", (PyCFunction)WinObj_GetWindowStructureWidths, 1,
2403     PyDoc_STR("() -> (Rect outRect)")},
2404    {"BeginUpdate", (PyCFunction)WinObj_BeginUpdate, 1,
2405     PyDoc_STR("() -> None")},
2406    {"EndUpdate", (PyCFunction)WinObj_EndUpdate, 1,
2407     PyDoc_STR("() -> None")},
2408    {"InvalWindowRgn", (PyCFunction)WinObj_InvalWindowRgn, 1,
2409     PyDoc_STR("(RgnHandle region) -> None")},
2410    {"InvalWindowRect", (PyCFunction)WinObj_InvalWindowRect, 1,
2411     PyDoc_STR("(Rect bounds) -> None")},
2412    {"ValidWindowRgn", (PyCFunction)WinObj_ValidWindowRgn, 1,
2413     PyDoc_STR("(RgnHandle region) -> None")},
2414    {"ValidWindowRect", (PyCFunction)WinObj_ValidWindowRect, 1,
2415     PyDoc_STR("(Rect bounds) -> None")},
2416    {"DrawGrowIcon", (PyCFunction)WinObj_DrawGrowIcon, 1,
2417     PyDoc_STR("() -> None")},
2418    {"SetWTitle", (PyCFunction)WinObj_SetWTitle, 1,
2419     PyDoc_STR("(Str255 title) -> None")},
2420    {"GetWTitle", (PyCFunction)WinObj_GetWTitle, 1,
2421     PyDoc_STR("() -> (Str255 title)")},
2422    {"SetWindowTitleWithCFString", (PyCFunction)WinObj_SetWindowTitleWithCFString, 1,
2423     PyDoc_STR("(CFStringRef inString) -> None")},
2424    {"CopyWindowTitleAsCFString", (PyCFunction)WinObj_CopyWindowTitleAsCFString, 1,
2425     PyDoc_STR("() -> (CFStringRef outString)")},
2426    {"SetWindowProxyFSSpec", (PyCFunction)WinObj_SetWindowProxyFSSpec, 1,
2427     PyDoc_STR("(FSSpec inFile) -> None")},
2428    {"GetWindowProxyFSSpec", (PyCFunction)WinObj_GetWindowProxyFSSpec, 1,
2429     PyDoc_STR("() -> (FSSpec outFile)")},
2430    {"SetWindowProxyAlias", (PyCFunction)WinObj_SetWindowProxyAlias, 1,
2431     PyDoc_STR("(AliasHandle inAlias) -> None")},
2432    {"GetWindowProxyAlias", (PyCFunction)WinObj_GetWindowProxyAlias, 1,
2433     PyDoc_STR("() -> (AliasHandle alias)")},
2434    {"SetWindowProxyCreatorAndType", (PyCFunction)WinObj_SetWindowProxyCreatorAndType, 1,
2435     PyDoc_STR("(OSType fileCreator, OSType fileType, SInt16 vRefNum) -> None")},
2436    {"GetWindowProxyIcon", (PyCFunction)WinObj_GetWindowProxyIcon, 1,
2437     PyDoc_STR("() -> (IconRef outIcon)")},
2438    {"SetWindowProxyIcon", (PyCFunction)WinObj_SetWindowProxyIcon, 1,
2439     PyDoc_STR("(IconRef icon) -> None")},
2440    {"RemoveWindowProxy", (PyCFunction)WinObj_RemoveWindowProxy, 1,
2441     PyDoc_STR("() -> None")},
2442    {"BeginWindowProxyDrag", (PyCFunction)WinObj_BeginWindowProxyDrag, 1,
2443     PyDoc_STR("(RgnHandle outDragOutlineRgn) -> (DragReference outNewDrag)")},
2444    {"EndWindowProxyDrag", (PyCFunction)WinObj_EndWindowProxyDrag, 1,
2445     PyDoc_STR("(DragReference theDrag) -> None")},
2446    {"TrackWindowProxyFromExistingDrag", (PyCFunction)WinObj_TrackWindowProxyFromExistingDrag, 1,
2447     PyDoc_STR("(Point startPt, DragReference drag, RgnHandle inDragOutlineRgn) -> None")},
2448    {"TrackWindowProxyDrag", (PyCFunction)WinObj_TrackWindowProxyDrag, 1,
2449     PyDoc_STR("(Point startPt) -> None")},
2450    {"IsWindowModified", (PyCFunction)WinObj_IsWindowModified, 1,
2451     PyDoc_STR("() -> (Boolean _rv)")},
2452    {"SetWindowModified", (PyCFunction)WinObj_SetWindowModified, 1,
2453     PyDoc_STR("(Boolean modified) -> None")},
2454    {"IsWindowPathSelectClick", (PyCFunction)WinObj_IsWindowPathSelectClick, 1,
2455     PyDoc_STR("(EventRecord event) -> (Boolean _rv)")},
2456    {"WindowPathSelect", (PyCFunction)WinObj_WindowPathSelect, 1,
2457     PyDoc_STR("(MenuHandle menu) -> (SInt32 outMenuResult)")},
2458    {"HiliteWindowFrameForDrag", (PyCFunction)WinObj_HiliteWindowFrameForDrag, 1,
2459     PyDoc_STR("(Boolean hilited) -> None")},
2460    {"TransitionWindow", (PyCFunction)WinObj_TransitionWindow, 1,
2461     PyDoc_STR("(WindowTransitionEffect inEffect, WindowTransitionAction inAction, Rect inRect) -> None")},
2462    {"TransitionWindowAndParent", (PyCFunction)WinObj_TransitionWindowAndParent, 1,
2463     PyDoc_STR("(WindowPtr inParentWindow, WindowTransitionEffect inEffect, WindowTransitionAction inAction, Rect inRect) -> None")},
2464    {"MacMoveWindow", (PyCFunction)WinObj_MacMoveWindow, 1,
2465     PyDoc_STR("(short hGlobal, short vGlobal, Boolean front) -> None")},
2466    {"SizeWindow", (PyCFunction)WinObj_SizeWindow, 1,
2467     PyDoc_STR("(short w, short h, Boolean fUpdate) -> None")},
2468    {"GrowWindow", (PyCFunction)WinObj_GrowWindow, 1,
2469     PyDoc_STR("(Point startPt, Rect bBox) -> (long _rv)")},
2470    {"DragWindow", (PyCFunction)WinObj_DragWindow, 1,
2471     PyDoc_STR("(Point startPt, Rect boundsRect) -> None")},
2472    {"ZoomWindow", (PyCFunction)WinObj_ZoomWindow, 1,
2473     PyDoc_STR("(WindowPartCode partCode, Boolean front) -> None")},
2474    {"IsWindowCollapsable", (PyCFunction)WinObj_IsWindowCollapsable, 1,
2475     PyDoc_STR("() -> (Boolean _rv)")},
2476    {"IsWindowCollapsed", (PyCFunction)WinObj_IsWindowCollapsed, 1,
2477     PyDoc_STR("() -> (Boolean _rv)")},
2478    {"CollapseWindow", (PyCFunction)WinObj_CollapseWindow, 1,
2479     PyDoc_STR("(Boolean collapse) -> None")},
2480    {"GetWindowBounds", (PyCFunction)WinObj_GetWindowBounds, 1,
2481     PyDoc_STR("(WindowRegionCode regionCode) -> (Rect globalBounds)")},
2482    {"ResizeWindow", (PyCFunction)WinObj_ResizeWindow, 1,
2483     PyDoc_STR("(Point inStartPoint, Rect inSizeConstraints) -> (Boolean _rv, Rect outNewContentRect)")},
2484    {"SetWindowBounds", (PyCFunction)WinObj_SetWindowBounds, 1,
2485     PyDoc_STR("(WindowRegionCode regionCode, Rect globalBounds) -> None")},
2486    {"RepositionWindow", (PyCFunction)WinObj_RepositionWindow, 1,
2487     PyDoc_STR("(WindowPtr parentWindow, WindowPositionMethod method) -> None")},
2488    {"MoveWindowStructure", (PyCFunction)WinObj_MoveWindowStructure, 1,
2489     PyDoc_STR("(short hGlobal, short vGlobal) -> None")},
2490    {"IsWindowInStandardState", (PyCFunction)WinObj_IsWindowInStandardState, 1,
2491     PyDoc_STR("(Point inIdealSize) -> (Boolean _rv, Rect outIdealStandardState)")},
2492    {"ZoomWindowIdeal", (PyCFunction)WinObj_ZoomWindowIdeal, 1,
2493     PyDoc_STR("(WindowPartCode inPartCode) -> (Point ioIdealSize)")},
2494    {"GetWindowIdealUserState", (PyCFunction)WinObj_GetWindowIdealUserState, 1,
2495     PyDoc_STR("() -> (Rect outUserState)")},
2496    {"SetWindowIdealUserState", (PyCFunction)WinObj_SetWindowIdealUserState, 1,
2497     PyDoc_STR("(Rect inUserState) -> None")},
2498    {"GetWindowGreatestAreaDevice", (PyCFunction)WinObj_GetWindowGreatestAreaDevice, 1,
2499     PyDoc_STR("(WindowRegionCode inRegion) -> (GDHandle outGreatestDevice, Rect outGreatestDeviceRect)")},
2500    {"ConstrainWindowToScreen", (PyCFunction)WinObj_ConstrainWindowToScreen, 1,
2501     PyDoc_STR("(WindowRegionCode inRegionCode, WindowConstrainOptions inOptions, Rect inScreenRect) -> (Rect outStructure)")},
2502    {"HideWindow", (PyCFunction)WinObj_HideWindow, 1,
2503     PyDoc_STR("() -> None")},
2504    {"MacShowWindow", (PyCFunction)WinObj_MacShowWindow, 1,
2505     PyDoc_STR("() -> None")},
2506    {"ShowHide", (PyCFunction)WinObj_ShowHide, 1,
2507     PyDoc_STR("(Boolean showFlag) -> None")},
2508    {"MacIsWindowVisible", (PyCFunction)WinObj_MacIsWindowVisible, 1,
2509     PyDoc_STR("() -> (Boolean _rv)")},
2510    {"ShowSheetWindow", (PyCFunction)WinObj_ShowSheetWindow, 1,
2511     PyDoc_STR("(WindowPtr inParentWindow) -> None")},
2512    {"HideSheetWindow", (PyCFunction)WinObj_HideSheetWindow, 1,
2513     PyDoc_STR("() -> None")},
2514    {"GetSheetWindowParent", (PyCFunction)WinObj_GetSheetWindowParent, 1,
2515     PyDoc_STR("() -> (WindowPtr outParentWindow)")},
2516    {"GetWindowPropertyAttributes", (PyCFunction)WinObj_GetWindowPropertyAttributes, 1,
2517     PyDoc_STR("(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)")},
2518    {"ChangeWindowPropertyAttributes", (PyCFunction)WinObj_ChangeWindowPropertyAttributes, 1,
2519     PyDoc_STR("(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None")},
2520    {"TrackBox", (PyCFunction)WinObj_TrackBox, 1,
2521     PyDoc_STR("(Point thePt, WindowPartCode partCode) -> (Boolean _rv)")},
2522    {"TrackGoAway", (PyCFunction)WinObj_TrackGoAway, 1,
2523     PyDoc_STR("(Point thePt) -> (Boolean _rv)")},
2524    {"GetWindowPort", (PyCFunction)WinObj_GetWindowPort, 1,
2525     PyDoc_STR("() -> (CGrafPtr _rv)")},
2526    {"GetWindowStructurePort", (PyCFunction)WinObj_GetWindowStructurePort, 1,
2527     PyDoc_STR("() -> (CGrafPtr _rv)")},
2528    {"GetWindowKind", (PyCFunction)WinObj_GetWindowKind, 1,
2529     PyDoc_STR("() -> (short _rv)")},
2530    {"IsWindowHilited", (PyCFunction)WinObj_IsWindowHilited, 1,
2531     PyDoc_STR("() -> (Boolean _rv)")},
2532    {"IsWindowUpdatePending", (PyCFunction)WinObj_IsWindowUpdatePending, 1,
2533     PyDoc_STR("() -> (Boolean _rv)")},
2534    {"MacGetNextWindow", (PyCFunction)WinObj_MacGetNextWindow, 1,
2535     PyDoc_STR("() -> (WindowPtr _rv)")},
2536    {"GetWindowStandardState", (PyCFunction)WinObj_GetWindowStandardState, 1,
2537     PyDoc_STR("() -> (Rect rect)")},
2538    {"GetWindowUserState", (PyCFunction)WinObj_GetWindowUserState, 1,
2539     PyDoc_STR("() -> (Rect rect)")},
2540    {"SetWindowKind", (PyCFunction)WinObj_SetWindowKind, 1,
2541     PyDoc_STR("(short kind) -> None")},
2542    {"SetWindowStandardState", (PyCFunction)WinObj_SetWindowStandardState, 1,
2543     PyDoc_STR("(Rect rect) -> None")},
2544    {"SetWindowUserState", (PyCFunction)WinObj_SetWindowUserState, 1,
2545     PyDoc_STR("(Rect rect) -> None")},
2546    {"SetPortWindowPort", (PyCFunction)WinObj_SetPortWindowPort, 1,
2547     PyDoc_STR("() -> None")},
2548    {"GetWindowPortBounds", (PyCFunction)WinObj_GetWindowPortBounds, 1,
2549     PyDoc_STR("() -> (Rect bounds)")},
2550    {"IsWindowVisible", (PyCFunction)WinObj_IsWindowVisible, 1,
2551     PyDoc_STR("() -> (Boolean _rv)")},
2552    {"GetWindowStructureRgn", (PyCFunction)WinObj_GetWindowStructureRgn, 1,
2553     PyDoc_STR("(RgnHandle r) -> None")},
2554    {"GetWindowContentRgn", (PyCFunction)WinObj_GetWindowContentRgn, 1,
2555     PyDoc_STR("(RgnHandle r) -> None")},
2556    {"GetWindowUpdateRgn", (PyCFunction)WinObj_GetWindowUpdateRgn, 1,
2557     PyDoc_STR("(RgnHandle r) -> None")},
2558    {"GetNextWindow", (PyCFunction)WinObj_GetNextWindow, 1,
2559     PyDoc_STR("() -> (WindowPtr _rv)")},
2560    {"MoveWindow", (PyCFunction)WinObj_MoveWindow, 1,
2561     PyDoc_STR("(short hGlobal, short vGlobal, Boolean front) -> None")},
2562    {"ShowWindow", (PyCFunction)WinObj_ShowWindow, 1,
2563     PyDoc_STR("() -> None")},
2564    {"AutoDispose", (PyCFunction)WinObj_AutoDispose, 1,
2565     PyDoc_STR("(int)->int. Automatically DisposeHandle the object on Python object cleanup")},
2566    {NULL, NULL, 0}
2567};
2568
2569#define WinObj_getsetlist NULL
2570
2571
2572static int WinObj_compare(WindowObject *self, WindowObject *other)
2573{
2574    if ( self->ob_itself > other->ob_itself ) return 1;
2575    if ( self->ob_itself < other->ob_itself ) return -1;
2576    return 0;
2577}
2578
2579static PyObject * WinObj_repr(WindowObject *self)
2580{
2581    char buf[100];
2582    sprintf(buf, "<Window object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
2583    return PyString_FromString(buf);
2584}
2585
2586static int WinObj_hash(WindowObject *self)
2587{
2588    return (int)self->ob_itself;
2589}
2590#define WinObj_tp_init 0
2591
2592#define WinObj_tp_alloc PyType_GenericAlloc
2593
2594static PyObject *WinObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
2595{
2596    PyObject *_self;
2597    WindowPtr itself;
2598    char *kw[] = {"itself", 0};
2599
2600    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, WinObj_Convert, &itself)) return NULL;
2601    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
2602    ((WindowObject *)_self)->ob_itself = itself;
2603    return _self;
2604}
2605
2606#define WinObj_tp_free PyObject_Del
2607
2608
2609PyTypeObject Window_Type = {
2610    PyObject_HEAD_INIT(NULL)
2611    0, /*ob_size*/
2612    "_Win.Window", /*tp_name*/
2613    sizeof(WindowObject), /*tp_basicsize*/
2614    0, /*tp_itemsize*/
2615    /* methods */
2616    (destructor) WinObj_dealloc, /*tp_dealloc*/
2617    0, /*tp_print*/
2618    (getattrfunc)0, /*tp_getattr*/
2619    (setattrfunc)0, /*tp_setattr*/
2620    (cmpfunc) WinObj_compare, /*tp_compare*/
2621    (reprfunc) WinObj_repr, /*tp_repr*/
2622    (PyNumberMethods *)0, /* tp_as_number */
2623    (PySequenceMethods *)0, /* tp_as_sequence */
2624    (PyMappingMethods *)0, /* tp_as_mapping */
2625    (hashfunc) WinObj_hash, /*tp_hash*/
2626    0, /*tp_call*/
2627    0, /*tp_str*/
2628    PyObject_GenericGetAttr, /*tp_getattro*/
2629    PyObject_GenericSetAttr, /*tp_setattro */
2630    0, /*tp_as_buffer*/
2631    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
2632    0, /*tp_doc*/
2633    0, /*tp_traverse*/
2634    0, /*tp_clear*/
2635    0, /*tp_richcompare*/
2636    0, /*tp_weaklistoffset*/
2637    0, /*tp_iter*/
2638    0, /*tp_iternext*/
2639    WinObj_methods, /* tp_methods */
2640    0, /*tp_members*/
2641    WinObj_getsetlist, /*tp_getset*/
2642    0, /*tp_base*/
2643    0, /*tp_dict*/
2644    0, /*tp_descr_get*/
2645    0, /*tp_descr_set*/
2646    0, /*tp_dictoffset*/
2647    WinObj_tp_init, /* tp_init */
2648    WinObj_tp_alloc, /* tp_alloc */
2649    WinObj_tp_new, /* tp_new */
2650    WinObj_tp_free, /* tp_free */
2651};
2652
2653/* --------------------- End object type Window --------------------- */
2654
2655
2656static PyObject *Win_GetNewCWindow(PyObject *_self, PyObject *_args)
2657{
2658    PyObject *_res = NULL;
2659    WindowPtr _rv;
2660    short windowID;
2661    WindowPtr behind;
2662#ifndef GetNewCWindow
2663    PyMac_PRECHECK(GetNewCWindow);
2664#endif
2665    if (!PyArg_ParseTuple(_args, "hO&",
2666                          &windowID,
2667                          WinObj_Convert, &behind))
2668        return NULL;
2669    _rv = GetNewCWindow(windowID,
2670                        (void *)0,
2671                        behind);
2672    _res = Py_BuildValue("O&",
2673                         WinObj_New, _rv);
2674    return _res;
2675}
2676
2677static PyObject *Win_NewWindow(PyObject *_self, PyObject *_args)
2678{
2679    PyObject *_res = NULL;
2680    WindowPtr _rv;
2681    Rect boundsRect;
2682    Str255 title;
2683    Boolean visible;
2684    short theProc;
2685    WindowPtr behind;
2686    Boolean goAwayFlag;
2687    long refCon;
2688#ifndef NewWindow
2689    PyMac_PRECHECK(NewWindow);
2690#endif
2691    if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
2692                          PyMac_GetRect, &boundsRect,
2693                          PyMac_GetStr255, title,
2694                          &visible,
2695                          &theProc,
2696                          WinObj_Convert, &behind,
2697                          &goAwayFlag,
2698                          &refCon))
2699        return NULL;
2700    _rv = NewWindow((void *)0,
2701                    &boundsRect,
2702                    title,
2703                    visible,
2704                    theProc,
2705                    behind,
2706                    goAwayFlag,
2707                    refCon);
2708    _res = Py_BuildValue("O&",
2709                         WinObj_New, _rv);
2710    return _res;
2711}
2712
2713static PyObject *Win_GetNewWindow(PyObject *_self, PyObject *_args)
2714{
2715    PyObject *_res = NULL;
2716    WindowPtr _rv;
2717    short windowID;
2718    WindowPtr behind;
2719#ifndef GetNewWindow
2720    PyMac_PRECHECK(GetNewWindow);
2721#endif
2722    if (!PyArg_ParseTuple(_args, "hO&",
2723                          &windowID,
2724                          WinObj_Convert, &behind))
2725        return NULL;
2726    _rv = GetNewWindow(windowID,
2727                       (void *)0,
2728                       behind);
2729    _res = Py_BuildValue("O&",
2730                         WinObj_New, _rv);
2731    return _res;
2732}
2733
2734static PyObject *Win_NewCWindow(PyObject *_self, PyObject *_args)
2735{
2736    PyObject *_res = NULL;
2737    WindowPtr _rv;
2738    Rect boundsRect;
2739    Str255 title;
2740    Boolean visible;
2741    short procID;
2742    WindowPtr behind;
2743    Boolean goAwayFlag;
2744    long refCon;
2745#ifndef NewCWindow
2746    PyMac_PRECHECK(NewCWindow);
2747#endif
2748    if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
2749                          PyMac_GetRect, &boundsRect,
2750                          PyMac_GetStr255, title,
2751                          &visible,
2752                          &procID,
2753                          WinObj_Convert, &behind,
2754                          &goAwayFlag,
2755                          &refCon))
2756        return NULL;
2757    _rv = NewCWindow((void *)0,
2758                     &boundsRect,
2759                     title,
2760                     visible,
2761                     procID,
2762                     behind,
2763                     goAwayFlag,
2764                     refCon);
2765    _res = Py_BuildValue("O&",
2766                         WinObj_New, _rv);
2767    return _res;
2768}
2769
2770static PyObject *Win_CreateNewWindow(PyObject *_self, PyObject *_args)
2771{
2772    PyObject *_res = NULL;
2773    OSStatus _err;
2774    WindowClass windowClass;
2775    WindowAttributes attributes;
2776    Rect contentBounds;
2777    WindowPtr outWindow;
2778#ifndef CreateNewWindow
2779    PyMac_PRECHECK(CreateNewWindow);
2780#endif
2781    if (!PyArg_ParseTuple(_args, "llO&",
2782                          &windowClass,
2783                          &attributes,
2784                          PyMac_GetRect, &contentBounds))
2785        return NULL;
2786    _err = CreateNewWindow(windowClass,
2787                           attributes,
2788                           &contentBounds,
2789                           &outWindow);
2790    if (_err != noErr) return PyMac_Error(_err);
2791    _res = Py_BuildValue("O&",
2792                         WinObj_New, outWindow);
2793    return _res;
2794}
2795
2796static PyObject *Win_CreateWindowFromResource(PyObject *_self, PyObject *_args)
2797{
2798    PyObject *_res = NULL;
2799    OSStatus _err;
2800    SInt16 resID;
2801    WindowPtr outWindow;
2802#ifndef CreateWindowFromResource
2803    PyMac_PRECHECK(CreateWindowFromResource);
2804#endif
2805    if (!PyArg_ParseTuple(_args, "h",
2806                          &resID))
2807        return NULL;
2808    _err = CreateWindowFromResource(resID,
2809                                    &outWindow);
2810    if (_err != noErr) return PyMac_Error(_err);
2811    _res = Py_BuildValue("O&",
2812                         WinObj_New, outWindow);
2813    return _res;
2814}
2815
2816static PyObject *Win_ShowFloatingWindows(PyObject *_self, PyObject *_args)
2817{
2818    PyObject *_res = NULL;
2819    OSStatus _err;
2820#ifndef ShowFloatingWindows
2821    PyMac_PRECHECK(ShowFloatingWindows);
2822#endif
2823    if (!PyArg_ParseTuple(_args, ""))
2824        return NULL;
2825    _err = ShowFloatingWindows();
2826    if (_err != noErr) return PyMac_Error(_err);
2827    Py_INCREF(Py_None);
2828    _res = Py_None;
2829    return _res;
2830}
2831
2832static PyObject *Win_HideFloatingWindows(PyObject *_self, PyObject *_args)
2833{
2834    PyObject *_res = NULL;
2835    OSStatus _err;
2836#ifndef HideFloatingWindows
2837    PyMac_PRECHECK(HideFloatingWindows);
2838#endif
2839    if (!PyArg_ParseTuple(_args, ""))
2840        return NULL;
2841    _err = HideFloatingWindows();
2842    if (_err != noErr) return PyMac_Error(_err);
2843    Py_INCREF(Py_None);
2844    _res = Py_None;
2845    return _res;
2846}
2847
2848static PyObject *Win_AreFloatingWindowsVisible(PyObject *_self, PyObject *_args)
2849{
2850    PyObject *_res = NULL;
2851    Boolean _rv;
2852#ifndef AreFloatingWindowsVisible
2853    PyMac_PRECHECK(AreFloatingWindowsVisible);
2854#endif
2855    if (!PyArg_ParseTuple(_args, ""))
2856        return NULL;
2857    _rv = AreFloatingWindowsVisible();
2858    _res = Py_BuildValue("b",
2859                         _rv);
2860    return _res;
2861}
2862
2863static PyObject *Win_CheckUpdate(PyObject *_self, PyObject *_args)
2864{
2865    PyObject *_res = NULL;
2866    Boolean _rv;
2867    EventRecord theEvent;
2868#ifndef CheckUpdate
2869    PyMac_PRECHECK(CheckUpdate);
2870#endif
2871    if (!PyArg_ParseTuple(_args, ""))
2872        return NULL;
2873    _rv = CheckUpdate(&theEvent);
2874    _res = Py_BuildValue("bO&",
2875                         _rv,
2876                         PyMac_BuildEventRecord, &theEvent);
2877    return _res;
2878}
2879
2880static PyObject *Win_MacFindWindow(PyObject *_self, PyObject *_args)
2881{
2882    PyObject *_res = NULL;
2883    WindowPartCode _rv;
2884    Point thePoint;
2885    WindowPtr window;
2886#ifndef MacFindWindow
2887    PyMac_PRECHECK(MacFindWindow);
2888#endif
2889    if (!PyArg_ParseTuple(_args, "O&",
2890                          PyMac_GetPoint, &thePoint))
2891        return NULL;
2892    _rv = MacFindWindow(thePoint,
2893                        &window);
2894    _res = Py_BuildValue("hO&",
2895                         _rv,
2896                         WinObj_WhichWindow, window);
2897    return _res;
2898}
2899
2900static PyObject *Win_FrontWindow(PyObject *_self, PyObject *_args)
2901{
2902    PyObject *_res = NULL;
2903    WindowPtr _rv;
2904#ifndef FrontWindow
2905    PyMac_PRECHECK(FrontWindow);
2906#endif
2907    if (!PyArg_ParseTuple(_args, ""))
2908        return NULL;
2909    _rv = FrontWindow();
2910    _res = Py_BuildValue("O&",
2911                         WinObj_WhichWindow, _rv);
2912    return _res;
2913}
2914
2915static PyObject *Win_FrontNonFloatingWindow(PyObject *_self, PyObject *_args)
2916{
2917    PyObject *_res = NULL;
2918    WindowPtr _rv;
2919#ifndef FrontNonFloatingWindow
2920    PyMac_PRECHECK(FrontNonFloatingWindow);
2921#endif
2922    if (!PyArg_ParseTuple(_args, ""))
2923        return NULL;
2924    _rv = FrontNonFloatingWindow();
2925    _res = Py_BuildValue("O&",
2926                         WinObj_WhichWindow, _rv);
2927    return _res;
2928}
2929
2930static PyObject *Win_GetFrontWindowOfClass(PyObject *_self, PyObject *_args)
2931{
2932    PyObject *_res = NULL;
2933    WindowPtr _rv;
2934    WindowClass inWindowClass;
2935    Boolean mustBeVisible;
2936#ifndef GetFrontWindowOfClass
2937    PyMac_PRECHECK(GetFrontWindowOfClass);
2938#endif
2939    if (!PyArg_ParseTuple(_args, "lb",
2940                          &inWindowClass,
2941                          &mustBeVisible))
2942        return NULL;
2943    _rv = GetFrontWindowOfClass(inWindowClass,
2944                                mustBeVisible);
2945    _res = Py_BuildValue("O&",
2946                         WinObj_New, _rv);
2947    return _res;
2948}
2949
2950static PyObject *Win_FindWindowOfClass(PyObject *_self, PyObject *_args)
2951{
2952    PyObject *_res = NULL;
2953    OSStatus _err;
2954    Point where;
2955    WindowClass inWindowClass;
2956    WindowPtr outWindow;
2957    WindowPartCode outWindowPart;
2958#ifndef FindWindowOfClass
2959    PyMac_PRECHECK(FindWindowOfClass);
2960#endif
2961    if (!PyArg_ParseTuple(_args, "O&l",
2962                          PyMac_GetPoint, &where,
2963                          &inWindowClass))
2964        return NULL;
2965    _err = FindWindowOfClass(&where,
2966                             inWindowClass,
2967                             &outWindow,
2968                             &outWindowPart);
2969    if (_err != noErr) return PyMac_Error(_err);
2970    _res = Py_BuildValue("O&h",
2971                         WinObj_WhichWindow, outWindow,
2972                         outWindowPart);
2973    return _res;
2974}
2975
2976static PyObject *Win_CreateStandardWindowMenu(PyObject *_self, PyObject *_args)
2977{
2978    PyObject *_res = NULL;
2979    OSStatus _err;
2980    OptionBits inOptions;
2981    MenuHandle outMenu;
2982#ifndef CreateStandardWindowMenu
2983    PyMac_PRECHECK(CreateStandardWindowMenu);
2984#endif
2985    if (!PyArg_ParseTuple(_args, "l",
2986                          &inOptions))
2987        return NULL;
2988    _err = CreateStandardWindowMenu(inOptions,
2989                                    &outMenu);
2990    if (_err != noErr) return PyMac_Error(_err);
2991    _res = Py_BuildValue("O&",
2992                         MenuObj_New, outMenu);
2993    return _res;
2994}
2995
2996static PyObject *Win_CollapseAllWindows(PyObject *_self, PyObject *_args)
2997{
2998    PyObject *_res = NULL;
2999    OSStatus _err;
3000    Boolean collapse;
3001#ifndef CollapseAllWindows
3002    PyMac_PRECHECK(CollapseAllWindows);
3003#endif
3004    if (!PyArg_ParseTuple(_args, "b",
3005                          &collapse))
3006        return NULL;
3007    _err = CollapseAllWindows(collapse);
3008    if (_err != noErr) return PyMac_Error(_err);
3009    Py_INCREF(Py_None);
3010    _res = Py_None;
3011    return _res;
3012}
3013
3014static PyObject *Win_GetAvailableWindowPositioningBounds(PyObject *_self, PyObject *_args)
3015{
3016    PyObject *_res = NULL;
3017    OSStatus _err;
3018    GDHandle inDevice;
3019    Rect outAvailableRect;
3020#ifndef GetAvailableWindowPositioningBounds
3021    PyMac_PRECHECK(GetAvailableWindowPositioningBounds);
3022#endif
3023    if (!PyArg_ParseTuple(_args, "O&",
3024                          ResObj_Convert, &inDevice))
3025        return NULL;
3026    _err = GetAvailableWindowPositioningBounds(inDevice,
3027                                               &outAvailableRect);
3028    if (_err != noErr) return PyMac_Error(_err);
3029    _res = Py_BuildValue("O&",
3030                         PyMac_BuildRect, &outAvailableRect);
3031    return _res;
3032}
3033
3034static PyObject *Win_DisableScreenUpdates(PyObject *_self, PyObject *_args)
3035{
3036    PyObject *_res = NULL;
3037    OSStatus _err;
3038#ifndef DisableScreenUpdates
3039    PyMac_PRECHECK(DisableScreenUpdates);
3040#endif
3041    if (!PyArg_ParseTuple(_args, ""))
3042        return NULL;
3043    _err = DisableScreenUpdates();
3044    if (_err != noErr) return PyMac_Error(_err);
3045    Py_INCREF(Py_None);
3046    _res = Py_None;
3047    return _res;
3048}
3049
3050static PyObject *Win_EnableScreenUpdates(PyObject *_self, PyObject *_args)
3051{
3052    PyObject *_res = NULL;
3053    OSStatus _err;
3054#ifndef EnableScreenUpdates
3055    PyMac_PRECHECK(EnableScreenUpdates);
3056#endif
3057    if (!PyArg_ParseTuple(_args, ""))
3058        return NULL;
3059    _err = EnableScreenUpdates();
3060    if (_err != noErr) return PyMac_Error(_err);
3061    Py_INCREF(Py_None);
3062    _res = Py_None;
3063    return _res;
3064}
3065
3066static PyObject *Win_PinRect(PyObject *_self, PyObject *_args)
3067{
3068    PyObject *_res = NULL;
3069    long _rv;
3070    Rect theRect;
3071    Point thePt;
3072#ifndef PinRect
3073    PyMac_PRECHECK(PinRect);
3074#endif
3075    if (!PyArg_ParseTuple(_args, "O&O&",
3076                          PyMac_GetRect, &theRect,
3077                          PyMac_GetPoint, &thePt))
3078        return NULL;
3079    _rv = PinRect(&theRect,
3080                  thePt);
3081    _res = Py_BuildValue("l",
3082                         _rv);
3083    return _res;
3084}
3085
3086static PyObject *Win_GetGrayRgn(PyObject *_self, PyObject *_args)
3087{
3088    PyObject *_res = NULL;
3089    RgnHandle _rv;
3090#ifndef GetGrayRgn
3091    PyMac_PRECHECK(GetGrayRgn);
3092#endif
3093    if (!PyArg_ParseTuple(_args, ""))
3094        return NULL;
3095    _rv = GetGrayRgn();
3096    _res = Py_BuildValue("O&",
3097                         ResObj_New, _rv);
3098    return _res;
3099}
3100
3101static PyObject *Win_GetWindowFromPort(PyObject *_self, PyObject *_args)
3102{
3103    PyObject *_res = NULL;
3104    WindowPtr _rv;
3105    CGrafPtr port;
3106#ifndef GetWindowFromPort
3107    PyMac_PRECHECK(GetWindowFromPort);
3108#endif
3109    if (!PyArg_ParseTuple(_args, "O&",
3110                          GrafObj_Convert, &port))
3111        return NULL;
3112    _rv = GetWindowFromPort(port);
3113    _res = Py_BuildValue("O&",
3114                         WinObj_New, _rv);
3115    return _res;
3116}
3117
3118static PyObject *Win_WhichWindow(PyObject *_self, PyObject *_args)
3119{
3120    PyObject *_res = NULL;
3121
3122    long ptr;
3123
3124    if ( !PyArg_ParseTuple(_args, "i", &ptr) )
3125        return NULL;
3126    _res = WinObj_WhichWindow((WindowPtr)ptr);
3127    return _res;
3128
3129}
3130
3131static PyObject *Win_FindWindow(PyObject *_self, PyObject *_args)
3132{
3133    PyObject *_res = NULL;
3134    short _rv;
3135    Point thePoint;
3136    WindowPtr theWindow;
3137#ifndef FindWindow
3138    PyMac_PRECHECK(FindWindow);
3139#endif
3140    if (!PyArg_ParseTuple(_args, "O&",
3141                          PyMac_GetPoint, &thePoint))
3142        return NULL;
3143    _rv = FindWindow(thePoint,
3144                     &theWindow);
3145    _res = Py_BuildValue("hO&",
3146                         _rv,
3147                         WinObj_WhichWindow, theWindow);
3148    return _res;
3149}
3150#endif /* APPLE_SUPPORTS_QUICKTIME */
3151
3152static PyMethodDef Win_methods[] = {
3153#if APPLE_SUPPORTS_QUICKTIME
3154    {"GetNewCWindow", (PyCFunction)Win_GetNewCWindow, 1,
3155     PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")},
3156    {"NewWindow", (PyCFunction)Win_NewWindow, 1,
3157     PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")},
3158    {"GetNewWindow", (PyCFunction)Win_GetNewWindow, 1,
3159     PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")},
3160    {"NewCWindow", (PyCFunction)Win_NewCWindow, 1,
3161     PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")},
3162    {"CreateNewWindow", (PyCFunction)Win_CreateNewWindow, 1,
3163     PyDoc_STR("(WindowClass windowClass, WindowAttributes attributes, Rect contentBounds) -> (WindowPtr outWindow)")},
3164    {"CreateWindowFromResource", (PyCFunction)Win_CreateWindowFromResource, 1,
3165     PyDoc_STR("(SInt16 resID) -> (WindowPtr outWindow)")},
3166    {"ShowFloatingWindows", (PyCFunction)Win_ShowFloatingWindows, 1,
3167     PyDoc_STR("() -> None")},
3168    {"HideFloatingWindows", (PyCFunction)Win_HideFloatingWindows, 1,
3169     PyDoc_STR("() -> None")},
3170    {"AreFloatingWindowsVisible", (PyCFunction)Win_AreFloatingWindowsVisible, 1,
3171     PyDoc_STR("() -> (Boolean _rv)")},
3172    {"CheckUpdate", (PyCFunction)Win_CheckUpdate, 1,
3173     PyDoc_STR("() -> (Boolean _rv, EventRecord theEvent)")},
3174    {"MacFindWindow", (PyCFunction)Win_MacFindWindow, 1,
3175     PyDoc_STR("(Point thePoint) -> (WindowPartCode _rv, WindowPtr window)")},
3176    {"FrontWindow", (PyCFunction)Win_FrontWindow, 1,
3177     PyDoc_STR("() -> (WindowPtr _rv)")},
3178    {"FrontNonFloatingWindow", (PyCFunction)Win_FrontNonFloatingWindow, 1,
3179     PyDoc_STR("() -> (WindowPtr _rv)")},
3180    {"GetFrontWindowOfClass", (PyCFunction)Win_GetFrontWindowOfClass, 1,
3181     PyDoc_STR("(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)")},
3182    {"FindWindowOfClass", (PyCFunction)Win_FindWindowOfClass, 1,
3183     PyDoc_STR("(Point where, WindowClass inWindowClass) -> (WindowPtr outWindow, WindowPartCode outWindowPart)")},
3184    {"CreateStandardWindowMenu", (PyCFunction)Win_CreateStandardWindowMenu, 1,
3185     PyDoc_STR("(OptionBits inOptions) -> (MenuHandle outMenu)")},
3186    {"CollapseAllWindows", (PyCFunction)Win_CollapseAllWindows, 1,
3187     PyDoc_STR("(Boolean collapse) -> None")},
3188    {"GetAvailableWindowPositioningBounds", (PyCFunction)Win_GetAvailableWindowPositioningBounds, 1,
3189     PyDoc_STR("(GDHandle inDevice) -> (Rect outAvailableRect)")},
3190    {"DisableScreenUpdates", (PyCFunction)Win_DisableScreenUpdates, 1,
3191     PyDoc_STR("() -> None")},
3192    {"EnableScreenUpdates", (PyCFunction)Win_EnableScreenUpdates, 1,
3193     PyDoc_STR("() -> None")},
3194    {"PinRect", (PyCFunction)Win_PinRect, 1,
3195     PyDoc_STR("(Rect theRect, Point thePt) -> (long _rv)")},
3196    {"GetGrayRgn", (PyCFunction)Win_GetGrayRgn, 1,
3197     PyDoc_STR("() -> (RgnHandle _rv)")},
3198    {"GetWindowFromPort", (PyCFunction)Win_GetWindowFromPort, 1,
3199     PyDoc_STR("(CGrafPtr port) -> (WindowPtr _rv)")},
3200    {"WhichWindow", (PyCFunction)Win_WhichWindow, 1,
3201     PyDoc_STR("Resolve an integer WindowPtr address to a Window object")},
3202    {"FindWindow", (PyCFunction)Win_FindWindow, 1,
3203     PyDoc_STR("(Point thePoint) -> (short _rv, WindowPtr theWindow)")},
3204    {NULL, NULL, 0}
3205#endif /* APPLE_SUPPORTS_QUICKTIME */
3206};
3207
3208
3209
3210#if APPLE_SUPPORTS_QUICKTIME
3211/* Return the object corresponding to the window, or NULL */
3212
3213PyObject *
3214WinObj_WhichWindow(WindowPtr w)
3215{
3216    PyObject *it;
3217
3218    if (w == NULL) {
3219        it = Py_None;
3220        Py_INCREF(it);
3221    } else {
3222        it = (PyObject *) GetWRefCon(w);
3223        if (it == NULL || !IsPointerValid((Ptr)it) || ((WindowObject *)it)->ob_itself != w || !WinObj_Check(it)) {
3224            it = WinObj_New(w);
3225            ((WindowObject *)it)->ob_freeit = NULL;
3226        } else {
3227            Py_INCREF(it);
3228        }
3229    }
3230    return it;
3231}
3232
3233#endif /* APPLE_SUPPORTS_QUICKTIME */
3234
3235void init_Win(void)
3236{
3237    PyObject *m;
3238#if APPLE_SUPPORTS_QUICKTIME
3239    PyObject *d;
3240
3241    PyMac_INIT_TOOLBOX_OBJECT_NEW(WindowPtr, WinObj_New);
3242    PyMac_INIT_TOOLBOX_OBJECT_NEW(WindowPtr, WinObj_WhichWindow);
3243    PyMac_INIT_TOOLBOX_OBJECT_CONVERT(WindowPtr, WinObj_Convert);
3244
3245#endif /* APPLE_SUPPORTS_QUICKTIME */
3246
3247    m = Py_InitModule("_Win", Win_methods);
3248#if APPLE_SUPPORTS_QUICKTIME
3249    d = PyModule_GetDict(m);
3250    Win_Error = PyMac_GetOSErrException();
3251    if (Win_Error == NULL ||
3252        PyDict_SetItemString(d, "Error", Win_Error) != 0)
3253        return;
3254    Window_Type.ob_type = &PyType_Type;
3255    if (PyType_Ready(&Window_Type) < 0) return;
3256    Py_INCREF(&Window_Type);
3257    PyModule_AddObject(m, "Window", (PyObject *)&Window_Type);
3258    /* Backward-compatible name */
3259    Py_INCREF(&Window_Type);
3260    PyModule_AddObject(m, "WindowType", (PyObject *)&Window_Type);
3261#endif /* APPLE_SUPPORTS_QUICKTIME */
3262}
3263
3264/* ======================== End module _Win ========================= */
3265
3266