source: python/trunk/Mac/Modules/win/_Winmodule.c

Last change on this file was 391, checked in by dmik, 11 years ago

python: Merge vendor 2.7.6 to trunk.
  • Property svn:eol-style set to native
File size: 98.4 KB
Line 
1
2/* ========================== Module _Win =========================== */
3
4#include "Python.h"
5
6#ifndef __LP64__
7
8#include "pymactoolbox.h"
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 /* __LP64__ */
3151
3152static PyMethodDef Win_methods[] = {
3153#ifndef __LP64__
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 /* __LP64__ */
3206};
3207
3208
3209
3210#ifndef __LP64__
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 /* __LP64__ */
3234
3235void init_Win(void)
3236{
3237 PyObject *m;
3238#ifndef __LP64__
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 /* __LP64__ */
3246
3247 m = Py_InitModule("_Win", Win_methods);
3248#ifndef __LP64__
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 /* __LP64__ */
3262}
3263
3264/* ======================== End module _Win ========================= */
3265
Note: See TracBrowser for help on using the repository browser.