Mac/Modules/app/_Appmodule.c

   1
   2 /* ========================== Module _App =========================== */
   3
   4 #include "Python.h"
   5
   6
   7
   8 #ifdef _WIN32
   9 #include "pywintoolbox.h"
  10 #else
  11 #include "macglue.h"
  12 #include "pymactoolbox.h"
  13 #endif
  14
  15 /* Macro to test whether a weak-loaded CFM function exists */
  16 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
  17         PyErr_SetString(PyExc_NotImplementedError, \
  18         "Not available in this shared library/OS version"); \
  19         return NULL; \
  20     }} while(0)
  21
  22
  23 #ifdef WITHOUT_FRAMEWORKS
  24 #include <Appearance.h>
  25 #else
  26 #include <Carbon/Carbon.h>
  27 #endif
  28
  29
  30
  31 int ThemeButtonDrawInfo_Convert(PyObject *v, ThemeButtonDrawInfo *p_itself)
  32 {
  33         return PyArg_Parse(v, "(iHH)", &p_itself->state, &p_itself->value, &p_itself->adornment);
  34 }
  35
  36
  37 static PyObject *App_Error;
  38
  39 /* ----------------- Object type ThemeDrawingState ------------------ */
  40
  41 PyTypeObject ThemeDrawingState_Type;
  42
  43 #define ThemeDrawingStateObj_Check(x) ((x)->ob_type == &ThemeDrawingState_Type)
  44
  45 typedef struct ThemeDrawingStateObject {
  46         PyObject_HEAD
  47         ThemeDrawingState ob_itself;
  48 } ThemeDrawingStateObject;
  49
  50 PyObject *ThemeDrawingStateObj_New(ThemeDrawingState itself)
  51 {
  52         ThemeDrawingStateObject *it;
  53         it = PyObject_NEW(ThemeDrawingStateObject, &ThemeDrawingState_Type);
  54         if (it == NULL) return NULL;
  55         it->ob_itself = itself;
  56         return (PyObject *)it;
  57 }
  58 int ThemeDrawingStateObj_Convert(PyObject *v, ThemeDrawingState *p_itself)
  59 {
  60         if (!ThemeDrawingStateObj_Check(v))
  61         {
  62                 PyErr_SetString(PyExc_TypeError, "ThemeDrawingState required");
  63                 return 0;
  64         }
  65         *p_itself = ((ThemeDrawingStateObject *)v)->ob_itself;
  66         return 1;
  67 }
  68
  69 static void ThemeDrawingStateObj_dealloc(ThemeDrawingStateObject *self)
  70 {
  71         /* Cleanup of self->ob_itself goes here */
  72         PyMem_DEL(self);
  73 }
  74
  75 static PyObject *ThemeDrawingStateObj_SetThemeDrawingState(ThemeDrawingStateObject *_self, PyObject *_args)
  76 {
  77         PyObject *_res = NULL;
  78         OSStatus _rv;
  79         Boolean inDisposeNow;
  80         if (!PyArg_ParseTuple(_args, "b",
  81                               &inDisposeNow))
  82                 return NULL;
  83         _rv = SetThemeDrawingState(_self->ob_itself,
  84                                    inDisposeNow);
  85         _res = Py_BuildValue("l",
  86                              _rv);
  87         return _res;
  88 }
  89
  90 static PyObject *ThemeDrawingStateObj_DisposeThemeDrawingState(ThemeDrawingStateObject *_self, PyObject *_args)
  91 {
  92         PyObject *_res = NULL;
  93         OSStatus _rv;
  94         if (!PyArg_ParseTuple(_args, ""))
  95                 return NULL;
  96         _rv = DisposeThemeDrawingState(_self->ob_itself);
  97         _res = Py_BuildValue("l",
  98                              _rv);
  99         return _res;
 100 }
 101
 102 static PyMethodDef ThemeDrawingStateObj_methods[] = {
 103         {"SetThemeDrawingState", (PyCFunction)ThemeDrawingStateObj_SetThemeDrawingState, 1,
 104          "(Boolean inDisposeNow) -> (OSStatus _rv)"},
 105         {"DisposeThemeDrawingState", (PyCFunction)ThemeDrawingStateObj_DisposeThemeDrawingState, 1,
 106          "() -> (OSStatus _rv)"},
 107         {NULL, NULL, 0}
 108 };
 109
 110 PyMethodChain ThemeDrawingStateObj_chain = { ThemeDrawingStateObj_methods, NULL };
 111
 112 static PyObject *ThemeDrawingStateObj_getattr(ThemeDrawingStateObject *self, char *name)
 113 {
 114         return Py_FindMethodInChain(&ThemeDrawingStateObj_chain, (PyObject *)self, name);
 115 }
 116
 117 #define ThemeDrawingStateObj_setattr NULL
 118
 119 #define ThemeDrawingStateObj_compare NULL
 120
 121 #define ThemeDrawingStateObj_repr NULL
 122
 123 #define ThemeDrawingStateObj_hash NULL
 124
 125 PyTypeObject ThemeDrawingState_Type = {
 126         PyObject_HEAD_INIT(NULL)
 127         0, /*ob_size*/
 128         "_App.ThemeDrawingState", /*tp_name*/
 129         sizeof(ThemeDrawingStateObject), /*tp_basicsize*/
 130         0, /*tp_itemsize*/
 131         /* methods */
 132         (destructor) ThemeDrawingStateObj_dealloc, /*tp_dealloc*/
 133         0, /*tp_print*/
 134         (getattrfunc) ThemeDrawingStateObj_getattr, /*tp_getattr*/
 135         (setattrfunc) ThemeDrawingStateObj_setattr, /*tp_setattr*/
 136         (cmpfunc) ThemeDrawingStateObj_compare, /*tp_compare*/
 137         (reprfunc) ThemeDrawingStateObj_repr, /*tp_repr*/
 138         (PyNumberMethods *)0, /* tp_as_number */
 139         (PySequenceMethods *)0, /* tp_as_sequence */
 140         (PyMappingMethods *)0, /* tp_as_mapping */
 141         (hashfunc) ThemeDrawingStateObj_hash, /*tp_hash*/
 142 };
 143
 144 /* --------------- End object type ThemeDrawingState ---------------- */
 145
 146
 147 static PyObject *App_RegisterAppearanceClient(PyObject *_self, PyObject *_args)
 148 {
 149         PyObject *_res = NULL;
 150         OSStatus _err;
 151         if (!PyArg_ParseTuple(_args, ""))
 152                 return NULL;
 153         _err = RegisterAppearanceClient();
 154         if (_err != noErr) return PyMac_Error(_err);
 155         Py_INCREF(Py_None);
 156         _res = Py_None;
 157         return _res;
 158 }
 159
 160 static PyObject *App_UnregisterAppearanceClient(PyObject *_self, PyObject *_args)
 161 {
 162         PyObject *_res = NULL;
 163         OSStatus _err;
 164         if (!PyArg_ParseTuple(_args, ""))
 165                 return NULL;
 166         _err = UnregisterAppearanceClient();
 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 *App_SetThemePen(PyObject *_self, PyObject *_args)
 174 {
 175         PyObject *_res = NULL;
 176         OSStatus _err;
 177         ThemeBrush inBrush;
 178         SInt16 inDepth;
 179         Boolean inIsColorDevice;
 180         if (!PyArg_ParseTuple(_args, "hhb",
 181                               &inBrush,
 182                               &inDepth,
 183                               &inIsColorDevice))
 184                 return NULL;
 185         _err = SetThemePen(inBrush,
 186                            inDepth,
 187                            inIsColorDevice);
 188         if (_err != noErr) return PyMac_Error(_err);
 189         Py_INCREF(Py_None);
 190         _res = Py_None;
 191         return _res;
 192 }
 193
 194 static PyObject *App_SetThemeBackground(PyObject *_self, PyObject *_args)
 195 {
 196         PyObject *_res = NULL;
 197         OSStatus _err;
 198         ThemeBrush inBrush;
 199         SInt16 inDepth;
 200         Boolean inIsColorDevice;
 201         if (!PyArg_ParseTuple(_args, "hhb",
 202                               &inBrush,
 203                               &inDepth,
 204                               &inIsColorDevice))
 205                 return NULL;
 206         _err = SetThemeBackground(inBrush,
 207                                   inDepth,
 208                                   inIsColorDevice);
 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_SetThemeTextColor(PyObject *_self, PyObject *_args)
 216 {
 217         PyObject *_res = NULL;
 218         OSStatus _err;
 219         ThemeTextColor inColor;
 220         SInt16 inDepth;
 221         Boolean inIsColorDevice;
 222         if (!PyArg_ParseTuple(_args, "hhb",
 223                               &inColor,
 224                               &inDepth,
 225                               &inIsColorDevice))
 226                 return NULL;
 227         _err = SetThemeTextColor(inColor,
 228                                  inDepth,
 229                                  inIsColorDevice);
 230         if (_err != noErr) return PyMac_Error(_err);
 231         Py_INCREF(Py_None);
 232         _res = Py_None;
 233         return _res;
 234 }
 235
 236 static PyObject *App_SetThemeWindowBackground(PyObject *_self, PyObject *_args)
 237 {
 238         PyObject *_res = NULL;
 239         OSStatus _err;
 240         WindowPtr inWindow;
 241         ThemeBrush inBrush;
 242         Boolean inUpdate;
 243         if (!PyArg_ParseTuple(_args, "O&hb",
 244                               WinObj_Convert, &inWindow,
 245                               &inBrush,
 246                               &inUpdate))
 247                 return NULL;
 248         _err = SetThemeWindowBackground(inWindow,
 249                                         inBrush,
 250                                         inUpdate);
 251         if (_err != noErr) return PyMac_Error(_err);
 252         Py_INCREF(Py_None);
 253         _res = Py_None;
 254         return _res;
 255 }
 256
 257 static PyObject *App_DrawThemeWindowHeader(PyObject *_self, PyObject *_args)
 258 {
 259         PyObject *_res = NULL;
 260         OSStatus _err;
 261         Rect inRect;
 262         ThemeDrawState inState;
 263         if (!PyArg_ParseTuple(_args, "O&l",
 264                               PyMac_GetRect, &inRect,
 265                               &inState))
 266                 return NULL;
 267         _err = DrawThemeWindowHeader(&inRect,
 268                                      inState);
 269         if (_err != noErr) return PyMac_Error(_err);
 270         Py_INCREF(Py_None);
 271         _res = Py_None;
 272         return _res;
 273 }
 274
 275 static PyObject *App_DrawThemeWindowListViewHeader(PyObject *_self, PyObject *_args)
 276 {
 277         PyObject *_res = NULL;
 278         OSStatus _err;
 279         Rect inRect;
 280         ThemeDrawState inState;
 281         if (!PyArg_ParseTuple(_args, "O&l",
 282                               PyMac_GetRect, &inRect,
 283                               &inState))
 284                 return NULL;
 285         _err = DrawThemeWindowListViewHeader(&inRect,
 286                                              inState);
 287         if (_err != noErr) return PyMac_Error(_err);
 288         Py_INCREF(Py_None);
 289         _res = Py_None;
 290         return _res;
 291 }
 292
 293 static PyObject *App_DrawThemePlacard(PyObject *_self, PyObject *_args)
 294 {
 295         PyObject *_res = NULL;
 296         OSStatus _err;
 297         Rect inRect;
 298         ThemeDrawState inState;
 299         if (!PyArg_ParseTuple(_args, "O&l",
 300                               PyMac_GetRect, &inRect,
 301                               &inState))
 302                 return NULL;
 303         _err = DrawThemePlacard(&inRect,
 304                                 inState);
 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_DrawThemeEditTextFrame(PyObject *_self, PyObject *_args)
 312 {
 313         PyObject *_res = NULL;
 314         OSStatus _err;
 315         Rect inRect;
 316         ThemeDrawState inState;
 317         if (!PyArg_ParseTuple(_args, "O&l",
 318                               PyMac_GetRect, &inRect,
 319                               &inState))
 320                 return NULL;
 321         _err = DrawThemeEditTextFrame(&inRect,
 322                                       inState);
 323         if (_err != noErr) return PyMac_Error(_err);
 324         Py_INCREF(Py_None);
 325         _res = Py_None;
 326         return _res;
 327 }
 328
 329 static PyObject *App_DrawThemeListBoxFrame(PyObject *_self, PyObject *_args)
 330 {
 331         PyObject *_res = NULL;
 332         OSStatus _err;
 333         Rect inRect;
 334         ThemeDrawState inState;
 335         if (!PyArg_ParseTuple(_args, "O&l",
 336                               PyMac_GetRect, &inRect,
 337                               &inState))
 338                 return NULL;
 339         _err = DrawThemeListBoxFrame(&inRect,
 340                                      inState);
 341         if (_err != noErr) return PyMac_Error(_err);
 342         Py_INCREF(Py_None);
 343         _res = Py_None;
 344         return _res;
 345 }
 346
 347 static PyObject *App_DrawThemeFocusRect(PyObject *_self, PyObject *_args)
 348 {
 349         PyObject *_res = NULL;
 350         OSStatus _err;
 351         Rect inRect;
 352         Boolean inHasFocus;
 353         if (!PyArg_ParseTuple(_args, "O&b",
 354                               PyMac_GetRect, &inRect,
 355                               &inHasFocus))
 356                 return NULL;
 357         _err = DrawThemeFocusRect(&inRect,
 358                                   inHasFocus);
 359         if (_err != noErr) return PyMac_Error(_err);
 360         Py_INCREF(Py_None);
 361         _res = Py_None;
 362         return _res;
 363 }
 364
 365 static PyObject *App_DrawThemePrimaryGroup(PyObject *_self, PyObject *_args)
 366 {
 367         PyObject *_res = NULL;
 368         OSStatus _err;
 369         Rect inRect;
 370         ThemeDrawState inState;
 371         if (!PyArg_ParseTuple(_args, "O&l",
 372                               PyMac_GetRect, &inRect,
 373                               &inState))
 374                 return NULL;
 375         _err = DrawThemePrimaryGroup(&inRect,
 376                                      inState);
 377         if (_err != noErr) return PyMac_Error(_err);
 378         Py_INCREF(Py_None);
 379         _res = Py_None;
 380         return _res;
 381 }
 382
 383 static PyObject *App_DrawThemeSecondaryGroup(PyObject *_self, PyObject *_args)
 384 {
 385         PyObject *_res = NULL;
 386         OSStatus _err;
 387         Rect inRect;
 388         ThemeDrawState inState;
 389         if (!PyArg_ParseTuple(_args, "O&l",
 390                               PyMac_GetRect, &inRect,
 391                               &inState))
 392                 return NULL;
 393         _err = DrawThemeSecondaryGroup(&inRect,
 394                                        inState);
 395         if (_err != noErr) return PyMac_Error(_err);
 396         Py_INCREF(Py_None);
 397         _res = Py_None;
 398         return _res;
 399 }
 400
 401 static PyObject *App_DrawThemeSeparator(PyObject *_self, PyObject *_args)
 402 {
 403         PyObject *_res = NULL;
 404         OSStatus _err;
 405         Rect inRect;
 406         ThemeDrawState inState;
 407         if (!PyArg_ParseTuple(_args, "O&l",
 408                               PyMac_GetRect, &inRect,
 409                               &inState))
 410                 return NULL;
 411         _err = DrawThemeSeparator(&inRect,
 412                                   inState);
 413         if (_err != noErr) return PyMac_Error(_err);
 414         Py_INCREF(Py_None);
 415         _res = Py_None;
 416         return _res;
 417 }
 418
 419 static PyObject *App_DrawThemeModelessDialogFrame(PyObject *_self, PyObject *_args)
 420 {
 421         PyObject *_res = NULL;
 422         OSStatus _err;
 423         Rect inRect;
 424         ThemeDrawState inState;
 425         if (!PyArg_ParseTuple(_args, "O&l",
 426                               PyMac_GetRect, &inRect,
 427                               &inState))
 428                 return NULL;
 429         _err = DrawThemeModelessDialogFrame(&inRect,
 430                                             inState);
 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_DrawThemeGenericWell(PyObject *_self, PyObject *_args)
 438 {
 439         PyObject *_res = NULL;
 440         OSStatus _err;
 441         Rect inRect;
 442         ThemeDrawState inState;
 443         Boolean inFillCenter;
 444         if (!PyArg_ParseTuple(_args, "O&lb",
 445                               PyMac_GetRect, &inRect,
 446                               &inState,
 447                               &inFillCenter))
 448                 return NULL;
 449         _err = DrawThemeGenericWell(&inRect,
 450                                     inState,
 451                                     inFillCenter);
 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_DrawThemeFocusRegion(PyObject *_self, PyObject *_args)
 459 {
 460         PyObject *_res = NULL;
 461         OSStatus _err;
 462         Boolean inHasFocus;
 463         if (!PyArg_ParseTuple(_args, "b",
 464                               &inHasFocus))
 465                 return NULL;
 466         _err = DrawThemeFocusRegion((RgnHandle)0,
 467                                     inHasFocus);
 468         if (_err != noErr) return PyMac_Error(_err);
 469         Py_INCREF(Py_None);
 470         _res = Py_None;
 471         return _res;
 472 }
 473
 474 static PyObject *App_IsThemeInColor(PyObject *_self, PyObject *_args)
 475 {
 476         PyObject *_res = NULL;
 477         Boolean _rv;
 478         SInt16 inDepth;
 479         Boolean inIsColorDevice;
 480         if (!PyArg_ParseTuple(_args, "hb",
 481                               &inDepth,
 482                               &inIsColorDevice))
 483                 return NULL;
 484         _rv = IsThemeInColor(inDepth,
 485                              inIsColorDevice);
 486         _res = Py_BuildValue("b",
 487                              _rv);
 488         return _res;
 489 }
 490
 491 static PyObject *App_GetThemeAccentColors(PyObject *_self, PyObject *_args)
 492 {
 493         PyObject *_res = NULL;
 494         OSStatus _err;
 495         CTabHandle outColors;
 496         if (!PyArg_ParseTuple(_args, ""))
 497                 return NULL;
 498         _err = GetThemeAccentColors(&outColors);
 499         if (_err != noErr) return PyMac_Error(_err);
 500         _res = Py_BuildValue("O&",
 501                              ResObj_New, outColors);
 502         return _res;
 503 }
 504
 505 static PyObject *App_DrawThemeMenuBarBackground(PyObject *_self, PyObject *_args)
 506 {
 507         PyObject *_res = NULL;
 508         OSStatus _err;
 509         Rect inBounds;
 510         ThemeMenuBarState inState;
 511         UInt32 inAttributes;
 512         if (!PyArg_ParseTuple(_args, "O&Hl",
 513                               PyMac_GetRect, &inBounds,
 514                               &inState,
 515                               &inAttributes))
 516                 return NULL;
 517         _err = DrawThemeMenuBarBackground(&inBounds,
 518                                           inState,
 519                                           inAttributes);
 520         if (_err != noErr) return PyMac_Error(_err);
 521         Py_INCREF(Py_None);
 522         _res = Py_None;
 523         return _res;
 524 }
 525
 526 static PyObject *App_GetThemeMenuBarHeight(PyObject *_self, PyObject *_args)
 527 {
 528         PyObject *_res = NULL;
 529         OSStatus _err;
 530         SInt16 outHeight;
 531         if (!PyArg_ParseTuple(_args, ""))
 532                 return NULL;
 533         _err = GetThemeMenuBarHeight(&outHeight);
 534         if (_err != noErr) return PyMac_Error(_err);
 535         _res = Py_BuildValue("h",
 536                              outHeight);
 537         return _res;
 538 }
 539
 540 static PyObject *App_DrawThemeMenuBackground(PyObject *_self, PyObject *_args)
 541 {
 542         PyObject *_res = NULL;
 543         OSStatus _err;
 544         Rect inMenuRect;
 545         ThemeMenuType inMenuType;
 546         if (!PyArg_ParseTuple(_args, "O&H",
 547                               PyMac_GetRect, &inMenuRect,
 548                               &inMenuType))
 549                 return NULL;
 550         _err = DrawThemeMenuBackground(&inMenuRect,
 551                                        inMenuType);
 552         if (_err != noErr) return PyMac_Error(_err);
 553         Py_INCREF(Py_None);
 554         _res = Py_None;
 555         return _res;
 556 }
 557
 558 static PyObject *App_GetThemeMenuBackgroundRegion(PyObject *_self, PyObject *_args)
 559 {
 560         PyObject *_res = NULL;
 561         OSStatus _err;
 562         Rect inMenuRect;
 563         ThemeMenuType menuType;
 564         if (!PyArg_ParseTuple(_args, "O&H",
 565                               PyMac_GetRect, &inMenuRect,
 566                               &menuType))
 567                 return NULL;
 568         _err = GetThemeMenuBackgroundRegion(&inMenuRect,
 569                                             menuType,
 570                                             (RgnHandle)0);
 571         if (_err != noErr) return PyMac_Error(_err);
 572         Py_INCREF(Py_None);
 573         _res = Py_None;
 574         return _res;
 575 }
 576
 577 static PyObject *App_DrawThemeMenuSeparator(PyObject *_self, PyObject *_args)
 578 {
 579         PyObject *_res = NULL;
 580         OSStatus _err;
 581         Rect inItemRect;
 582         if (!PyArg_ParseTuple(_args, "O&",
 583                               PyMac_GetRect, &inItemRect))
 584                 return NULL;
 585         _err = DrawThemeMenuSeparator(&inItemRect);
 586         if (_err != noErr) return PyMac_Error(_err);
 587         Py_INCREF(Py_None);
 588         _res = Py_None;
 589         return _res;
 590 }
 591
 592 static PyObject *App_GetThemeMenuSeparatorHeight(PyObject *_self, PyObject *_args)
 593 {
 594         PyObject *_res = NULL;
 595         OSStatus _err;
 596         SInt16 outHeight;
 597         if (!PyArg_ParseTuple(_args, ""))
 598                 return NULL;
 599         _err = GetThemeMenuSeparatorHeight(&outHeight);
 600         if (_err != noErr) return PyMac_Error(_err);
 601         _res = Py_BuildValue("h",
 602                              outHeight);
 603         return _res;
 604 }
 605
 606 static PyObject *App_GetThemeMenuItemExtra(PyObject *_self, PyObject *_args)
 607 {
 608         PyObject *_res = NULL;
 609         OSStatus _err;
 610         ThemeMenuItemType inItemType;
 611         SInt16 outHeight;
 612         SInt16 outWidth;
 613         if (!PyArg_ParseTuple(_args, "H",
 614                               &inItemType))
 615                 return NULL;
 616         _err = GetThemeMenuItemExtra(inItemType,
 617                                      &outHeight,
 618                                      &outWidth);
 619         if (_err != noErr) return PyMac_Error(_err);
 620         _res = Py_BuildValue("hh",
 621                              outHeight,
 622                              outWidth);
 623         return _res;
 624 }
 625
 626 static PyObject *App_GetThemeMenuTitleExtra(PyObject *_self, PyObject *_args)
 627 {
 628         PyObject *_res = NULL;
 629         OSStatus _err;
 630         SInt16 outWidth;
 631         Boolean inIsSquished;
 632         if (!PyArg_ParseTuple(_args, "b",
 633                               &inIsSquished))
 634                 return NULL;
 635         _err = GetThemeMenuTitleExtra(&outWidth,
 636                                       inIsSquished);
 637         if (_err != noErr) return PyMac_Error(_err);
 638         _res = Py_BuildValue("h",
 639                              outWidth);
 640         return _res;
 641 }
 642
 643 static PyObject *App_DrawThemeTabPane(PyObject *_self, PyObject *_args)
 644 {
 645         PyObject *_res = NULL;
 646         OSStatus _err;
 647         Rect inRect;
 648         ThemeDrawState inState;
 649         if (!PyArg_ParseTuple(_args, "O&l",
 650                               PyMac_GetRect, &inRect,
 651                               &inState))
 652                 return NULL;
 653         _err = DrawThemeTabPane(&inRect,
 654                                 inState);
 655         if (_err != noErr) return PyMac_Error(_err);
 656         Py_INCREF(Py_None);
 657         _res = Py_None;
 658         return _res;
 659 }
 660
 661 static PyObject *App_GetThemeTabRegion(PyObject *_self, PyObject *_args)
 662 {
 663         PyObject *_res = NULL;
 664         OSStatus _err;
 665         Rect inRect;
 666         ThemeTabStyle inStyle;
 667         ThemeTabDirection inDirection;
 668         if (!PyArg_ParseTuple(_args, "O&HH",
 669                               PyMac_GetRect, &inRect,
 670                               &inStyle,
 671                               &inDirection))
 672                 return NULL;
 673         _err = GetThemeTabRegion(&inRect,
 674                                  inStyle,
 675                                  inDirection,
 676                                  (RgnHandle)0);
 677         if (_err != noErr) return PyMac_Error(_err);
 678         Py_INCREF(Py_None);
 679         _res = Py_None;
 680         return _res;
 681 }
 682
 683 static PyObject *App_SetThemeCursor(PyObject *_self, PyObject *_args)
 684 {
 685         PyObject *_res = NULL;
 686         OSStatus _err;
 687         ThemeCursor inCursor;
 688         if (!PyArg_ParseTuple(_args, "l",
 689                               &inCursor))
 690                 return NULL;
 691         _err = SetThemeCursor(inCursor);
 692         if (_err != noErr) return PyMac_Error(_err);
 693         Py_INCREF(Py_None);
 694         _res = Py_None;
 695         return _res;
 696 }
 697
 698 static PyObject *App_SetAnimatedThemeCursor(PyObject *_self, PyObject *_args)
 699 {
 700         PyObject *_res = NULL;
 701         OSStatus _err;
 702         ThemeCursor inCursor;
 703         UInt32 inAnimationStep;
 704         if (!PyArg_ParseTuple(_args, "ll",
 705                               &inCursor,
 706                               &inAnimationStep))
 707                 return NULL;
 708         _err = SetAnimatedThemeCursor(inCursor,
 709                                       inAnimationStep);
 710         if (_err != noErr) return PyMac_Error(_err);
 711         Py_INCREF(Py_None);
 712         _res = Py_None;
 713         return _res;
 714 }
 715
 716 static PyObject *App_GetThemeScrollBarThumbStyle(PyObject *_self, PyObject *_args)
 717 {
 718         PyObject *_res = NULL;
 719         OSStatus _err;
 720         ThemeScrollBarThumbStyle outStyle;
 721         if (!PyArg_ParseTuple(_args, ""))
 722                 return NULL;
 723         _err = GetThemeScrollBarThumbStyle(&outStyle);
 724         if (_err != noErr) return PyMac_Error(_err);
 725         _res = Py_BuildValue("H",
 726                              outStyle);
 727         return _res;
 728 }
 729
 730 static PyObject *App_GetThemeScrollBarArrowStyle(PyObject *_self, PyObject *_args)
 731 {
 732         PyObject *_res = NULL;
 733         OSStatus _err;
 734         ThemeScrollBarArrowStyle outStyle;
 735         if (!PyArg_ParseTuple(_args, ""))
 736                 return NULL;
 737         _err = GetThemeScrollBarArrowStyle(&outStyle);
 738         if (_err != noErr) return PyMac_Error(_err);
 739         _res = Py_BuildValue("H",
 740                              outStyle);
 741         return _res;
 742 }
 743
 744 static PyObject *App_GetThemeCheckBoxStyle(PyObject *_self, PyObject *_args)
 745 {
 746         PyObject *_res = NULL;
 747         OSStatus _err;
 748         ThemeCheckBoxStyle outStyle;
 749         if (!PyArg_ParseTuple(_args, ""))
 750                 return NULL;
 751         _err = GetThemeCheckBoxStyle(&outStyle);
 752         if (_err != noErr) return PyMac_Error(_err);
 753         _res = Py_BuildValue("H",
 754                              outStyle);
 755         return _res;
 756 }
 757
 758 static PyObject *App_UseThemeFont(PyObject *_self, PyObject *_args)
 759 {
 760         PyObject *_res = NULL;
 761         OSStatus _err;
 762         ThemeFontID inFontID;
 763         ScriptCode inScript;
 764         if (!PyArg_ParseTuple(_args, "Hh",
 765                               &inFontID,
 766                               &inScript))
 767                 return NULL;
 768         _err = UseThemeFont(inFontID,
 769                             inScript);
 770         if (_err != noErr) return PyMac_Error(_err);
 771         Py_INCREF(Py_None);
 772         _res = Py_None;
 773         return _res;
 774 }
 775
 776 #if TARGET_API_MAC_CARBON
 777
 778 static PyObject *App_DrawThemeTextBox(PyObject *_self, PyObject *_args)
 779 {
 780         PyObject *_res = NULL;
 781         OSStatus _err;
 782         CFStringRef inString;
 783         ThemeFontID inFontID;
 784         ThemeDrawState inState;
 785         Boolean inWrapToWidth;
 786         Rect inBoundingBox;
 787         SInt16 inJust;
 788         if (!PyArg_ParseTuple(_args, "O&HlbO&h",
 789                               CFStringRefObj_Convert, &inString,
 790                               &inFontID,
 791                               &inState,
 792                               &inWrapToWidth,
 793                               PyMac_GetRect, &inBoundingBox,
 794                               &inJust))
 795                 return NULL;
 796         _err = DrawThemeTextBox(inString,
 797                                 inFontID,
 798                                 inState,
 799                                 inWrapToWidth,
 800                                 &inBoundingBox,
 801                                 inJust,
 802                                 NULL);
 803         if (_err != noErr) return PyMac_Error(_err);
 804         Py_INCREF(Py_None);
 805         _res = Py_None;
 806         return _res;
 807 }
 808 #endif
 809
 810 #if TARGET_API_MAC_CARBON
 811
 812 static PyObject *App_TruncateThemeText(PyObject *_self, PyObject *_args)
 813 {
 814         PyObject *_res = NULL;
 815         OSStatus _err;
 816         CFMutableStringRef inString;
 817         ThemeFontID inFontID;
 818         ThemeDrawState inState;
 819         SInt16 inPixelWidthLimit;
 820         TruncCode inTruncWhere;
 821         Boolean outTruncated;
 822         if (!PyArg_ParseTuple(_args, "O&Hlhh",
 823                               CFMutableStringRefObj_Convert, &inString,
 824                               &inFontID,
 825                               &inState,
 826                               &inPixelWidthLimit,
 827                               &inTruncWhere))
 828                 return NULL;
 829         _err = TruncateThemeText(inString,
 830                                  inFontID,
 831                                  inState,
 832                                  inPixelWidthLimit,
 833                                  inTruncWhere,
 834                                  &outTruncated);
 835         if (_err != noErr) return PyMac_Error(_err);
 836         _res = Py_BuildValue("b",
 837                              outTruncated);
 838         return _res;
 839 }
 840 #endif
 841
 842 #if TARGET_API_MAC_CARBON
 843
 844 static PyObject *App_GetThemeTextDimensions(PyObject *_self, PyObject *_args)
 845 {
 846         PyObject *_res = NULL;
 847         OSStatus _err;
 848         CFStringRef inString;
 849         ThemeFontID inFontID;
 850         ThemeDrawState inState;
 851         Boolean inWrapToWidth;
 852         Point ioBounds;
 853         SInt16 outBaseline;
 854         if (!PyArg_ParseTuple(_args, "O&HlbO&",
 855                               CFStringRefObj_Convert, &inString,
 856                               &inFontID,
 857                               &inState,
 858                               &inWrapToWidth,
 859                               PyMac_GetPoint, &ioBounds))
 860                 return NULL;
 861         _err = GetThemeTextDimensions(inString,
 862                                       inFontID,
 863                                       inState,
 864                                       inWrapToWidth,
 865                                       &ioBounds,
 866                                       &outBaseline);
 867         if (_err != noErr) return PyMac_Error(_err);
 868         _res = Py_BuildValue("O&h",
 869                              PyMac_BuildPoint, ioBounds,
 870                              outBaseline);
 871         return _res;
 872 }
 873 #endif
 874
 875 #if TARGET_API_MAC_CARBON
 876
 877 static PyObject *App_GetThemeTextShadowOutset(PyObject *_self, PyObject *_args)
 878 {
 879         PyObject *_res = NULL;
 880         OSStatus _err;
 881         ThemeFontID inFontID;
 882         ThemeDrawState inState;
 883         Rect outOutset;
 884         if (!PyArg_ParseTuple(_args, "Hl",
 885                               &inFontID,
 886                               &inState))
 887                 return NULL;
 888         _err = GetThemeTextShadowOutset(inFontID,
 889                                         inState,
 890                                         &outOutset);
 891         if (_err != noErr) return PyMac_Error(_err);
 892         _res = Py_BuildValue("O&",
 893                              PyMac_BuildRect, &outOutset);
 894         return _res;
 895 }
 896 #endif
 897
 898 static PyObject *App_DrawThemeScrollBarArrows(PyObject *_self, PyObject *_args)
 899 {
 900         PyObject *_res = NULL;
 901         OSStatus _err;
 902         Rect bounds;
 903         ThemeTrackEnableState enableState;
 904         ThemeTrackPressState pressState;
 905         Boolean isHoriz;
 906         Rect trackBounds;
 907         if (!PyArg_ParseTuple(_args, "O&bbb",
 908                               PyMac_GetRect, &bounds,
 909                               &enableState,
 910                               &pressState,
 911                               &isHoriz))
 912                 return NULL;
 913         _err = DrawThemeScrollBarArrows(&bounds,
 914                                         enableState,
 915                                         pressState,
 916                                         isHoriz,
 917                                         &trackBounds);
 918         if (_err != noErr) return PyMac_Error(_err);
 919         _res = Py_BuildValue("O&",
 920                              PyMac_BuildRect, &trackBounds);
 921         return _res;
 922 }
 923
 924 static PyObject *App_GetThemeScrollBarTrackRect(PyObject *_self, PyObject *_args)
 925 {
 926         PyObject *_res = NULL;
 927         OSStatus _err;
 928         Rect bounds;
 929         ThemeTrackEnableState enableState;
 930         ThemeTrackPressState pressState;
 931         Boolean isHoriz;
 932         Rect trackBounds;
 933         if (!PyArg_ParseTuple(_args, "O&bbb",
 934                               PyMac_GetRect, &bounds,
 935                               &enableState,
 936                               &pressState,
 937                               &isHoriz))
 938                 return NULL;
 939         _err = GetThemeScrollBarTrackRect(&bounds,
 940                                           enableState,
 941                                           pressState,
 942                                           isHoriz,
 943                                           &trackBounds);
 944         if (_err != noErr) return PyMac_Error(_err);
 945         _res = Py_BuildValue("O&",
 946                              PyMac_BuildRect, &trackBounds);
 947         return _res;
 948 }
 949
 950 static PyObject *App_HitTestThemeScrollBarArrows(PyObject *_self, PyObject *_args)
 951 {
 952         PyObject *_res = NULL;
 953         Boolean _rv;
 954         Rect scrollBarBounds;
 955         ThemeTrackEnableState enableState;
 956         ThemeTrackPressState pressState;
 957         Boolean isHoriz;
 958         Point ptHit;
 959         Rect trackBounds;
 960         ControlPartCode partcode;
 961         if (!PyArg_ParseTuple(_args, "O&bbbO&",
 962                               PyMac_GetRect, &scrollBarBounds,
 963                               &enableState,
 964                               &pressState,
 965                               &isHoriz,
 966                               PyMac_GetPoint, &ptHit))
 967                 return NULL;
 968         _rv = HitTestThemeScrollBarArrows(&scrollBarBounds,
 969                                           enableState,
 970                                           pressState,
 971                                           isHoriz,
 972                                           ptHit,
 973                                           &trackBounds,
 974                                           &partcode);
 975         _res = Py_BuildValue("bO&h",
 976                              _rv,
 977                              PyMac_BuildRect, &trackBounds,
 978                              partcode);
 979         return _res;
 980 }
 981
 982 static PyObject *App_DrawThemeScrollBarDelimiters(PyObject *_self, PyObject *_args)
 983 {
 984         PyObject *_res = NULL;
 985         OSStatus _err;
 986         ThemeWindowType flavor;
 987         Rect inContRect;
 988         ThemeDrawState state;
 989         ThemeWindowAttributes attributes;
 990         if (!PyArg_ParseTuple(_args, "HO&ll",
 991                               &flavor,
 992                               PyMac_GetRect, &inContRect,
 993                               &state,
 994                               &attributes))
 995                 return NULL;
 996         _err = DrawThemeScrollBarDelimiters(flavor,
 997                                             &inContRect,
 998                                             state,
 999                                             attributes);
1000         if (_err != noErr) return PyMac_Error(_err);
1001         Py_INCREF(Py_None);
1002         _res = Py_None;
1003         return _res;
1004 }
1005
1006 static PyObject *App_DrawThemeButton(PyObject *_self, PyObject *_args)
1007 {
1008         PyObject *_res = NULL;
1009         OSStatus _err;
1010         Rect inBounds;
1011         UInt16 inKind;
1012         ThemeButtonDrawInfo inNewInfo;
1013         ThemeButtonDrawInfo inPrevInfo;
1014         UInt32 inUserData;
1015         if (!PyArg_ParseTuple(_args, "O&HO&O&l",
1016                               PyMac_GetRect, &inBounds,
1017                               &inKind,
1018                               ThemeButtonDrawInfo_Convert, &inNewInfo,
1019                               ThemeButtonDrawInfo_Convert, &inPrevInfo,
1020                               &inUserData))
1021                 return NULL;
1022         _err = DrawThemeButton(&inBounds,
1023                                inKind,
1024                                &inNewInfo,
1025                                &inPrevInfo,
1026                                NULL,
1027                                NULL,
1028                                inUserData);
1029         if (_err != noErr) return PyMac_Error(_err);
1030         Py_INCREF(Py_None);
1031         _res = Py_None;
1032         return _res;
1033 }
1034
1035 static PyObject *App_GetThemeButtonRegion(PyObject *_self, PyObject *_args)
1036 {
1037         PyObject *_res = NULL;
1038         OSStatus _err;
1039         Rect inBounds;
1040         UInt16 inKind;
1041         ThemeButtonDrawInfo inNewInfo;
1042         if (!PyArg_ParseTuple(_args, "O&HO&",
1043                               PyMac_GetRect, &inBounds,
1044                               &inKind,
1045                               ThemeButtonDrawInfo_Convert, &inNewInfo))
1046                 return NULL;
1047         _err = GetThemeButtonRegion(&inBounds,
1048                                     inKind,
1049                                     &inNewInfo,
1050                                     (RgnHandle)0);
1051         if (_err != noErr) return PyMac_Error(_err);
1052         Py_INCREF(Py_None);
1053         _res = Py_None;
1054         return _res;
1055 }
1056
1057 static PyObject *App_GetThemeButtonContentBounds(PyObject *_self, PyObject *_args)
1058 {
1059         PyObject *_res = NULL;
1060         OSStatus _err;
1061         Rect inBounds;
1062         UInt16 inKind;
1063         ThemeButtonDrawInfo inDrawInfo;
1064         Rect outBounds;
1065         if (!PyArg_ParseTuple(_args, "O&HO&",
1066                               PyMac_GetRect, &inBounds,
1067                               &inKind,
1068                               ThemeButtonDrawInfo_Convert, &inDrawInfo))
1069                 return NULL;
1070         _err = GetThemeButtonContentBounds(&inBounds,
1071                                            inKind,
1072                                            &inDrawInfo,
1073                                            &outBounds);
1074         if (_err != noErr) return PyMac_Error(_err);
1075         _res = Py_BuildValue("O&",
1076                              PyMac_BuildRect, &outBounds);
1077         return _res;
1078 }
1079
1080 static PyObject *App_GetThemeButtonBackgroundBounds(PyObject *_self, PyObject *_args)
1081 {
1082         PyObject *_res = NULL;
1083         OSStatus _err;
1084         Rect inBounds;
1085         UInt16 inKind;
1086         ThemeButtonDrawInfo inDrawInfo;
1087         Rect outBounds;
1088         if (!PyArg_ParseTuple(_args, "O&HO&",
1089                               PyMac_GetRect, &inBounds,
1090                               &inKind,
1091                               ThemeButtonDrawInfo_Convert, &inDrawInfo))
1092                 return NULL;
1093         _err = GetThemeButtonBackgroundBounds(&inBounds,
1094                                               inKind,
1095                                               &inDrawInfo,
1096                                               &outBounds);
1097         if (_err != noErr) return PyMac_Error(_err);
1098         _res = Py_BuildValue("O&",
1099                              PyMac_BuildRect, &outBounds);
1100         return _res;
1101 }
1102
1103 static PyObject *App_PlayThemeSound(PyObject *_self, PyObject *_args)
1104 {
1105         PyObject *_res = NULL;
1106         OSStatus _err;
1107         ThemeSoundKind kind;
1108         if (!PyArg_ParseTuple(_args, "O&",
1109                               PyMac_GetOSType, &kind))
1110                 return NULL;
1111         _err = PlayThemeSound(kind);
1112         if (_err != noErr) return PyMac_Error(_err);
1113         Py_INCREF(Py_None);
1114         _res = Py_None;
1115         return _res;
1116 }
1117
1118 static PyObject *App_BeginThemeDragSound(PyObject *_self, PyObject *_args)
1119 {
1120         PyObject *_res = NULL;
1121         OSStatus _err;
1122         ThemeDragSoundKind kind;
1123         if (!PyArg_ParseTuple(_args, "O&",
1124                               PyMac_GetOSType, &kind))
1125                 return NULL;
1126         _err = BeginThemeDragSound(kind);
1127         if (_err != noErr) return PyMac_Error(_err);
1128         Py_INCREF(Py_None);
1129         _res = Py_None;
1130         return _res;
1131 }
1132
1133 static PyObject *App_EndThemeDragSound(PyObject *_self, PyObject *_args)
1134 {
1135         PyObject *_res = NULL;
1136         OSStatus _err;
1137         if (!PyArg_ParseTuple(_args, ""))
1138                 return NULL;
1139         _err = EndThemeDragSound();
1140         if (_err != noErr) return PyMac_Error(_err);
1141         Py_INCREF(Py_None);
1142         _res = Py_None;
1143         return _res;
1144 }
1145
1146 static PyObject *App_DrawThemeTickMark(PyObject *_self, PyObject *_args)
1147 {
1148         PyObject *_res = NULL;
1149         OSStatus _err;
1150         Rect bounds;
1151         ThemeDrawState state;
1152         if (!PyArg_ParseTuple(_args, "O&l",
1153                               PyMac_GetRect, &bounds,
1154                               &state))
1155                 return NULL;
1156         _err = DrawThemeTickMark(&bounds,
1157                                  state);
1158         if (_err != noErr) return PyMac_Error(_err);
1159         Py_INCREF(Py_None);
1160         _res = Py_None;
1161         return _res;
1162 }
1163
1164 static PyObject *App_DrawThemeChasingArrows(PyObject *_self, PyObject *_args)
1165 {
1166         PyObject *_res = NULL;
1167         OSStatus _err;
1168         Rect bounds;
1169         UInt32 index;
1170         ThemeDrawState state;
1171         UInt32 eraseData;
1172         if (!PyArg_ParseTuple(_args, "O&lll",
1173                               PyMac_GetRect, &bounds,
1174                               &index,
1175                               &state,
1176                               &eraseData))
1177                 return NULL;
1178         _err = DrawThemeChasingArrows(&bounds,
1179                                       index,
1180                                       state,
1181                                       NULL,
1182                                       eraseData);
1183         if (_err != noErr) return PyMac_Error(_err);
1184         Py_INCREF(Py_None);
1185         _res = Py_None;
1186         return _res;
1187 }
1188
1189 static PyObject *App_DrawThemePopupArrow(PyObject *_self, PyObject *_args)
1190 {
1191         PyObject *_res = NULL;
1192         OSStatus _err;
1193         Rect bounds;
1194         ThemeArrowOrientation orientation;
1195         ThemePopupArrowSize size;
1196         ThemeDrawState state;
1197         UInt32 eraseData;
1198         if (!PyArg_ParseTuple(_args, "O&HHll",
1199                               PyMac_GetRect, &bounds,
1200                               &orientation,
1201                               &size,
1202                               &state,
1203                               &eraseData))
1204                 return NULL;
1205         _err = DrawThemePopupArrow(&bounds,
1206                                    orientation,
1207                                    size,
1208                                    state,
1209                                    NULL,
1210                                    eraseData);
1211         if (_err != noErr) return PyMac_Error(_err);
1212         Py_INCREF(Py_None);
1213         _res = Py_None;
1214         return _res;
1215 }
1216
1217 static PyObject *App_DrawThemeStandaloneGrowBox(PyObject *_self, PyObject *_args)
1218 {
1219         PyObject *_res = NULL;
1220         OSStatus _err;
1221         Point origin;
1222         ThemeGrowDirection growDirection;
1223         Boolean isSmall;
1224         ThemeDrawState state;
1225         if (!PyArg_ParseTuple(_args, "O&Hbl",
1226                               PyMac_GetPoint, &origin,
1227                               &growDirection,
1228                               &isSmall,
1229                               &state))
1230                 return NULL;
1231         _err = DrawThemeStandaloneGrowBox(origin,
1232                                           growDirection,
1233                                           isSmall,
1234                                           state);
1235         if (_err != noErr) return PyMac_Error(_err);
1236         Py_INCREF(Py_None);
1237         _res = Py_None;
1238         return _res;
1239 }
1240
1241 static PyObject *App_DrawThemeStandaloneNoGrowBox(PyObject *_self, PyObject *_args)
1242 {
1243         PyObject *_res = NULL;
1244         OSStatus _err;
1245         Point origin;
1246         ThemeGrowDirection growDirection;
1247         Boolean isSmall;
1248         ThemeDrawState state;
1249         if (!PyArg_ParseTuple(_args, "O&Hbl",
1250                               PyMac_GetPoint, &origin,
1251                               &growDirection,
1252                               &isSmall,
1253                               &state))
1254                 return NULL;
1255         _err = DrawThemeStandaloneNoGrowBox(origin,
1256                                             growDirection,
1257                                             isSmall,
1258                                             state);
1259         if (_err != noErr) return PyMac_Error(_err);
1260         Py_INCREF(Py_None);
1261         _res = Py_None;
1262         return _res;
1263 }
1264
1265 static PyObject *App_GetThemeStandaloneGrowBoxBounds(PyObject *_self, PyObject *_args)
1266 {
1267         PyObject *_res = NULL;
1268         OSStatus _err;
1269         Point origin;
1270         ThemeGrowDirection growDirection;
1271         Boolean isSmall;
1272         Rect bounds;
1273         if (!PyArg_ParseTuple(_args, "O&Hb",
1274                               PyMac_GetPoint, &origin,
1275                               &growDirection,
1276                               &isSmall))
1277                 return NULL;
1278         _err = GetThemeStandaloneGrowBoxBounds(origin,
1279                                                growDirection,
1280                                                isSmall,
1281                                                &bounds);
1282         if (_err != noErr) return PyMac_Error(_err);
1283         _res = Py_BuildValue("O&",
1284                              PyMac_BuildRect, &bounds);
1285         return _res;
1286 }
1287
1288 static PyObject *App_NormalizeThemeDrawingState(PyObject *_self, PyObject *_args)
1289 {
1290         PyObject *_res = NULL;
1291         OSStatus _err;
1292         if (!PyArg_ParseTuple(_args, ""))
1293                 return NULL;
1294         _err = NormalizeThemeDrawingState();
1295         if (_err != noErr) return PyMac_Error(_err);
1296         Py_INCREF(Py_None);
1297         _res = Py_None;
1298         return _res;
1299 }
1300
1301 static PyObject *App_GetThemeDrawingState(PyObject *_self, PyObject *_args)
1302 {
1303         PyObject *_res = NULL;
1304         OSStatus _err;
1305         ThemeDrawingState outState;
1306         if (!PyArg_ParseTuple(_args, ""))
1307                 return NULL;
1308         _err = GetThemeDrawingState(&outState);
1309         if (_err != noErr) return PyMac_Error(_err);
1310         _res = Py_BuildValue("O&",
1311                              ThemeDrawingStateObj_New, outState);
1312         return _res;
1313 }
1314
1315 static PyObject *App_ApplyThemeBackground(PyObject *_self, PyObject *_args)
1316 {
1317         PyObject *_res = NULL;
1318         OSStatus _err;
1319         ThemeBackgroundKind inKind;
1320         Rect bounds;
1321         ThemeDrawState inState;
1322         SInt16 inDepth;
1323         Boolean inColorDev;
1324         if (!PyArg_ParseTuple(_args, "lO&lhb",
1325                               &inKind,
1326                               PyMac_GetRect, &bounds,
1327                               &inState,
1328                               &inDepth,
1329                               &inColorDev))
1330                 return NULL;
1331         _err = ApplyThemeBackground(inKind,
1332                                     &bounds,
1333                                     inState,
1334                                     inDepth,
1335                                     inColorDev);
1336         if (_err != noErr) return PyMac_Error(_err);
1337         Py_INCREF(Py_None);
1338         _res = Py_None;
1339         return _res;
1340 }
1341
1342 static PyObject *App_SetThemeTextColorForWindow(PyObject *_self, PyObject *_args)
1343 {
1344         PyObject *_res = NULL;
1345         OSStatus _err;
1346         WindowPtr window;
1347         Boolean isActive;
1348         SInt16 depth;
1349         Boolean isColorDev;
1350         if (!PyArg_ParseTuple(_args, "O&bhb",
1351                               WinObj_Convert, &window,
1352                               &isActive,
1353                               &depth,
1354                               &isColorDev))
1355                 return NULL;
1356         _err = SetThemeTextColorForWindow(window,
1357                                           isActive,
1358                                           depth,
1359                                           isColorDev);
1360         if (_err != noErr) return PyMac_Error(_err);
1361         Py_INCREF(Py_None);
1362         _res = Py_None;
1363         return _res;
1364 }
1365
1366 static PyObject *App_IsValidAppearanceFileType(PyObject *_self, PyObject *_args)
1367 {
1368         PyObject *_res = NULL;
1369         Boolean _rv;
1370         OSType fileType;
1371         if (!PyArg_ParseTuple(_args, "O&",
1372                               PyMac_GetOSType, &fileType))
1373                 return NULL;
1374         _rv = IsValidAppearanceFileType(fileType);
1375         _res = Py_BuildValue("b",
1376                              _rv);
1377         return _res;
1378 }
1379
1380 static PyObject *App_GetThemeBrushAsColor(PyObject *_self, PyObject *_args)
1381 {
1382         PyObject *_res = NULL;
1383         OSStatus _err;
1384         ThemeBrush inBrush;
1385         SInt16 inDepth;
1386         Boolean inColorDev;
1387         RGBColor outColor;
1388         if (!PyArg_ParseTuple(_args, "hhb",
1389                               &inBrush,
1390                               &inDepth,
1391                               &inColorDev))
1392                 return NULL;
1393         _err = GetThemeBrushAsColor(inBrush,
1394                                     inDepth,
1395                                     inColorDev,
1396                                     &outColor);
1397         if (_err != noErr) return PyMac_Error(_err);
1398         _res = Py_BuildValue("O&",
1399                              QdRGB_New, &outColor);
1400         return _res;
1401 }
1402
1403 static PyObject *App_GetThemeTextColor(PyObject *_self, PyObject *_args)
1404 {
1405         PyObject *_res = NULL;
1406         OSStatus _err;
1407         ThemeTextColor inColor;
1408         SInt16 inDepth;
1409         Boolean inColorDev;
1410         RGBColor outColor;
1411         if (!PyArg_ParseTuple(_args, "hhb",
1412                               &inColor,
1413                               &inDepth,
1414                               &inColorDev))
1415                 return NULL;
1416         _err = GetThemeTextColor(inColor,
1417                                  inDepth,
1418                                  inColorDev,
1419                                  &outColor);
1420         if (_err != noErr) return PyMac_Error(_err);
1421         _res = Py_BuildValue("O&",
1422                              QdRGB_New, &outColor);
1423         return _res;
1424 }
1425
1426 #if TARGET_API_MAC_CARBON
1427
1428 static PyObject *App_GetThemeMetric(PyObject *_self, PyObject *_args)
1429 {
1430         PyObject *_res = NULL;
1431         OSStatus _err;
1432         ThemeMetric inMetric;
1433         SInt32 outMetric;
1434         if (!PyArg_ParseTuple(_args, "l",
1435                               &inMetric))
1436                 return NULL;
1437         _err = GetThemeMetric(inMetric,
1438                               &outMetric);
1439         if (_err != noErr) return PyMac_Error(_err);
1440         _res = Py_BuildValue("l",
1441                              outMetric);
1442         return _res;
1443 }
1444 #endif
1445
1446 static PyMethodDef App_methods[] = {
1447         {"RegisterAppearanceClient", (PyCFunction)App_RegisterAppearanceClient, 1,
1448          "() -> None"},
1449         {"UnregisterAppearanceClient", (PyCFunction)App_UnregisterAppearanceClient, 1,
1450          "() -> None"},
1451         {"SetThemePen", (PyCFunction)App_SetThemePen, 1,
1452          "(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None"},
1453         {"SetThemeBackground", (PyCFunction)App_SetThemeBackground, 1,
1454          "(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None"},
1455         {"SetThemeTextColor", (PyCFunction)App_SetThemeTextColor, 1,
1456          "(ThemeTextColor inColor, SInt16 inDepth, Boolean inIsColorDevice) -> None"},
1457         {"SetThemeWindowBackground", (PyCFunction)App_SetThemeWindowBackground, 1,
1458          "(WindowPtr inWindow, ThemeBrush inBrush, Boolean inUpdate) -> None"},
1459         {"DrawThemeWindowHeader", (PyCFunction)App_DrawThemeWindowHeader, 1,
1460          "(Rect inRect, ThemeDrawState inState) -> None"},
1461         {"DrawThemeWindowListViewHeader", (PyCFunction)App_DrawThemeWindowListViewHeader, 1,
1462          "(Rect inRect, ThemeDrawState inState) -> None"},
1463         {"DrawThemePlacard", (PyCFunction)App_DrawThemePlacard, 1,
1464          "(Rect inRect, ThemeDrawState inState) -> None"},
1465         {"DrawThemeEditTextFrame", (PyCFunction)App_DrawThemeEditTextFrame, 1,
1466          "(Rect inRect, ThemeDrawState inState) -> None"},
1467         {"DrawThemeListBoxFrame", (PyCFunction)App_DrawThemeListBoxFrame, 1,
1468          "(Rect inRect, ThemeDrawState inState) -> None"},
1469         {"DrawThemeFocusRect", (PyCFunction)App_DrawThemeFocusRect, 1,
1470          "(Rect inRect, Boolean inHasFocus) -> None"},
1471         {"DrawThemePrimaryGroup", (PyCFunction)App_DrawThemePrimaryGroup, 1,
1472          "(Rect inRect, ThemeDrawState inState) -> None"},
1473         {"DrawThemeSecondaryGroup", (PyCFunction)App_DrawThemeSecondaryGroup, 1,
1474          "(Rect inRect, ThemeDrawState inState) -> None"},
1475         {"DrawThemeSeparator", (PyCFunction)App_DrawThemeSeparator, 1,
1476          "(Rect inRect, ThemeDrawState inState) -> None"},
1477         {"DrawThemeModelessDialogFrame", (PyCFunction)App_DrawThemeModelessDialogFrame, 1,
1478          "(Rect inRect, ThemeDrawState inState) -> None"},
1479         {"DrawThemeGenericWell", (PyCFunction)App_DrawThemeGenericWell, 1,
1480          "(Rect inRect, ThemeDrawState inState, Boolean inFillCenter) -> None"},
1481         {"DrawThemeFocusRegion", (PyCFunction)App_DrawThemeFocusRegion, 1,
1482          "(Boolean inHasFocus) -> None"},
1483         {"IsThemeInColor", (PyCFunction)App_IsThemeInColor, 1,
1484          "(SInt16 inDepth, Boolean inIsColorDevice) -> (Boolean _rv)"},
1485         {"GetThemeAccentColors", (PyCFunction)App_GetThemeAccentColors, 1,
1486          "() -> (CTabHandle outColors)"},
1487         {"DrawThemeMenuBarBackground", (PyCFunction)App_DrawThemeMenuBarBackground, 1,
1488          "(Rect inBounds, ThemeMenuBarState inState, UInt32 inAttributes) -> None"},
1489         {"GetThemeMenuBarHeight", (PyCFunction)App_GetThemeMenuBarHeight, 1,
1490          "() -> (SInt16 outHeight)"},
1491         {"DrawThemeMenuBackground", (PyCFunction)App_DrawThemeMenuBackground, 1,
1492          "(Rect inMenuRect, ThemeMenuType inMenuType) -> None"},
1493         {"GetThemeMenuBackgroundRegion", (PyCFunction)App_GetThemeMenuBackgroundRegion, 1,
1494          "(Rect inMenuRect, ThemeMenuType menuType) -> None"},
1495         {"DrawThemeMenuSeparator", (PyCFunction)App_DrawThemeMenuSeparator, 1,
1496          "(Rect inItemRect) -> None"},
1497         {"GetThemeMenuSeparatorHeight", (PyCFunction)App_GetThemeMenuSeparatorHeight, 1,
1498          "() -> (SInt16 outHeight)"},
1499         {"GetThemeMenuItemExtra", (PyCFunction)App_GetThemeMenuItemExtra, 1,
1500          "(ThemeMenuItemType inItemType) -> (SInt16 outHeight, SInt16 outWidth)"},
1501         {"GetThemeMenuTitleExtra", (PyCFunction)App_GetThemeMenuTitleExtra, 1,
1502          "(Boolean inIsSquished) -> (SInt16 outWidth)"},
1503         {"DrawThemeTabPane", (PyCFunction)App_DrawThemeTabPane, 1,
1504          "(Rect inRect, ThemeDrawState inState) -> None"},
1505         {"GetThemeTabRegion", (PyCFunction)App_GetThemeTabRegion, 1,
1506          "(Rect inRect, ThemeTabStyle inStyle, ThemeTabDirection inDirection) -> None"},
1507         {"SetThemeCursor", (PyCFunction)App_SetThemeCursor, 1,
1508          "(ThemeCursor inCursor) -> None"},
1509         {"SetAnimatedThemeCursor", (PyCFunction)App_SetAnimatedThemeCursor, 1,
1510          "(ThemeCursor inCursor, UInt32 inAnimationStep) -> None"},
1511         {"GetThemeScrollBarThumbStyle", (PyCFunction)App_GetThemeScrollBarThumbStyle, 1,
1512          "() -> (ThemeScrollBarThumbStyle outStyle)"},
1513         {"GetThemeScrollBarArrowStyle", (PyCFunction)App_GetThemeScrollBarArrowStyle, 1,
1514          "() -> (ThemeScrollBarArrowStyle outStyle)"},
1515         {"GetThemeCheckBoxStyle", (PyCFunction)App_GetThemeCheckBoxStyle, 1,
1516          "() -> (ThemeCheckBoxStyle outStyle)"},
1517         {"UseThemeFont", (PyCFunction)App_UseThemeFont, 1,
1518          "(ThemeFontID inFontID, ScriptCode inScript) -> None"},
1519
1520 #if TARGET_API_MAC_CARBON
1521         {"DrawThemeTextBox", (PyCFunction)App_DrawThemeTextBox, 1,
1522          "(CFStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, Boolean inWrapToWidth, Rect inBoundingBox, SInt16 inJust) -> None"},
1523 #endif
1524
1525 #if TARGET_API_MAC_CARBON
1526         {"TruncateThemeText", (PyCFunction)App_TruncateThemeText, 1,
1527          "(CFMutableStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, SInt16 inPixelWidthLimit, TruncCode inTruncWhere) -> (Boolean outTruncated)"},
1528 #endif
1529
1530 #if TARGET_API_MAC_CARBON
1531         {"GetThemeTextDimensions", (PyCFunction)App_GetThemeTextDimensions, 1,
1532          "(CFStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, Boolean inWrapToWidth, Point ioBounds) -> (Point ioBounds, SInt16 outBaseline)"},
1533 #endif
1534
1535 #if TARGET_API_MAC_CARBON
1536         {"GetThemeTextShadowOutset", (PyCFunction)App_GetThemeTextShadowOutset, 1,
1537          "(ThemeFontID inFontID, ThemeDrawState inState) -> (Rect outOutset)"},
1538 #endif
1539         {"DrawThemeScrollBarArrows", (PyCFunction)App_DrawThemeScrollBarArrows, 1,
1540          "(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)"},
1541         {"GetThemeScrollBarTrackRect", (PyCFunction)App_GetThemeScrollBarTrackRect, 1,
1542          "(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)"},
1543         {"HitTestThemeScrollBarArrows", (PyCFunction)App_HitTestThemeScrollBarArrows, 1,
1544          "(Rect scrollBarBounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz, Point ptHit) -> (Boolean _rv, Rect trackBounds, ControlPartCode partcode)"},
1545         {"DrawThemeScrollBarDelimiters", (PyCFunction)App_DrawThemeScrollBarDelimiters, 1,
1546          "(ThemeWindowType flavor, Rect inContRect, ThemeDrawState state, ThemeWindowAttributes attributes) -> None"},
1547         {"DrawThemeButton", (PyCFunction)App_DrawThemeButton, 1,
1548          "(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inNewInfo, ThemeButtonDrawInfo inPrevInfo, UInt32 inUserData) -> None"},
1549         {"GetThemeButtonRegion", (PyCFunction)App_GetThemeButtonRegion, 1,
1550          "(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inNewInfo) -> None"},
1551         {"GetThemeButtonContentBounds", (PyCFunction)App_GetThemeButtonContentBounds, 1,
1552          "(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inDrawInfo) -> (Rect outBounds)"},
1553         {"GetThemeButtonBackgroundBounds", (PyCFunction)App_GetThemeButtonBackgroundBounds, 1,
1554          "(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inDrawInfo) -> (Rect outBounds)"},
1555         {"PlayThemeSound", (PyCFunction)App_PlayThemeSound, 1,
1556          "(ThemeSoundKind kind) -> None"},
1557         {"BeginThemeDragSound", (PyCFunction)App_BeginThemeDragSound, 1,
1558          "(ThemeDragSoundKind kind) -> None"},
1559         {"EndThemeDragSound", (PyCFunction)App_EndThemeDragSound, 1,
1560          "() -> None"},
1561         {"DrawThemeTickMark", (PyCFunction)App_DrawThemeTickMark, 1,
1562          "(Rect bounds, ThemeDrawState state) -> None"},
1563         {"DrawThemeChasingArrows", (PyCFunction)App_DrawThemeChasingArrows, 1,
1564          "(Rect bounds, UInt32 index, ThemeDrawState state, UInt32 eraseData) -> None"},
1565         {"DrawThemePopupArrow", (PyCFunction)App_DrawThemePopupArrow, 1,
1566          "(Rect bounds, ThemeArrowOrientation orientation, ThemePopupArrowSize size, ThemeDrawState state, UInt32 eraseData) -> None"},
1567         {"DrawThemeStandaloneGrowBox", (PyCFunction)App_DrawThemeStandaloneGrowBox, 1,
1568          "(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None"},
1569         {"DrawThemeStandaloneNoGrowBox", (PyCFunction)App_DrawThemeStandaloneNoGrowBox, 1,
1570          "(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None"},
1571         {"GetThemeStandaloneGrowBoxBounds", (PyCFunction)App_GetThemeStandaloneGrowBoxBounds, 1,
1572          "(Point origin, ThemeGrowDirection growDirection, Boolean isSmall) -> (Rect bounds)"},
1573         {"NormalizeThemeDrawingState", (PyCFunction)App_NormalizeThemeDrawingState, 1,
1574          "() -> None"},
1575         {"GetThemeDrawingState", (PyCFunction)App_GetThemeDrawingState, 1,
1576          "() -> (ThemeDrawingState outState)"},
1577         {"ApplyThemeBackground", (PyCFunction)App_ApplyThemeBackground, 1,
1578          "(ThemeBackgroundKind inKind, Rect bounds, ThemeDrawState inState, SInt16 inDepth, Boolean inColorDev) -> None"},
1579         {"SetThemeTextColorForWindow", (PyCFunction)App_SetThemeTextColorForWindow, 1,
1580          "(WindowPtr window, Boolean isActive, SInt16 depth, Boolean isColorDev) -> None"},
1581         {"IsValidAppearanceFileType", (PyCFunction)App_IsValidAppearanceFileType, 1,
1582          "(OSType fileType) -> (Boolean _rv)"},
1583         {"GetThemeBrushAsColor", (PyCFunction)App_GetThemeBrushAsColor, 1,
1584          "(ThemeBrush inBrush, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)"},
1585         {"GetThemeTextColor", (PyCFunction)App_GetThemeTextColor, 1,
1586          "(ThemeTextColor inColor, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)"},
1587
1588 #if TARGET_API_MAC_CARBON
1589         {"GetThemeMetric", (PyCFunction)App_GetThemeMetric, 1,
1590          "(ThemeMetric inMetric) -> (SInt32 outMetric)"},
1591 #endif
1592         {NULL, NULL, 0}
1593 };
1594
1595
1596
1597
1598 void init_App(void)
1599 {
1600         PyObject *m;
1601         PyObject *d;
1602
1603
1604
1605
1606         m = Py_InitModule("_App", App_methods);
1607         d = PyModule_GetDict(m);
1608         App_Error = PyMac_GetOSErrException();
1609         if (App_Error == NULL ||
1610             PyDict_SetItemString(d, "Error", App_Error) != 0)
1611                 return;
1612         ThemeDrawingState_Type.ob_type = &PyType_Type;
1613         Py_INCREF(&ThemeDrawingState_Type);
1614         if (PyDict_SetItemString(d, "ThemeDrawingStateType", (PyObject *)&ThemeDrawingState_Type) != 0)
1615                 Py_FatalError("can't initialize ThemeDrawingStateType");
1616 }
1617
1618 /* ======================== End module _App ========================= */
1619