1
2 /* ========================== Module _Win =========================== */
3
4 #include "Python.h"
5 #include "pymactoolbox.h"
6
7 #if APPLE_SUPPORTS_QUICKTIME
8
9
10 /* Macro to test whether a weak-loaded CFM function exists */
11 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
12 PyErr_SetString(PyExc_NotImplementedError, \
13 "Not available in this shared library/OS version"); \
14 return NULL; \
15 }} while(0)
16
17
18 #include <Carbon/Carbon.h>
19
20 #ifdef USE_TOOLBOX_OBJECT_GLUE
21 extern PyObject *_WinObj_New(WindowRef);
22 extern PyObject *_WinObj_WhichWindow(WindowRef);
23 extern 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 */
36 static void
PyMac_AutoDisposeWindow(WindowPtr w)37 PyMac_AutoDisposeWindow(WindowPtr w)
38 {
39 DisposeWindow(w);
40 }
41
42 static PyObject *Win_Error;
43
44 /* ----------------------- Object type Window ----------------------- */
45
46 PyTypeObject Window_Type;
47
48 #define WinObj_Check(x) ((x)->ob_type == &Window_Type || PyObject_TypeCheck((x), &Window_Type))
49
50 typedef struct WindowObject {
51 PyObject_HEAD
52 WindowPtr ob_itself;
53 void (*ob_freeit)(WindowPtr ptr);
54 } WindowObject;
55
WinObj_New(WindowPtr itself)56 PyObject *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
WinObj_Convert(PyObject * v,WindowPtr * p_itself)73 int 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
WinObj_dealloc(WindowObject * self)96 static 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
WinObj_GetWindowOwnerCount(WindowObject * _self,PyObject * _args)108 static 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
WinObj_CloneWindow(WindowObject * _self,PyObject * _args)126 static 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
WinObj_GetWindowRetainCount(WindowObject * _self,PyObject * _args)142 static 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
WinObj_RetainWindow(WindowObject * _self,PyObject * _args)157 static 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
WinObj_ReleaseWindow(WindowObject * _self,PyObject * _args)173 static 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
WinObj_ReshapeCustomWindow(WindowObject * _self,PyObject * _args)189 static 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
WinObj_GetWindowWidgetHilite(WindowObject * _self,PyObject * _args)205 static 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
WinObj_GetWindowClass(WindowObject * _self,PyObject * _args)223 static 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
WinObj_GetWindowAttributes(WindowObject * _self,PyObject * _args)241 static 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
WinObj_ChangeWindowAttributes(WindowObject * _self,PyObject * _args)259 static 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
WinObj_SetWindowClass(WindowObject * _self,PyObject * _args)281 static 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
WinObj_SetWindowModality(WindowObject * _self,PyObject * _args)300 static 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
WinObj_GetWindowModality(WindowObject * _self,PyObject * _args)322 static 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
WinObj_SetWindowContentColor(WindowObject * _self,PyObject * _args)343 static 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
WinObj_GetWindowContentColor(WindowObject * _self,PyObject * _args)362 static 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
WinObj_GetWindowContentPattern(WindowObject * _self,PyObject * _args)380 static 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
WinObj_SetWindowContentPattern(WindowObject * _self,PyObject * _args)399 static 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
WinObj_ScrollWindowRect(WindowObject * _self,PyObject * _args)418 static 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
WinObj_ScrollWindowRegion(WindowObject * _self,PyObject * _args)449 static 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
WinObj_ClipAbove(WindowObject * _self,PyObject * _args)480 static 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
WinObj_PaintOne(WindowObject * _self,PyObject * _args)494 static 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
WinObj_PaintBehind(WindowObject * _self,PyObject * _args)511 static 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
WinObj_CalcVis(WindowObject * _self,PyObject * _args)528 static 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
WinObj_CalcVisBehind(WindowObject * _self,PyObject * _args)542 static 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
WinObj_BringToFront(WindowObject * _self,PyObject * _args)559 static 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
WinObj_SendBehind(WindowObject * _self,PyObject * _args)573 static 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
WinObj_SelectWindow(WindowObject * _self,PyObject * _args)590 static 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
WinObj_GetNextWindowOfClass(WindowObject * _self,PyObject * _args)604 static 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
WinObj_SetWindowAlternateTitle(WindowObject * _self,PyObject * _args)625 static 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
WinObj_CopyWindowAlternateTitle(WindowObject * _self,PyObject * _args)644 static 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
WinObj_HiliteWindow(WindowObject * _self,PyObject * _args)662 static 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
WinObj_SetWRefCon(WindowObject * _self,PyObject * _args)679 static 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
WinObj_GetWRefCon(WindowObject * _self,PyObject * _args)696 static 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
WinObj_SetWindowPic(WindowObject * _self,PyObject * _args)711 static 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
WinObj_GetWindowPic(WindowObject * _self,PyObject * _args)728 static 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
WinObj_GetWVariant(WindowObject * _self,PyObject * _args)743 static 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
WinObj_GetWindowFeatures(WindowObject * _self,PyObject * _args)758 static 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
WinObj_GetWindowRegion(WindowObject * _self,PyObject * _args)776 static 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
WinObj_GetWindowStructureWidths(WindowObject * _self,PyObject * _args)798 static 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
WinObj_BeginUpdate(WindowObject * _self,PyObject * _args)816 static 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
WinObj_EndUpdate(WindowObject * _self,PyObject * _args)830 static 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
WinObj_InvalWindowRgn(WindowObject * _self,PyObject * _args)844 static 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, ®ion))
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
WinObj_InvalWindowRect(WindowObject * _self,PyObject * _args)863 static 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
WinObj_ValidWindowRgn(WindowObject * _self,PyObject * _args)882 static 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, ®ion))
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
WinObj_ValidWindowRect(WindowObject * _self,PyObject * _args)901 static 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
WinObj_DrawGrowIcon(WindowObject * _self,PyObject * _args)920 static 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
WinObj_SetWTitle(WindowObject * _self,PyObject * _args)934 static 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
WinObj_GetWTitle(WindowObject * _self,PyObject * _args)951 static 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
WinObj_SetWindowTitleWithCFString(WindowObject * _self,PyObject * _args)967 static 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
WinObj_CopyWindowTitleAsCFString(WindowObject * _self,PyObject * _args)986 static 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
WinObj_SetWindowProxyFSSpec(WindowObject * _self,PyObject * _args)1004 static 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
WinObj_GetWindowProxyFSSpec(WindowObject * _self,PyObject * _args)1023 static 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
WinObj_SetWindowProxyAlias(WindowObject * _self,PyObject * _args)1041 static 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
WinObj_GetWindowProxyAlias(WindowObject * _self,PyObject * _args)1060 static 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
WinObj_SetWindowProxyCreatorAndType(WindowObject * _self,PyObject * _args)1078 static 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
WinObj_GetWindowProxyIcon(WindowObject * _self,PyObject * _args)1103 static 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
WinObj_SetWindowProxyIcon(WindowObject * _self,PyObject * _args)1121 static 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
WinObj_RemoveWindowProxy(WindowObject * _self,PyObject * _args)1140 static 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
WinObj_BeginWindowProxyDrag(WindowObject * _self,PyObject * _args)1156 static 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
WinObj_EndWindowProxyDrag(WindowObject * _self,PyObject * _args)1177 static 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
WinObj_TrackWindowProxyFromExistingDrag(WindowObject * _self,PyObject * _args)1196 static 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
WinObj_TrackWindowProxyDrag(WindowObject * _self,PyObject * _args)1221 static 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
WinObj_IsWindowModified(WindowObject * _self,PyObject * _args)1240 static 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
WinObj_SetWindowModified(WindowObject * _self,PyObject * _args)1255 static 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
WinObj_IsWindowPathSelectClick(WindowObject * _self,PyObject * _args)1274 static 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
WinObj_WindowPathSelect(WindowObject * _self,PyObject * _args)1292 static 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
WinObj_HiliteWindowFrameForDrag(WindowObject * _self,PyObject * _args)1313 static 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
WinObj_TransitionWindow(WindowObject * _self,PyObject * _args)1332 static 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
WinObj_TransitionWindowAndParent(WindowObject * _self,PyObject * _args)1357 static 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
WinObj_MacMoveWindow(WindowObject * _self,PyObject * _args)1385 static 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
WinObj_SizeWindow(WindowObject * _self,PyObject * _args)1408 static 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
WinObj_GrowWindow(WindowObject * _self,PyObject * _args)1431 static 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
WinObj_DragWindow(WindowObject * _self,PyObject * _args)1452 static 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
WinObj_ZoomWindow(WindowObject * _self,PyObject * _args)1472 static 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
WinObj_IsWindowCollapsable(WindowObject * _self,PyObject * _args)1492 static 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
WinObj_IsWindowCollapsed(WindowObject * _self,PyObject * _args)1507 static 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
WinObj_CollapseWindow(WindowObject * _self,PyObject * _args)1522 static 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
WinObj_GetWindowBounds(WindowObject * _self,PyObject * _args)1541 static 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 ®ionCode))
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
WinObj_ResizeWindow(WindowObject * _self,PyObject * _args)1562 static 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
WinObj_SetWindowBounds(WindowObject * _self,PyObject * _args)1586 static 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 ®ionCode,
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
WinObj_RepositionWindow(WindowObject * _self,PyObject * _args)1608 static 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
WinObj_MoveWindowStructure(WindowObject * _self,PyObject * _args)1630 static 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
WinObj_IsWindowInStandardState(WindowObject * _self,PyObject * _args)1652 static 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
WinObj_ZoomWindowIdeal(WindowObject * _self,PyObject * _args)1673 static 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
WinObj_GetWindowIdealUserState(WindowObject * _self,PyObject * _args)1694 static 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
WinObj_SetWindowIdealUserState(WindowObject * _self,PyObject * _args)1712 static 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
WinObj_GetWindowGreatestAreaDevice(WindowObject * _self,PyObject * _args)1731 static 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
WinObj_ConstrainWindowToScreen(WindowObject * _self,PyObject * _args)1755 static 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
WinObj_HideWindow(WindowObject * _self,PyObject * _args)1782 static 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
WinObj_MacShowWindow(WindowObject * _self,PyObject * _args)1796 static 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
WinObj_ShowHide(WindowObject * _self,PyObject * _args)1810 static 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
WinObj_MacIsWindowVisible(WindowObject * _self,PyObject * _args)1827 static 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
WinObj_ShowSheetWindow(WindowObject * _self,PyObject * _args)1842 static 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
WinObj_HideSheetWindow(WindowObject * _self,PyObject * _args)1861 static 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
WinObj_GetSheetWindowParent(WindowObject * _self,PyObject * _args)1877 static 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
WinObj_GetWindowPropertyAttributes(WindowObject * _self,PyObject * _args)1895 static 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
WinObj_ChangeWindowPropertyAttributes(WindowObject * _self,PyObject * _args)1919 static 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
WinObj_TrackBox(WindowObject * _self,PyObject * _args)1947 static 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
WinObj_TrackGoAway(WindowObject * _self,PyObject * _args)1968 static 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
WinObj_GetWindowPort(WindowObject * _self,PyObject * _args)1986 static 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
WinObj_GetWindowStructurePort(WindowObject * _self,PyObject * _args)2001 static 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
WinObj_GetWindowKind(WindowObject * _self,PyObject * _args)2016 static 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
WinObj_IsWindowHilited(WindowObject * _self,PyObject * _args)2031 static 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
WinObj_IsWindowUpdatePending(WindowObject * _self,PyObject * _args)2046 static 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
WinObj_MacGetNextWindow(WindowObject * _self,PyObject * _args)2061 static 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
WinObj_GetWindowStandardState(WindowObject * _self,PyObject * _args)2076 static 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
WinObj_GetWindowUserState(WindowObject * _self,PyObject * _args)2092 static 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
WinObj_SetWindowKind(WindowObject * _self,PyObject * _args)2108 static 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
WinObj_SetWindowStandardState(WindowObject * _self,PyObject * _args)2125 static 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
WinObj_SetWindowUserState(WindowObject * _self,PyObject * _args)2142 static 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
WinObj_SetPortWindowPort(WindowObject * _self,PyObject * _args)2159 static 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
WinObj_GetWindowPortBounds(WindowObject * _self,PyObject * _args)2173 static 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
WinObj_IsWindowVisible(WindowObject * _self,PyObject * _args)2189 static 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
WinObj_GetWindowStructureRgn(WindowObject * _self,PyObject * _args)2204 static 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
WinObj_GetWindowContentRgn(WindowObject * _self,PyObject * _args)2221 static 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
WinObj_GetWindowUpdateRgn(WindowObject * _self,PyObject * _args)2238 static 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
WinObj_GetNextWindow(WindowObject * _self,PyObject * _args)2255 static 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
WinObj_MoveWindow(WindowObject * _self,PyObject * _args)2270 static 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
WinObj_ShowWindow(WindowObject * _self,PyObject * _args)2293 static 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
WinObj_AutoDispose(WindowObject * _self,PyObject * _args)2307 static 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
2325 static 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
WinObj_compare(WindowObject * self,WindowObject * other)2572 static 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
WinObj_repr(WindowObject * self)2579 static 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
WinObj_hash(WindowObject * self)2586 static 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
WinObj_tp_new(PyTypeObject * type,PyObject * _args,PyObject * _kwds)2594 static 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
2609 PyTypeObject 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
Win_GetNewCWindow(PyObject * _self,PyObject * _args)2656 static 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
Win_NewWindow(PyObject * _self,PyObject * _args)2677 static 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
Win_GetNewWindow(PyObject * _self,PyObject * _args)2713 static 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
Win_NewCWindow(PyObject * _self,PyObject * _args)2734 static 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
Win_CreateNewWindow(PyObject * _self,PyObject * _args)2770 static 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
Win_CreateWindowFromResource(PyObject * _self,PyObject * _args)2796 static 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
Win_ShowFloatingWindows(PyObject * _self,PyObject * _args)2816 static 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
Win_HideFloatingWindows(PyObject * _self,PyObject * _args)2832 static 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
Win_AreFloatingWindowsVisible(PyObject * _self,PyObject * _args)2848 static 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
Win_CheckUpdate(PyObject * _self,PyObject * _args)2863 static 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
Win_MacFindWindow(PyObject * _self,PyObject * _args)2880 static 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
Win_FrontWindow(PyObject * _self,PyObject * _args)2900 static 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
Win_FrontNonFloatingWindow(PyObject * _self,PyObject * _args)2915 static 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
Win_GetFrontWindowOfClass(PyObject * _self,PyObject * _args)2930 static 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
Win_FindWindowOfClass(PyObject * _self,PyObject * _args)2950 static 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
Win_CreateStandardWindowMenu(PyObject * _self,PyObject * _args)2976 static 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
Win_CollapseAllWindows(PyObject * _self,PyObject * _args)2996 static 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
Win_GetAvailableWindowPositioningBounds(PyObject * _self,PyObject * _args)3014 static 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
Win_DisableScreenUpdates(PyObject * _self,PyObject * _args)3034 static 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
Win_EnableScreenUpdates(PyObject * _self,PyObject * _args)3050 static 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
Win_PinRect(PyObject * _self,PyObject * _args)3066 static 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
Win_GetGrayRgn(PyObject * _self,PyObject * _args)3086 static 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
Win_GetWindowFromPort(PyObject * _self,PyObject * _args)3101 static 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
Win_WhichWindow(PyObject * _self,PyObject * _args)3118 static 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
Win_FindWindow(PyObject * _self,PyObject * _args)3131 static PyObject *Win_FindWindow(PyObject *_self, PyObject *_args)
3132 {
3133 PyObject *_res = NULL;
3134 short _rv;
3135 Point thePoint;
3136 WindowPtr theWindow;
3137 #ifndef FindWindow
3138 PyMac_PRECHECK(FindWindow);
3139 #endif
3140 if (!PyArg_ParseTuple(_args, "O&",
3141 PyMac_GetPoint, &thePoint))
3142 return NULL;
3143 _rv = FindWindow(thePoint,
3144 &theWindow);
3145 _res = Py_BuildValue("hO&",
3146 _rv,
3147 WinObj_WhichWindow, theWindow);
3148 return _res;
3149 }
3150 #endif /* APPLE_SUPPORTS_QUICKTIME */
3151
3152 static PyMethodDef Win_methods[] = {
3153 #if APPLE_SUPPORTS_QUICKTIME
3154 {"GetNewCWindow", (PyCFunction)Win_GetNewCWindow, 1,
3155 PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")},
3156 {"NewWindow", (PyCFunction)Win_NewWindow, 1,
3157 PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")},
3158 {"GetNewWindow", (PyCFunction)Win_GetNewWindow, 1,
3159 PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")},
3160 {"NewCWindow", (PyCFunction)Win_NewCWindow, 1,
3161 PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")},
3162 {"CreateNewWindow", (PyCFunction)Win_CreateNewWindow, 1,
3163 PyDoc_STR("(WindowClass windowClass, WindowAttributes attributes, Rect contentBounds) -> (WindowPtr outWindow)")},
3164 {"CreateWindowFromResource", (PyCFunction)Win_CreateWindowFromResource, 1,
3165 PyDoc_STR("(SInt16 resID) -> (WindowPtr outWindow)")},
3166 {"ShowFloatingWindows", (PyCFunction)Win_ShowFloatingWindows, 1,
3167 PyDoc_STR("() -> None")},
3168 {"HideFloatingWindows", (PyCFunction)Win_HideFloatingWindows, 1,
3169 PyDoc_STR("() -> None")},
3170 {"AreFloatingWindowsVisible", (PyCFunction)Win_AreFloatingWindowsVisible, 1,
3171 PyDoc_STR("() -> (Boolean _rv)")},
3172 {"CheckUpdate", (PyCFunction)Win_CheckUpdate, 1,
3173 PyDoc_STR("() -> (Boolean _rv, EventRecord theEvent)")},
3174 {"MacFindWindow", (PyCFunction)Win_MacFindWindow, 1,
3175 PyDoc_STR("(Point thePoint) -> (WindowPartCode _rv, WindowPtr window)")},
3176 {"FrontWindow", (PyCFunction)Win_FrontWindow, 1,
3177 PyDoc_STR("() -> (WindowPtr _rv)")},
3178 {"FrontNonFloatingWindow", (PyCFunction)Win_FrontNonFloatingWindow, 1,
3179 PyDoc_STR("() -> (WindowPtr _rv)")},
3180 {"GetFrontWindowOfClass", (PyCFunction)Win_GetFrontWindowOfClass, 1,
3181 PyDoc_STR("(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)")},
3182 {"FindWindowOfClass", (PyCFunction)Win_FindWindowOfClass, 1,
3183 PyDoc_STR("(Point where, WindowClass inWindowClass) -> (WindowPtr outWindow, WindowPartCode outWindowPart)")},
3184 {"CreateStandardWindowMenu", (PyCFunction)Win_CreateStandardWindowMenu, 1,
3185 PyDoc_STR("(OptionBits inOptions) -> (MenuHandle outMenu)")},
3186 {"CollapseAllWindows", (PyCFunction)Win_CollapseAllWindows, 1,
3187 PyDoc_STR("(Boolean collapse) -> None")},
3188 {"GetAvailableWindowPositioningBounds", (PyCFunction)Win_GetAvailableWindowPositioningBounds, 1,
3189 PyDoc_STR("(GDHandle inDevice) -> (Rect outAvailableRect)")},
3190 {"DisableScreenUpdates", (PyCFunction)Win_DisableScreenUpdates, 1,
3191 PyDoc_STR("() -> None")},
3192 {"EnableScreenUpdates", (PyCFunction)Win_EnableScreenUpdates, 1,
3193 PyDoc_STR("() -> None")},
3194 {"PinRect", (PyCFunction)Win_PinRect, 1,
3195 PyDoc_STR("(Rect theRect, Point thePt) -> (long _rv)")},
3196 {"GetGrayRgn", (PyCFunction)Win_GetGrayRgn, 1,
3197 PyDoc_STR("() -> (RgnHandle _rv)")},
3198 {"GetWindowFromPort", (PyCFunction)Win_GetWindowFromPort, 1,
3199 PyDoc_STR("(CGrafPtr port) -> (WindowPtr _rv)")},
3200 {"WhichWindow", (PyCFunction)Win_WhichWindow, 1,
3201 PyDoc_STR("Resolve an integer WindowPtr address to a Window object")},
3202 {"FindWindow", (PyCFunction)Win_FindWindow, 1,
3203 PyDoc_STR("(Point thePoint) -> (short _rv, WindowPtr theWindow)")},
3204 {NULL, NULL, 0}
3205 #endif /* APPLE_SUPPORTS_QUICKTIME */
3206 };
3207
3208
3209
3210 #if APPLE_SUPPORTS_QUICKTIME
3211 /* Return the object corresponding to the window, or NULL */
3212
3213 PyObject *
WinObj_WhichWindow(WindowPtr w)3214 WinObj_WhichWindow(WindowPtr w)
3215 {
3216 PyObject *it;
3217
3218 if (w == NULL) {
3219 it = Py_None;
3220 Py_INCREF(it);
3221 } else {
3222 it = (PyObject *) GetWRefCon(w);
3223 if (it == NULL || !IsPointerValid((Ptr)it) || ((WindowObject *)it)->ob_itself != w || !WinObj_Check(it)) {
3224 it = WinObj_New(w);
3225 ((WindowObject *)it)->ob_freeit = NULL;
3226 } else {
3227 Py_INCREF(it);
3228 }
3229 }
3230 return it;
3231 }
3232
3233 #endif /* APPLE_SUPPORTS_QUICKTIME */
3234
init_Win(void)3235 void init_Win(void)
3236 {
3237 PyObject *m;
3238 #if APPLE_SUPPORTS_QUICKTIME
3239 PyObject *d;
3240
3241 PyMac_INIT_TOOLBOX_OBJECT_NEW(WindowPtr, WinObj_New);
3242 PyMac_INIT_TOOLBOX_OBJECT_NEW(WindowPtr, WinObj_WhichWindow);
3243 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(WindowPtr, WinObj_Convert);
3244
3245 #endif /* APPLE_SUPPORTS_QUICKTIME */
3246
3247 m = Py_InitModule("_Win", Win_methods);
3248 #if APPLE_SUPPORTS_QUICKTIME
3249 d = PyModule_GetDict(m);
3250 Win_Error = PyMac_GetOSErrException();
3251 if (Win_Error == NULL ||
3252 PyDict_SetItemString(d, "Error", Win_Error) != 0)
3253 return;
3254 Window_Type.ob_type = &PyType_Type;
3255 if (PyType_Ready(&Window_Type) < 0) return;
3256 Py_INCREF(&Window_Type);
3257 PyModule_AddObject(m, "Window", (PyObject *)&Window_Type);
3258 /* Backward-compatible name */
3259 Py_INCREF(&Window_Type);
3260 PyModule_AddObject(m, "WindowType", (PyObject *)&Window_Type);
3261 #endif /* APPLE_SUPPORTS_QUICKTIME */
3262 }
3263
3264 /* ======================== End module _Win ========================= */
3265
3266