1 

     2 /* ========================== Module _Win =========================== */

     3 

     4 #include "Python.h"

     5 

     6 #ifndef __LP64__

     7 

     8 #include "pymactoolbox.h"

     9 

    10 /* Macro to test whether a weak-loaded CFM function exists */

    11 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\

    12         PyErr_SetString(PyExc_NotImplementedError, \

    13         "Not available in this shared library/OS version"); \

    14         return NULL; \

    15     }} while(0)

    16 

    17 

    18 #include <Carbon/Carbon.h>

    19 

    20 #ifdef USE_TOOLBOX_OBJECT_GLUE

    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

    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 

    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 

    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 

    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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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 

   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, &region))

   854 		return NULL;

   855 	_err = InvalWindowRgn(_self->ob_itself,

   856 	                      region);

   857 	if (_err != noErr) return PyMac_Error(_err);

   858 	Py_INCREF(Py_None);

   859 	_res = Py_None;

   860 	return _res;

   861 }

   862 

   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 

   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, &region))

   892 		return NULL;

   893 	_err = ValidWindowRgn(_self->ob_itself,

   894 	                      region);

   895 	if (_err != noErr) return PyMac_Error(_err);

   896 	Py_INCREF(Py_None);

   897 	_res = Py_None;

   898 	return _res;

   899 }

   900 

   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 

   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 

   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 

   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 

   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 

   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 

  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 

  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 

  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 

  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 

  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 

  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 

  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);