1 

     2 /* ========================== Module _App =========================== */

     3 

     4 #include "Python.h"

     5 

     6 #ifndef __LP64__

     7 	/* Carbon GUI stuff, not available in 64-bit mode */

     8 

     9 

    10 #include "pymactoolbox.h"

    11 

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

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

    14         PyErr_SetString(PyExc_NotImplementedError, \

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

    16         return NULL; \

    17     }} while(0)

    18 

    19 

    20 #include <Carbon/Carbon.h>

    21 

    22 

    23 static int ThemeButtonDrawInfo_Convert(PyObject *v, ThemeButtonDrawInfo *p_itself)

    24 {

    25         return PyArg_Parse(v, "(iHH)", &p_itself->state, &p_itself->value, &p_itself->adornment);

    26 }

    27 

    28 

    29 static PyObject *App_Error;

    30 

    31 /* ----------------- Object type ThemeDrawingState ------------------ */

    32 

    33 PyTypeObject ThemeDrawingState_Type;

    34 

    35 #define ThemeDrawingStateObj_Check(x) ((x)->ob_type == &ThemeDrawingState_Type || PyObject_TypeCheck((x), &ThemeDrawingState_Type))

    36 

    37 typedef struct ThemeDrawingStateObject {

    38 	PyObject_HEAD

    39 	ThemeDrawingState ob_itself;

    40 } ThemeDrawingStateObject;

    41 

    42 PyObject *ThemeDrawingStateObj_New(ThemeDrawingState itself)

    43 {

    44 	ThemeDrawingStateObject *it;

    45 	it = PyObject_NEW(ThemeDrawingStateObject, &ThemeDrawingState_Type);

    46 	if (it == NULL) return NULL;

    47 	it->ob_itself = itself;

    48 	return (PyObject *)it;

    49 }

    50 

    51 int ThemeDrawingStateObj_Convert(PyObject *v, ThemeDrawingState *p_itself)

    52 {

    53 	if (!ThemeDrawingStateObj_Check(v))

    54 	{

    55 		PyErr_SetString(PyExc_TypeError, "ThemeDrawingState required");

    56 		return 0;

    57 	}

    58 	*p_itself = ((ThemeDrawingStateObject *)v)->ob_itself;

    59 	return 1;

    60 }

    61 

    62 static void ThemeDrawingStateObj_dealloc(ThemeDrawingStateObject *self)

    63 {

    64 	/* Cleanup of self->ob_itself goes here */

    65 	self->ob_type->tp_free((PyObject *)self);

    66 }

    67 

    68 static PyObject *ThemeDrawingStateObj_SetThemeDrawingState(ThemeDrawingStateObject *_self, PyObject *_args)

    69 {

    70 	PyObject *_res = NULL;

    71 	OSStatus _rv;

    72 	Boolean inDisposeNow;

    73 #ifndef SetThemeDrawingState

    74 	PyMac_PRECHECK(SetThemeDrawingState);

    75 #endif

    76 	if (!PyArg_ParseTuple(_args, "b",

    77 	                      &inDisposeNow))

    78 		return NULL;

    79 	_rv = SetThemeDrawingState(_self->ob_itself,

    80 	                           inDisposeNow);

    81 	_res = Py_BuildValue("l",

    82 	                     _rv);

    83 	return _res;

    84 }

    85 

    86 static PyObject *ThemeDrawingStateObj_DisposeThemeDrawingState(ThemeDrawingStateObject *_self, PyObject *_args)

    87 {

    88 	PyObject *_res = NULL;

    89 	OSStatus _rv;

    90 #ifndef DisposeThemeDrawingState

    91 	PyMac_PRECHECK(DisposeThemeDrawingState);

    92 #endif

    93 	if (!PyArg_ParseTuple(_args, ""))

    94 		return NULL;

    95 	_rv = DisposeThemeDrawingState(_self->ob_itself);

    96 	_res = Py_BuildValue("l",

    97 	                     _rv);

    98 	return _res;

    99 }

   100 

   101 static PyMethodDef ThemeDrawingStateObj_methods[] = {

   102 	{"SetThemeDrawingState", (PyCFunction)ThemeDrawingStateObj_SetThemeDrawingState, 1,

   103 	 PyDoc_STR("(Boolean inDisposeNow) -> (OSStatus _rv)")},

   104 	{"DisposeThemeDrawingState", (PyCFunction)ThemeDrawingStateObj_DisposeThemeDrawingState, 1,

   105 	 PyDoc_STR("() -> (OSStatus _rv)")},

   106 	{NULL, NULL, 0}

   107 };

   108 

   109 #define ThemeDrawingStateObj_getsetlist NULL

   110 

   111 

   112 #define ThemeDrawingStateObj_compare NULL

   113 

   114 #define ThemeDrawingStateObj_repr NULL

   115 

   116 #define ThemeDrawingStateObj_hash NULL

   117 #define ThemeDrawingStateObj_tp_init 0

   118 

   119 #define ThemeDrawingStateObj_tp_alloc PyType_GenericAlloc

   120 

   121 static PyObject *ThemeDrawingStateObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

   122 {

   123 	PyObject *_self;

   124 	ThemeDrawingState itself;

   125 	char *kw[] = {"itself", 0};

   126 

   127 	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, ThemeDrawingStateObj_Convert, &itself)) return NULL;

   128 	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;

   129 	((ThemeDrawingStateObject *)_self)->ob_itself = itself;

   130 	return _self;

   131 }

   132 

   133 #define ThemeDrawingStateObj_tp_free PyObject_Del

   134 

   135 

   136 PyTypeObject ThemeDrawingState_Type = {

   137 	PyObject_HEAD_INIT(NULL)

   138 	0, /*ob_size*/

   139 	"_App.ThemeDrawingState", /*tp_name*/

   140 	sizeof(ThemeDrawingStateObject), /*tp_basicsize*/

   141 	0, /*tp_itemsize*/

   142 	/* methods */

   143 	(destructor) ThemeDrawingStateObj_dealloc, /*tp_dealloc*/

   144 	0, /*tp_print*/

   145 	(getattrfunc)0, /*tp_getattr*/

   146 	(setattrfunc)0, /*tp_setattr*/

   147 	(cmpfunc) ThemeDrawingStateObj_compare, /*tp_compare*/

   148 	(reprfunc) ThemeDrawingStateObj_repr, /*tp_repr*/

   149 	(PyNumberMethods *)0, /* tp_as_number */

   150 	(PySequenceMethods *)0, /* tp_as_sequence */

   151 	(PyMappingMethods *)0, /* tp_as_mapping */

   152 	(hashfunc) ThemeDrawingStateObj_hash, /*tp_hash*/

   153 	0, /*tp_call*/

   154 	0, /*tp_str*/

   155 	PyObject_GenericGetAttr, /*tp_getattro*/

   156 	PyObject_GenericSetAttr, /*tp_setattro */

   157 	0, /*tp_as_buffer*/

   158 	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

   159 	0, /*tp_doc*/

   160 	0, /*tp_traverse*/

   161 	0, /*tp_clear*/

   162 	0, /*tp_richcompare*/

   163 	0, /*tp_weaklistoffset*/

   164 	0, /*tp_iter*/

   165 	0, /*tp_iternext*/

   166 	ThemeDrawingStateObj_methods, /* tp_methods */

   167 	0, /*tp_members*/

   168 	ThemeDrawingStateObj_getsetlist, /*tp_getset*/

   169 	0, /*tp_base*/

   170 	0, /*tp_dict*/

   171 	0, /*tp_descr_get*/

   172 	0, /*tp_descr_set*/

   173 	0, /*tp_dictoffset*/

   174 	ThemeDrawingStateObj_tp_init, /* tp_init */

   175 	ThemeDrawingStateObj_tp_alloc, /* tp_alloc */

   176 	ThemeDrawingStateObj_tp_new, /* tp_new */

   177 	ThemeDrawingStateObj_tp_free, /* tp_free */

   178 };

   179 

   180 /* --------------- End object type ThemeDrawingState ---------------- */

   181 

   182 

   183 static PyObject *App_RegisterAppearanceClient(PyObject *_self, PyObject *_args)

   184 {

   185 	PyObject *_res = NULL;

   186 	OSStatus _err;

   187 #ifndef RegisterAppearanceClient

   188 	PyMac_PRECHECK(RegisterAppearanceClient);

   189 #endif

   190 	if (!PyArg_ParseTuple(_args, ""))

   191 		return NULL;

   192 	_err = RegisterAppearanceClient();

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

   194 	Py_INCREF(Py_None);

   195 	_res = Py_None;

   196 	return _res;

   197 }

   198 

   199 static PyObject *App_UnregisterAppearanceClient(PyObject *_self, PyObject *_args)

   200 {

   201 	PyObject *_res = NULL;

   202 	OSStatus _err;

   203 #ifndef UnregisterAppearanceClient

   204 	PyMac_PRECHECK(UnregisterAppearanceClient);

   205 #endif

   206 	if (!PyArg_ParseTuple(_args, ""))

   207 		return NULL;

   208 	_err = UnregisterAppearanceClient();

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

   210 	Py_INCREF(Py_None);

   211 	_res = Py_None;

   212 	return _res;

   213 }

   214 

   215 static PyObject *App_SetThemePen(PyObject *_self, PyObject *_args)

   216 {

   217 	PyObject *_res = NULL;

   218 	OSStatus _err;

   219 	ThemeBrush inBrush;

   220 	SInt16 inDepth;

   221 	Boolean inIsColorDevice;

   222 #ifndef SetThemePen

   223 	PyMac_PRECHECK(SetThemePen);

   224 #endif

   225 	if (!PyArg_ParseTuple(_args, "hhb",

   226 	                      &inBrush,

   227 	                      &inDepth,

   228 	                      &inIsColorDevice))

   229 		return NULL;

   230 	_err = SetThemePen(inBrush,

   231 	                   inDepth,

   232 	                   inIsColorDevice);

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

   234 	Py_INCREF(Py_None);

   235 	_res = Py_None;

   236 	return _res;

   237 }

   238 

   239 static PyObject *App_SetThemeBackground(PyObject *_self, PyObject *_args)

   240 {

   241 	PyObject *_res = NULL;

   242 	OSStatus _err;

   243 	ThemeBrush inBrush;

   244 	SInt16 inDepth;

   245 	Boolean inIsColorDevice;

   246 #ifndef SetThemeBackground

   247 	PyMac_PRECHECK(SetThemeBackground);

   248 #endif

   249 	if (!PyArg_ParseTuple(_args, "hhb",

   250 	                      &inBrush,

   251 	                      &inDepth,

   252 	                      &inIsColorDevice))

   253 		return NULL;

   254 	_err = SetThemeBackground(inBrush,

   255 	                          inDepth,

   256 	                          inIsColorDevice);

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

   258 	Py_INCREF(Py_None);

   259 	_res = Py_None;

   260 	return _res;

   261 }

   262 

   263 static PyObject *App_SetThemeTextColor(PyObject *_self, PyObject *_args)

   264 {

   265 	PyObject *_res = NULL;

   266 	OSStatus _err;

   267 	ThemeTextColor inColor;

   268 	SInt16 inDepth;

   269 	Boolean inIsColorDevice;

   270 #ifndef SetThemeTextColor

   271 	PyMac_PRECHECK(SetThemeTextColor);

   272 #endif

   273 	if (!PyArg_ParseTuple(_args, "hhb",

   274 	                      &inColor,

   275 	                      &inDepth,

   276 	                      &inIsColorDevice))

   277 		return NULL;

   278 	_err = SetThemeTextColor(inColor,

   279 	                         inDepth,

   280 	                         inIsColorDevice);

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

   282 	Py_INCREF(Py_None);

   283 	_res = Py_None;

   284 	return _res;

   285 }

   286 

   287 static PyObject *App_SetThemeWindowBackground(PyObject *_self, PyObject *_args)

   288 {

   289 	PyObject *_res = NULL;

   290 	OSStatus _err;

   291 	WindowPtr inWindow;

   292 	ThemeBrush inBrush;

   293 	Boolean inUpdate;

   294 #ifndef SetThemeWindowBackground

   295 	PyMac_PRECHECK(SetThemeWindowBackground);

   296 #endif

   297 	if (!PyArg_ParseTuple(_args, "O&hb",

   298 	                      WinObj_Convert, &inWindow,

   299 	                      &inBrush,

   300 	                      &inUpdate))

   301 		return NULL;

   302 	_err = SetThemeWindowBackground(inWindow,

   303 	                                inBrush,

   304 	                                inUpdate);

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

   306 	Py_INCREF(Py_None);

   307 	_res = Py_None;

   308 	return _res;

   309 }

   310 

   311 static PyObject *App_DrawThemeWindowHeader(PyObject *_self, PyObject *_args)

   312 {

   313 	PyObject *_res = NULL;

   314 	OSStatus _err;

   315 	Rect inRect;

   316 	ThemeDrawState inState;

   317 #ifndef DrawThemeWindowHeader

   318 	PyMac_PRECHECK(DrawThemeWindowHeader);

   319 #endif

   320 	if (!PyArg_ParseTuple(_args, "O&l",

   321 	                      PyMac_GetRect, &inRect,

   322 	                      &inState))

   323 		return NULL;

   324 	_err = DrawThemeWindowHeader(&inRect,

   325 	                             inState);

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

   327 	Py_INCREF(Py_None);

   328 	_res = Py_None;

   329 	return _res;

   330 }

   331 

   332 static PyObject *App_DrawThemeWindowListViewHeader(PyObject *_self, PyObject *_args)

   333 {

   334 	PyObject *_res = NULL;

   335 	OSStatus _err;

   336 	Rect inRect;

   337 	ThemeDrawState inState;

   338 #ifndef DrawThemeWindowListViewHeader

   339 	PyMac_PRECHECK(DrawThemeWindowListViewHeader);

   340 #endif

   341 	if (!PyArg_ParseTuple(_args, "O&l",

   342 	                      PyMac_GetRect, &inRect,

   343 	                      &inState))

   344 		return NULL;

   345 	_err = DrawThemeWindowListViewHeader(&inRect,

   346 	                                     inState);

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

   348 	Py_INCREF(Py_None);

   349 	_res = Py_None;

   350 	return _res;

   351 }

   352 

   353 static PyObject *App_DrawThemePlacard(PyObject *_self, PyObject *_args)

   354 {

   355 	PyObject *_res = NULL;

   356 	OSStatus _err;

   357 	Rect inRect;

   358 	ThemeDrawState inState;

   359 #ifndef DrawThemePlacard

   360 	PyMac_PRECHECK(DrawThemePlacard);

   361 #endif

   362 	if (!PyArg_ParseTuple(_args, "O&l",

   363 	                      PyMac_GetRect, &inRect,

   364 	                      &inState))

   365 		return NULL;

   366 	_err = DrawThemePlacard(&inRect,

   367 	                        inState);

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

   369 	Py_INCREF(Py_None);

   370 	_res = Py_None;

   371 	return _res;

   372 }

   373 

   374 static PyObject *App_DrawThemeEditTextFrame(PyObject *_self, PyObject *_args)

   375 {

   376 	PyObject *_res = NULL;

   377 	OSStatus _err;

   378 	Rect inRect;

   379 	ThemeDrawState inState;

   380 #ifndef DrawThemeEditTextFrame

   381 	PyMac_PRECHECK(DrawThemeEditTextFrame);

   382 #endif

   383 	if (!PyArg_ParseTuple(_args, "O&l",

   384 	                      PyMac_GetRect, &inRect,

   385 	                      &inState))

   386 		return NULL;

   387 	_err = DrawThemeEditTextFrame(&inRect,

   388 	                              inState);

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

   390 	Py_INCREF(Py_None);

   391 	_res = Py_None;

   392 	return _res;

   393 }

   394 

   395 static PyObject *App_DrawThemeListBoxFrame(PyObject *_self, PyObject *_args)

   396 {

   397 	PyObject *_res = NULL;

   398 	OSStatus _err;

   399 	Rect inRect;

   400 	ThemeDrawState inState;

   401 #ifndef DrawThemeListBoxFrame

   402 	PyMac_PRECHECK(DrawThemeListBoxFrame);

   403 #endif

   404 	if (!PyArg_ParseTuple(_args, "O&l",

   405 	                      PyMac_GetRect, &inRect,

   406 	                      &inState))

   407 		return NULL;

   408 	_err = DrawThemeListBoxFrame(&inRect,

   409 	                             inState);

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

   411 	Py_INCREF(Py_None);

   412 	_res = Py_None;

   413 	return _res;

   414 }

   415 

   416 static PyObject *App_DrawThemeFocusRect(PyObject *_self, PyObject *_args)

   417 {

   418 	PyObject *_res = NULL;

   419 	OSStatus _err;

   420 	Rect inRect;

   421 	Boolean inHasFocus;

   422 #ifndef DrawThemeFocusRect

   423 	PyMac_PRECHECK(DrawThemeFocusRect);

   424 #endif

   425 	if (!PyArg_ParseTuple(_args, "O&b",

   426 	                      PyMac_GetRect, &inRect,

   427 	                      &inHasFocus))

   428 		return NULL;

   429 	_err = DrawThemeFocusRect(&inRect,

   430 	                          inHasFocus);

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

   432 	Py_INCREF(Py_None);

   433 	_res = Py_None;

   434 	return _res;

   435 }

   436 

   437 static PyObject *App_DrawThemePrimaryGroup(PyObject *_self, PyObject *_args)

   438 {

   439 	PyObject *_res = NULL;

   440 	OSStatus _err;

   441 	Rect inRect;

   442 	ThemeDrawState inState;

   443 #ifndef DrawThemePrimaryGroup

   444 	PyMac_PRECHECK(DrawThemePrimaryGroup);

   445 #endif

   446 	if (!PyArg_ParseTuple(_args, "O&l",

   447 	                      PyMac_GetRect, &inRect,

   448 	                      &inState))

   449 		return NULL;

   450 	_err = DrawThemePrimaryGroup(&inRect,

   451 	                             inState);

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

   453 	Py_INCREF(Py_None);

   454 	_res = Py_None;

   455 	return _res;

   456 }

   457 

   458 static PyObject *App_DrawThemeSecondaryGroup(PyObject *_self, PyObject *_args)

   459 {

   460 	PyObject *_res = NULL;

   461 	OSStatus _err;

   462 	Rect inRect;

   463 	ThemeDrawState inState;

   464 #ifndef DrawThemeSecondaryGroup

   465 	PyMac_PRECHECK(DrawThemeSecondaryGroup);

   466 #endif

   467 	if (!PyArg_ParseTuple(_args, "O&l",

   468 	                      PyMac_GetRect, &inRect,

   469 	                      &inState))

   470 		return NULL;

   471 	_err = DrawThemeSecondaryGroup(&inRect,

   472 	                               inState);

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

   474 	Py_INCREF(Py_None);

   475 	_res = Py_None;

   476 	return _res;

   477 }

   478 

   479 static PyObject *App_DrawThemeSeparator(PyObject *_self, PyObject *_args)

   480 {

   481 	PyObject *_res = NULL;

   482 	OSStatus _err;

   483 	Rect inRect;

   484 	ThemeDrawState inState;

   485 #ifndef DrawThemeSeparator

   486 	PyMac_PRECHECK(DrawThemeSeparator);

   487 #endif

   488 	if (!PyArg_ParseTuple(_args, "O&l",

   489 	                      PyMac_GetRect, &inRect,

   490 	                      &inState))

   491 		return NULL;

   492 	_err = DrawThemeSeparator(&inRect,

   493 	                          inState);

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

   495 	Py_INCREF(Py_None);

   496 	_res = Py_None;

   497 	return _res;

   498 }

   499 

   500 static PyObject *App_DrawThemeModelessDialogFrame(PyObject *_self, PyObject *_args)

   501 {

   502 	PyObject *_res = NULL;

   503 	OSStatus _err;

   504 	Rect inRect;

   505 	ThemeDrawState inState;

   506 #ifndef DrawThemeModelessDialogFrame

   507 	PyMac_PRECHECK(DrawThemeModelessDialogFrame);

   508 #endif

   509 	if (!PyArg_ParseTuple(_args, "O&l",

   510 	                      PyMac_GetRect, &inRect,

   511 	                      &inState))

   512 		return NULL;

   513 	_err = DrawThemeModelessDialogFrame(&inRect,

   514 	                                    inState);

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

   516 	Py_INCREF(Py_None);

   517 	_res = Py_None;

   518 	return _res;

   519 }

   520 

   521 static PyObject *App_DrawThemeGenericWell(PyObject *_self, PyObject *_args)

   522 {

   523 	PyObject *_res = NULL;

   524 	OSStatus _err;

   525 	Rect inRect;

   526 	ThemeDrawState inState;

   527 	Boolean inFillCenter;

   528 #ifndef DrawThemeGenericWell

   529 	PyMac_PRECHECK(DrawThemeGenericWell);

   530 #endif

   531 	if (!PyArg_ParseTuple(_args, "O&lb",

   532 	                      PyMac_GetRect, &inRect,

   533 	                      &inState,

   534 	                      &inFillCenter))

   535 		return NULL;

   536 	_err = DrawThemeGenericWell(&inRect,

   537 	                            inState,

   538 	                            inFillCenter);

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

   540 	Py_INCREF(Py_None);

   541 	_res = Py_None;

   542 	return _res;

   543 }

   544 

   545 static PyObject *App_DrawThemeFocusRegion(PyObject *_self, PyObject *_args)

   546 {

   547 	PyObject *_res = NULL;

   548 	OSStatus _err;

   549 	Boolean inHasFocus;

   550 #ifndef DrawThemeFocusRegion

   551 	PyMac_PRECHECK(DrawThemeFocusRegion);

   552 #endif

   553 	if (!PyArg_ParseTuple(_args, "b",

   554 	                      &inHasFocus))

   555 		return NULL;

   556 	_err = DrawThemeFocusRegion((RgnHandle)0,

   557 	                            inHasFocus);

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

   559 	Py_INCREF(Py_None);

   560 	_res = Py_None;

   561 	return _res;

   562 }

   563 

   564 static PyObject *App_IsThemeInColor(PyObject *_self, PyObject *_args)

   565 {

   566 	PyObject *_res = NULL;

   567 	Boolean _rv;

   568 	SInt16 inDepth;

   569 	Boolean inIsColorDevice;

   570 #ifndef IsThemeInColor

   571 	PyMac_PRECHECK(IsThemeInColor);

   572 #endif

   573 	if (!PyArg_ParseTuple(_args, "hb",

   574 	                      &inDepth,

   575 	                      &inIsColorDevice))

   576 		return NULL;

   577 	_rv = IsThemeInColor(inDepth,

   578 	                     inIsColorDevice);

   579 	_res = Py_BuildValue("b",

   580 	                     _rv);

   581 	return _res;

   582 }

   583 

   584 static PyObject *App_GetThemeAccentColors(PyObject *_self, PyObject *_args)

   585 {

   586 	PyObject *_res = NULL;

   587 	OSStatus _err;

   588 	CTabHandle outColors;

   589 #ifndef GetThemeAccentColors

   590 	PyMac_PRECHECK(GetThemeAccentColors);

   591 #endif

   592 	if (!PyArg_ParseTuple(_args, ""))

   593 		return NULL;

   594 	_err = GetThemeAccentColors(&outColors);

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

   596 	_res = Py_BuildValue("O&",

   597 	                     ResObj_New, outColors);

   598 	return _res;

   599 }

   600 

   601 static PyObject *App_DrawThemeMenuBarBackground(PyObject *_self, PyObject *_args)

   602 {

   603 	PyObject *_res = NULL;

   604 	OSStatus _err;

   605 	Rect inBounds;

   606 	ThemeMenuBarState inState;

   607 	UInt32 inAttributes;

   608 #ifndef DrawThemeMenuBarBackground

   609 	PyMac_PRECHECK(DrawThemeMenuBarBackground);

   610 #endif

   611 	if (!PyArg_ParseTuple(_args, "O&Hl",

   612 	                      PyMac_GetRect, &inBounds,

   613 	                      &inState,

   614 	                      &inAttributes))

   615 		return NULL;

   616 	_err = DrawThemeMenuBarBackground(&inBounds,

   617 	                                  inState,

   618 	                                  inAttributes);

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

   620 	Py_INCREF(Py_None);

   621 	_res = Py_None;

   622 	return _res;

   623 }

   624 

   625 static PyObject *App_GetThemeMenuBarHeight(PyObject *_self, PyObject *_args)

   626 {

   627 	PyObject *_res = NULL;

   628 	OSStatus _err;

   629 	SInt16 outHeight;

   630 #ifndef GetThemeMenuBarHeight

   631 	PyMac_PRECHECK(GetThemeMenuBarHeight);

   632 #endif

   633 	if (!PyArg_ParseTuple(_args, ""))

   634 		return NULL;

   635 	_err = GetThemeMenuBarHeight(&outHeight);

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

   637 	_res = Py_BuildValue("h",

   638 	                     outHeight);

   639 	return _res;

   640 }

   641 

   642 static PyObject *App_DrawThemeMenuBackground(PyObject *_self, PyObject *_args)

   643 {

   644 	PyObject *_res = NULL;

   645 	OSStatus _err;

   646 	Rect inMenuRect;

   647 	ThemeMenuType inMenuType;

   648 #ifndef DrawThemeMenuBackground

   649 	PyMac_PRECHECK(DrawThemeMenuBackground);

   650 #endif

   651 	if (!PyArg_ParseTuple(_args, "O&H",

   652 	                      PyMac_GetRect, &inMenuRect,

   653 	                      &inMenuType))

   654 		return NULL;

   655 	_err = DrawThemeMenuBackground(&inMenuRect,

   656 	                               inMenuType);

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

   658 	Py_INCREF(Py_None);

   659 	_res = Py_None;

   660 	return _res;

   661 }

   662 

   663 static PyObject *App_GetThemeMenuBackgroundRegion(PyObject *_self, PyObject *_args)

   664 {

   665 	PyObject *_res = NULL;

   666 	OSStatus _err;

   667 	Rect inMenuRect;

   668 	ThemeMenuType menuType;

   669 #ifndef GetThemeMenuBackgroundRegion

   670 	PyMac_PRECHECK(GetThemeMenuBackgroundRegion);

   671 #endif

   672 	if (!PyArg_ParseTuple(_args, "O&H",

   673 	                      PyMac_GetRect, &inMenuRect,

   674 	                      &menuType))

   675 		return NULL;

   676 	_err = GetThemeMenuBackgroundRegion(&inMenuRect,

   677 	                                    menuType,

   678 	                                    (RgnHandle)0);

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

   680 	Py_INCREF(Py_None);

   681 	_res = Py_None;

   682 	return _res;

   683 }

   684 

   685 static PyObject *App_DrawThemeMenuSeparator(PyObject *_self, PyObject *_args)

   686 {

   687 	PyObject *_res = NULL;

   688 	OSStatus _err;

   689 	Rect inItemRect;

   690 #ifndef DrawThemeMenuSeparator

   691 	PyMac_PRECHECK(DrawThemeMenuSeparator);

   692 #endif

   693 	if (!PyArg_ParseTuple(_args, "O&",

   694 	                      PyMac_GetRect, &inItemRect))

   695 		return NULL;

   696 	_err = DrawThemeMenuSeparator(&inItemRect);

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

   698 	Py_INCREF(Py_None);

   699 	_res = Py_None;

   700 	return _res;

   701 }

   702 

   703 static PyObject *App_GetThemeMenuSeparatorHeight(PyObject *_self, PyObject *_args)

   704 {

   705 	PyObject *_res = NULL;

   706 	OSStatus _err;

   707 	SInt16 outHeight;

   708 #ifndef GetThemeMenuSeparatorHeight

   709 	PyMac_PRECHECK(GetThemeMenuSeparatorHeight);

   710 #endif

   711 	if (!PyArg_ParseTuple(_args, ""))

   712 		return NULL;

   713 	_err = GetThemeMenuSeparatorHeight(&outHeight);

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

   715 	_res = Py_BuildValue("h",

   716 	                     outHeight);

   717 	return _res;

   718 }

   719 

   720 static PyObject *App_GetThemeMenuItemExtra(PyObject *_self, PyObject *_args)

   721 {

   722 	PyObject *_res = NULL;

   723 	OSStatus _err;

   724 	ThemeMenuItemType inItemType;

   725 	SInt16 outHeight;

   726 	SInt16 outWidth;

   727 #ifndef GetThemeMenuItemExtra

   728 	PyMac_PRECHECK(GetThemeMenuItemExtra);

   729 #endif

   730 	if (!PyArg_ParseTuple(_args, "H",

   731 	                      &inItemType))

   732 		return NULL;

   733 	_err = GetThemeMenuItemExtra(inItemType,

   734 	                             &outHeight,

   735 	                             &outWidth);

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

   737 	_res = Py_BuildValue("hh",

   738 	                     outHeight,

   739 	                     outWidth);

   740 	return _res;

   741 }

   742 

   743 static PyObject *App_GetThemeMenuTitleExtra(PyObject *_self, PyObject *_args)

   744 {

   745 	PyObject *_res = NULL;

   746 	OSStatus _err;

   747 	SInt16 outWidth;

   748 	Boolean inIsSquished;

   749 #ifndef GetThemeMenuTitleExtra

   750 	PyMac_PRECHECK(GetThemeMenuTitleExtra);

   751 #endif

   752 	if (!PyArg_ParseTuple(_args, "b",

   753 	                      &inIsSquished))

   754 		return NULL;

   755 	_err = GetThemeMenuTitleExtra(&outWidth,

   756 	                              inIsSquished);

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

   758 	_res = Py_BuildValue("h",

   759 	                     outWidth);

   760 	return _res;

   761 }

   762 

   763 static PyObject *App_DrawThemeTabPane(PyObject *_self, PyObject *_args)

   764 {

   765 	PyObject *_res = NULL;

   766 	OSStatus _err;

   767 	Rect inRect;

   768 	ThemeDrawState inState;

   769 #ifndef DrawThemeTabPane

   770 	PyMac_PRECHECK(DrawThemeTabPane);

   771 #endif

   772 	if (!PyArg_ParseTuple(_args, "O&l",

   773 	                      PyMac_GetRect, &inRect,

   774 	                      &inState))

   775 		return NULL;

   776 	_err = DrawThemeTabPane(&inRect,

   777 	                        inState);

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

   779 	Py_INCREF(Py_None);

   780 	_res = Py_None;

   781 	return _res;

   782 }

   783 

   784 static PyObject *App_GetThemeTabRegion(PyObject *_self, PyObject *_args)

   785 {

   786 	PyObject *_res = NULL;

   787 	OSStatus _err;

   788 	Rect inRect;

   789 	ThemeTabStyle inStyle;

   790 	ThemeTabDirection inDirection;

   791 #ifndef GetThemeTabRegion

   792 	PyMac_PRECHECK(GetThemeTabRegion);

   793 #endif

   794 	if (!PyArg_ParseTuple(_args, "O&HH",

   795 	                      PyMac_GetRect, &inRect,

   796 	                      &inStyle,

   797 	                      &inDirection))

   798 		return NULL;

   799 	_err = GetThemeTabRegion(&inRect,

   800 	                         inStyle,

   801 	                         inDirection,

   802 	                         (RgnHandle)0);

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

   804 	Py_INCREF(Py_None);

   805 	_res = Py_None;

   806 	return _res;

   807 }

   808 

   809 static PyObject *App_SetThemeCursor(PyObject *_self, PyObject *_args)

   810 {

   811 	PyObject *_res = NULL;

   812 	OSStatus _err;

   813 	ThemeCursor inCursor;

   814 #ifndef SetThemeCursor

   815 	PyMac_PRECHECK(SetThemeCursor);

   816 #endif

   817 	if (!PyArg_ParseTuple(_args, "l",

   818 	                      &inCursor))

   819 		return NULL;

   820 	_err = SetThemeCursor(inCursor);

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

   822 	Py_INCREF(Py_None);

   823 	_res = Py_None;

   824 	return _res;

   825 }

   826 

   827 static PyObject *App_SetAnimatedThemeCursor(PyObject *_self, PyObject *_args)

   828 {

   829 	PyObject *_res = NULL;

   830 	OSStatus _err;

   831 	ThemeCursor inCursor;

   832 	UInt32 inAnimationStep;

   833 #ifndef SetAnimatedThemeCursor

   834 	PyMac_PRECHECK(SetAnimatedThemeCursor);

   835 #endif

   836 	if (!PyArg_ParseTuple(_args, "ll",

   837 	                      &inCursor,

   838 	                      &inAnimationStep))

   839 		return NULL;

   840 	_err = SetAnimatedThemeCursor(inCursor,

   841 	                              inAnimationStep);

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

   843 	Py_INCREF(Py_None);

   844 	_res = Py_None;

   845 	return _res;

   846 }

   847 

   848 static PyObject *App_GetThemeScrollBarThumbStyle(PyObject *_self, PyObject *_args)

   849 {

   850 	PyObject *_res = NULL;

   851 	OSStatus _err;

   852 	ThemeScrollBarThumbStyle outStyle;

   853 #ifndef GetThemeScrollBarThumbStyle

   854 	PyMac_PRECHECK(GetThemeScrollBarThumbStyle);

   855 #endif

   856 	if (!PyArg_ParseTuple(_args, ""))

   857 		return NULL;

   858 	_err = GetThemeScrollBarThumbStyle(&outStyle);

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

   860 	_res = Py_BuildValue("H",

   861 	                     outStyle);

   862 	return _res;

   863 }

   864 

   865 static PyObject *App_GetThemeScrollBarArrowStyle(PyObject *_self, PyObject *_args)

   866 {

   867 	PyObject *_res = NULL;

   868 	OSStatus _err;

   869 	ThemeScrollBarArrowStyle outStyle;

   870 #ifndef GetThemeScrollBarArrowStyle

   871 	PyMac_PRECHECK(GetThemeScrollBarArrowStyle);

   872 #endif

   873 	if (!PyArg_ParseTuple(_args, ""))

   874 		return NULL;

   875 	_err = GetThemeScrollBarArrowStyle(&outStyle);

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

   877 	_res = Py_BuildValue("H",

   878 	                     outStyle);

   879 	return _res;

   880 }

   881 

   882 static PyObject *App_GetThemeCheckBoxStyle(PyObject *_self, PyObject *_args)

   883 {

   884 	PyObject *_res = NULL;

   885 	OSStatus _err;

   886 	ThemeCheckBoxStyle outStyle;

   887 #ifndef GetThemeCheckBoxStyle

   888 	PyMac_PRECHECK(GetThemeCheckBoxStyle);

   889 #endif

   890 	if (!PyArg_ParseTuple(_args, ""))

   891 		return NULL;

   892 	_err = GetThemeCheckBoxStyle(&outStyle);

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

   894 	_res = Py_BuildValue("H",

   895 	                     outStyle);

   896 	return _res;

   897 }

   898 

   899 static PyObject *App_UseThemeFont(PyObject *_self, PyObject *_args)

   900 {

   901 	PyObject *_res = NULL;

   902 	OSStatus _err;

   903 	ThemeFontID inFontID;

   904 	ScriptCode inScript;

   905 #ifndef UseThemeFont

   906 	PyMac_PRECHECK(UseThemeFont);

   907 #endif

   908 	if (!PyArg_ParseTuple(_args, "Hh",

   909 	                      &inFontID,

   910 	                      &inScript))

   911 		return NULL;

   912 	_err = UseThemeFont(inFontID,

   913 	                    inScript);

   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 *App_DrawThemeTextBox(PyObject *_self, PyObject *_args)

   921 {

   922 	PyObject *_res = NULL;

   923 	OSStatus _err;

   924 	CFStringRef inString;

   925 	ThemeFontID inFontID;

   926 	ThemeDrawState inState;

   927 	Boolean inWrapToWidth;

   928 	Rect inBoundingBox;

   929 	SInt16 inJust;

   930 #ifndef DrawThemeTextBox

   931 	PyMac_PRECHECK(DrawThemeTextBox);

   932 #endif

   933 	if (!PyArg_ParseTuple(_args, "O&HlbO&h",

   934 	                      CFStringRefObj_Convert, &inString,

   935 	                      &inFontID,

   936 	                      &inState,

   937 	                      &inWrapToWidth,

   938 	                      PyMac_GetRect, &inBoundingBox,

   939 	                      &inJust))

   940 		return NULL;

   941 	_err = DrawThemeTextBox(inString,

   942 	                        inFontID,

   943 	                        inState,

   944 	                        inWrapToWidth,

   945 	                        &inBoundingBox,

   946 	                        inJust,

   947 	                        NULL);

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

   949 	Py_INCREF(Py_None);

   950 	_res = Py_None;

   951 	return _res;

   952 }

   953 

   954 static PyObject *App_TruncateThemeText(PyObject *_self, PyObject *_args)

   955 {

   956 	PyObject *_res = NULL;

   957 	OSStatus _err;

   958 	CFMutableStringRef inString;

   959 	ThemeFontID inFontID;

   960 	ThemeDrawState inState;

   961 	SInt16 inPixelWidthLimit;

   962 	TruncCode inTruncWhere;

   963 	Boolean outTruncated;

   964 #ifndef TruncateThemeText

   965 	PyMac_PRECHECK(TruncateThemeText);

   966 #endif

   967 	if (!PyArg_ParseTuple(_args, "O&Hlhh",

   968 	                      CFMutableStringRefObj_Convert, &inString,

   969 	                      &inFontID,

   970 	                      &inState,

   971 	                      &inPixelWidthLimit,

   972 	                      &inTruncWhere))

   973 		return NULL;

   974 	_err = TruncateThemeText(inString,

   975 	                         inFontID,

   976 	                         inState,

   977 	                         inPixelWidthLimit,

   978 	                         inTruncWhere,

   979 	                         &outTruncated);

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

   981 	_res = Py_BuildValue("b",

   982 	                     outTruncated);

   983 	return _res;

   984 }

   985 

   986 static PyObject *App_GetThemeTextDimensions(PyObject *_self, PyObject *_args)

   987 {

   988 	PyObject *_res = NULL;

   989 	OSStatus _err;

   990 	CFStringRef inString;

   991 	ThemeFontID inFontID;

   992 	ThemeDrawState inState;

   993 	Boolean inWrapToWidth;

   994 	Point ioBounds;

   995 	SInt16 outBaseline;

   996 #ifndef GetThemeTextDimensions

   997 	PyMac_PRECHECK(GetThemeTextDimensions);

   998 #endif

   999 	if (!PyArg_ParseTuple(_args, "O&HlbO&",

  1000 	                      CFStringRefObj_Convert, &inString,

  1001 	                      &inFontID,

  1002 	                      &inState,

  1003 	                      &inWrapToWidth,

  1004 	                      PyMac_GetPoint, &ioBounds))

  1005 		return NULL;

  1006 	_err = GetThemeTextDimensions(inString,

  1007 	                              inFontID,

  1008 	                              inState,

  1009 	                              inWrapToWidth,

  1010 	                              &ioBounds,

  1011 	                              &outBaseline);

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

  1013 	_res = Py_BuildValue("O&h",

  1014 	                     PyMac_BuildPoint, ioBounds,

  1015 	                     outBaseline);

  1016 	return _res;

  1017 }

  1018 

  1019 static PyObject *App_GetThemeTextShadowOutset(PyObject *_self, PyObject *_args)

  1020 {

  1021 	PyObject *_res = NULL;

  1022 	OSStatus _err;

  1023 	ThemeFontID inFontID;

  1024 	ThemeDrawState inState;

  1025 	Rect outOutset;

  1026 #ifndef GetThemeTextShadowOutset

  1027 	PyMac_PRECHECK(GetThemeTextShadowOutset);

  1028 #endif

  1029 	if (!PyArg_ParseTuple(_args, "Hl",

  1030 	                      &inFontID,

  1031 	                      &inState))

  1032 		return NULL;

  1033 	_err = GetThemeTextShadowOutset(inFontID,

  1034 	                                inState,

  1035 	                                &outOutset);

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

  1037 	_res = Py_BuildValue("O&",

  1038 	                     PyMac_BuildRect, &outOutset);

  1039 	return _res;

  1040 }

  1041 

  1042 static PyObject *App_DrawThemeScrollBarArrows(PyObject *_self, PyObject *_args)

  1043 {

  1044 	PyObject *_res = NULL;

  1045 	OSStatus _err;

  1046 	Rect bounds;

  1047 	ThemeTrackEnableState enableState;

  1048 	ThemeTrackPressState pressState;

  1049 	Boolean isHoriz;

  1050 	Rect trackBounds;

  1051 #ifndef DrawThemeScrollBarArrows

  1052 	PyMac_PRECHECK(DrawThemeScrollBarArrows);

  1053 #endif

  1054 	if (!PyArg_ParseTuple(_args, "O&bbb",

  1055 	                      PyMac_GetRect, &bounds,

  1056 	                      &enableState,

  1057 	                      &pressState,

  1058 	                      &isHoriz))

  1059 		return NULL;

  1060 	_err = DrawThemeScrollBarArrows(&bounds,

  1061 	                                enableState,

  1062 	                                pressState,

  1063 	                                isHoriz,

  1064 	                                &trackBounds);

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

  1066 	_res = Py_BuildValue("O&",

  1067 	                     PyMac_BuildRect, &trackBounds);

  1068 	return _res;

  1069 }

  1070 

  1071 static PyObject *App_GetThemeScrollBarTrackRect(PyObject *_self, PyObject *_args)

  1072 {

  1073 	PyObject *_res = NULL;

  1074 	OSStatus _err;

  1075 	Rect bounds;

  1076 	ThemeTrackEnableState enableState;

  1077 	ThemeTrackPressState pressState;

  1078 	Boolean isHoriz;

  1079 	Rect trackBounds;

  1080 #ifndef GetThemeScrollBarTrackRect

  1081 	PyMac_PRECHECK(GetThemeScrollBarTrackRect);

  1082 #endif

  1083 	if (!PyArg_ParseTuple(_args, "O&bbb",

  1084 	                      PyMac_GetRect, &bounds,

  1085 	                      &enableState,

  1086 	                      &pressState,

  1087 	                      &isHoriz))

  1088 		return NULL;

  1089 	_err = GetThemeScrollBarTrackRect(&bounds,

  1090 	                                  enableState,

  1091 	                                  pressState,

  1092 	                                  isHoriz,

  1093 	                                  &trackBounds);

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

  1095 	_res = Py_BuildValue("O&",

  1096 	                     PyMac_BuildRect, &trackBounds);

  1097 	return _res;

  1098 }

  1099 

  1100 static PyObject *App_HitTestThemeScrollBarArrows(PyObject *_self, PyObject *_args)

  1101 {

  1102 	PyObject *_res = NULL;

  1103 	Boolean _rv;

  1104 	Rect scrollBarBounds;

  1105 	ThemeTrackEnableState enableState;

  1106 	ThemeTrackPressState pressState;

  1107 	Boolean isHoriz;

  1108 	Point ptHit;

  1109 	Rect trackBounds;

  1110 	ControlPartCode partcode;

  1111 #ifndef HitTestThemeScrollBarArrows

  1112 	PyMac_PRECHECK(HitTestThemeScrollBarArrows);

  1113 #endif

  1114 	if (!PyArg_ParseTuple(_args, "O&bbbO&",

  1115 	                      PyMac_GetRect, &scrollBarBounds,

  1116 	                      &enableState,

  1117 	                      &pressState,

  1118 	                      &isHoriz,

  1119 	                      PyMac_GetPoint, &ptHit))

  1120 		return NULL;

  1121 	_rv = HitTestThemeScrollBarArrows(&scrollBarBounds,

  1122 	                                  enableState,

  1123 	                                  pressState,

  1124 	                                  isHoriz,

  1125 	                                  ptHit,

  1126 	                                  &trackBounds,

  1127 	                                  &partcode);

  1128 	_res = Py_BuildValue("bO&h",

  1129 	                     _rv,

  1130 	                     PyMac_BuildRect, &trackBounds,

  1131 	                     partcode);

  1132 	return _res;

  1133 }

  1134 

  1135 static PyObject *App_DrawThemeScrollBarDelimiters(PyObject *_self, PyObject *_args)