1 

     2 /* ========================== Module _Ctl =========================== */

     3 

     4 #include "Python.h"

     5 

     6 #ifndef __LP64__

     7 

     8 

     9 #include "pymactoolbox.h"

    10 

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

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

    13         PyErr_SetString(PyExc_NotImplementedError, \

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

    15         return NULL; \

    16     }} while(0)

    17 

    18 

    19 #include <Carbon/Carbon.h>

    20 

    21 #ifdef USE_TOOLBOX_OBJECT_GLUE

    22 extern PyObject *_CtlObj_New(ControlHandle);

    23 extern int _CtlObj_Convert(PyObject *, ControlHandle *);

    24 

    25 #define CtlObj_New _CtlObj_New

    26 #define CtlObj_Convert _CtlObj_Convert

    27 #endif

    28 

    29 static PyObject *CtlObj_WhichControl(ControlHandle);

    30 

    31 #define as_Control(h) ((ControlHandle)h)

    32 #define as_Resource(ctl) ((Handle)ctl)

    33 #define GetControlRect(ctl, rectp) GetControlBounds(ctl, rectp)

    34 

    35 #define MAXTABS 32  /* maximum number of tabs that we support in a tabs control */

    36 /*

    37 ** Parse/generate ControlFontStyleRec records

    38 */

    39 #if 0 /* Not needed */

    40 static PyObject *

    41 ControlFontStyle_New(ControlFontStyleRec *itself)

    42 {

    43 

    44         return Py_BuildValue("hhhhhhO&O&", itself->flags, itself->font,

    45                 itself->size, itself->style, itself->mode, itself->just,

    46                 QdRGB_New, &itself->foreColor, QdRGB_New, &itself->backColor);

    47 }

    48 #endif

    49 

    50 static int

    51 ControlFontStyle_Convert(PyObject *v, ControlFontStyleRec *itself)

    52 {

    53         return PyArg_Parse(v, "(hhhhhhO&O&)", &itself->flags,

    54                 &itself->font, &itself->size, &itself->style, &itself->mode,

    55                 &itself->just, QdRGB_Convert, &itself->foreColor,

    56                 QdRGB_Convert, &itself->backColor);

    57 }

    58 

    59 /*

    60 ** Parse/generate ControlID records

    61 */

    62 static PyObject *

    63 PyControlID_New(ControlID *itself)

    64 {

    65 

    66         return Py_BuildValue("O&l", PyMac_BuildOSType, itself->signature, itself->id);

    67 }

    68 

    69 static int

    70 PyControlID_Convert(PyObject *v, ControlID *itself)

    71 {

    72         return PyArg_Parse(v, "(O&l)", PyMac_GetOSType, &itself->signature, &itself->id);

    73 }

    74 

    75 /*

    76 ** generate DataBrowserListViewColumnDesc records

    77 */

    78 static int

    79 DataBrowserTableViewColumnDesc_Convert(PyObject *v, DataBrowserTableViewColumnDesc *itself)

    80 {

    81         return PyArg_Parse(v, "(lO&l)",

    82                            &itself->propertyID,

    83                            PyMac_GetOSType, &itself->propertyType,

    84                            &itself->propertyFlags);

    85 }

    86 

    87 static int

    88 ControlButtonContentInfo_Convert(PyObject *v, ControlButtonContentInfo *itself)

    89 {

    90         return PyArg_Parse(v, "(hO&)",

    91                            &itself->contentType,

    92                            OptResObj_Convert, &itself->u.iconSuite);

    93 }

    94 

    95 static int

    96 DataBrowserListViewHeaderDesc_Convert(PyObject *v, DataBrowserListViewHeaderDesc *itself)

    97 {

    98         itself->version = kDataBrowserListViewLatestHeaderDesc;

    99         return PyArg_Parse(v, "(HHhO&HO&O&)",

   100                            &itself->minimumWidth,

   101                            &itself->maximumWidth,

   102                            &itself->titleOffset,

   103                            CFStringRefObj_Convert, &itself->titleString,

   104                            &itself->initialOrder,

   105                            ControlFontStyle_Convert, &itself->btnFontStyle,

   106                            ControlButtonContentInfo_Convert, &itself->btnContentInfo);

   107 }

   108 

   109 static int

   110 DataBrowserListViewColumnDesc_Convert(PyObject *v, DataBrowserListViewColumnDesc *itself)

   111 {

   112         return PyArg_Parse(v, "(O&O&)",

   113                            DataBrowserTableViewColumnDesc_Convert, &itself->propertyDesc,

   114                            DataBrowserListViewHeaderDesc_Convert, &itself->headerBtnDesc);

   115 }

   116 

   117 /* TrackControl and HandleControlClick callback support */

   118 #define kMyControlActionProcTag 'ACTN'  /* not an official tag, only for internal use */

   119 static PyObject *tracker;

   120 static ControlActionUPP mytracker_upp;

   121 static ControlActionUPP myactionproc_upp;

   122 static ControlUserPaneKeyDownUPP mykeydownproc_upp;

   123 static ControlUserPaneFocusUPP myfocusproc_upp;

   124 static ControlUserPaneDrawUPP mydrawproc_upp;

   125 static ControlUserPaneIdleUPP myidleproc_upp;

   126 static ControlUserPaneHitTestUPP myhittestproc_upp;

   127 static ControlUserPaneTrackingUPP mytrackingproc_upp;

   128 

   129 static int settrackfunc(PyObject *);    /* forward */

   130 static void clrtrackfunc(void); /* forward */

   131 static int setcallback(PyObject *, OSType, PyObject *, UniversalProcPtr *);

   132 

   133 static PyObject *Ctl_Error;

   134 

   135 /* ---------------------- Object type Control ----------------------- */

   136 

   137 PyTypeObject Control_Type;

   138 

   139 #define CtlObj_Check(x) ((x)->ob_type == &Control_Type || PyObject_TypeCheck((x), &Control_Type))

   140 

   141 typedef struct ControlObject {

   142 	PyObject_HEAD

   143 	ControlHandle ob_itself;

   144 	PyObject *ob_callbackdict;

   145 } ControlObject;

   146 

   147 PyObject *CtlObj_New(ControlHandle itself)

   148 {

   149 	ControlObject *it;

   150 	if (itself == NULL) return PyMac_Error(resNotFound);

   151 	it = PyObject_NEW(ControlObject, &Control_Type);

   152 	if (it == NULL) return NULL;

   153 	it->ob_itself = itself;

   154 	SetControlReference(itself, (long)it);

   155 	it->ob_callbackdict = NULL;

   156 	return (PyObject *)it;

   157 }

   158 

   159 int CtlObj_Convert(PyObject *v, ControlHandle *p_itself)

   160 {

   161 	if (!CtlObj_Check(v))

   162 	{

   163 		PyErr_SetString(PyExc_TypeError, "Control required");

   164 		return 0;

   165 	}

   166 	*p_itself = ((ControlObject *)v)->ob_itself;

   167 	return 1;

   168 }

   169 

   170 static void CtlObj_dealloc(ControlObject *self)

   171 {

   172 	Py_XDECREF(self->ob_callbackdict);

   173 	if (self->ob_itself)SetControlReference(self->ob_itself, (long)0); /* Make it forget about us */

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

   175 }

   176 

   177 static PyObject *CtlObj_HiliteControl(ControlObject *_self, PyObject *_args)

   178 {

   179 	PyObject *_res = NULL;

   180 	ControlPartCode hiliteState;

   181 #ifndef HiliteControl

   182 	PyMac_PRECHECK(HiliteControl);

   183 #endif

   184 	if (!PyArg_ParseTuple(_args, "h",

   185 	                      &hiliteState))

   186 		return NULL;

   187 	HiliteControl(_self->ob_itself,

   188 	              hiliteState);

   189 	Py_INCREF(Py_None);

   190 	_res = Py_None;

   191 	return _res;

   192 }

   193 

   194 static PyObject *CtlObj_ShowControl(ControlObject *_self, PyObject *_args)

   195 {

   196 	PyObject *_res = NULL;

   197 #ifndef ShowControl

   198 	PyMac_PRECHECK(ShowControl);

   199 #endif

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

   201 		return NULL;

   202 	ShowControl(_self->ob_itself);

   203 	Py_INCREF(Py_None);

   204 	_res = Py_None;

   205 	return _res;

   206 }

   207 

   208 static PyObject *CtlObj_HideControl(ControlObject *_self, PyObject *_args)

   209 {

   210 	PyObject *_res = NULL;

   211 #ifndef HideControl

   212 	PyMac_PRECHECK(HideControl);

   213 #endif

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

   215 		return NULL;

   216 	HideControl(_self->ob_itself);

   217 	Py_INCREF(Py_None);

   218 	_res = Py_None;

   219 	return _res;

   220 }

   221 

   222 static PyObject *CtlObj_IsControlActive(ControlObject *_self, PyObject *_args)

   223 {

   224 	PyObject *_res = NULL;

   225 	Boolean _rv;

   226 #ifndef IsControlActive

   227 	PyMac_PRECHECK(IsControlActive);

   228 #endif

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

   230 		return NULL;

   231 	_rv = IsControlActive(_self->ob_itself);

   232 	_res = Py_BuildValue("b",

   233 	                     _rv);

   234 	return _res;

   235 }

   236 

   237 static PyObject *CtlObj_IsControlVisible(ControlObject *_self, PyObject *_args)

   238 {

   239 	PyObject *_res = NULL;

   240 	Boolean _rv;

   241 #ifndef IsControlVisible

   242 	PyMac_PRECHECK(IsControlVisible);

   243 #endif

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

   245 		return NULL;

   246 	_rv = IsControlVisible(_self->ob_itself);

   247 	_res = Py_BuildValue("b",

   248 	                     _rv);

   249 	return _res;

   250 }

   251 

   252 static PyObject *CtlObj_ActivateControl(ControlObject *_self, PyObject *_args)

   253 {

   254 	PyObject *_res = NULL;

   255 	OSErr _err;

   256 #ifndef ActivateControl

   257 	PyMac_PRECHECK(ActivateControl);

   258 #endif

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

   260 		return NULL;

   261 	_err = ActivateControl(_self->ob_itself);

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

   263 	Py_INCREF(Py_None);

   264 	_res = Py_None;

   265 	return _res;

   266 }

   267 

   268 static PyObject *CtlObj_DeactivateControl(ControlObject *_self, PyObject *_args)

   269 {

   270 	PyObject *_res = NULL;

   271 	OSErr _err;

   272 #ifndef DeactivateControl

   273 	PyMac_PRECHECK(DeactivateControl);

   274 #endif

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

   276 		return NULL;

   277 	_err = DeactivateControl(_self->ob_itself);

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

   279 	Py_INCREF(Py_None);

   280 	_res = Py_None;

   281 	return _res;

   282 }

   283 

   284 static PyObject *CtlObj_SetControlVisibility(ControlObject *_self, PyObject *_args)

   285 {

   286 	PyObject *_res = NULL;

   287 	OSErr _err;

   288 	Boolean inIsVisible;

   289 	Boolean inDoDraw;

   290 #ifndef SetControlVisibility

   291 	PyMac_PRECHECK(SetControlVisibility);

   292 #endif

   293 	if (!PyArg_ParseTuple(_args, "bb",

   294 	                      &inIsVisible,

   295 	                      &inDoDraw))

   296 		return NULL;

   297 	_err = SetControlVisibility(_self->ob_itself,

   298 	                            inIsVisible,

   299 	                            inDoDraw);

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

   301 	Py_INCREF(Py_None);

   302 	_res = Py_None;

   303 	return _res;

   304 }

   305 

   306 static PyObject *CtlObj_IsControlEnabled(ControlObject *_self, PyObject *_args)

   307 {

   308 	PyObject *_res = NULL;

   309 	Boolean _rv;

   310 #ifndef IsControlEnabled

   311 	PyMac_PRECHECK(IsControlEnabled);

   312 #endif

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

   314 		return NULL;

   315 	_rv = IsControlEnabled(_self->ob_itself);

   316 	_res = Py_BuildValue("b",

   317 	                     _rv);

   318 	return _res;

   319 }

   320 

   321 static PyObject *CtlObj_EnableControl(ControlObject *_self, PyObject *_args)

   322 {

   323 	PyObject *_res = NULL;

   324 	OSStatus _err;

   325 #ifndef EnableControl

   326 	PyMac_PRECHECK(EnableControl);

   327 #endif

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

   329 		return NULL;

   330 	_err = EnableControl(_self->ob_itself);

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

   332 	Py_INCREF(Py_None);

   333 	_res = Py_None;

   334 	return _res;

   335 }

   336 

   337 static PyObject *CtlObj_DisableControl(ControlObject *_self, PyObject *_args)

   338 {

   339 	PyObject *_res = NULL;

   340 	OSStatus _err;

   341 #ifndef DisableControl

   342 	PyMac_PRECHECK(DisableControl);

   343 #endif

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

   345 		return NULL;

   346 	_err = DisableControl(_self->ob_itself);

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

   354 {

   355 	PyObject *_res = NULL;

   356 #ifndef Draw1Control

   357 	PyMac_PRECHECK(Draw1Control);

   358 #endif

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

   360 		return NULL;

   361 	Draw1Control(_self->ob_itself);

   362 	Py_INCREF(Py_None);

   363 	_res = Py_None;

   364 	return _res;

   365 }

   366 

   367 static PyObject *CtlObj_GetBestControlRect(ControlObject *_self, PyObject *_args)

   368 {

   369 	PyObject *_res = NULL;

   370 	OSErr _err;

   371 	Rect outRect;

   372 	SInt16 outBaseLineOffset;

   373 #ifndef GetBestControlRect

   374 	PyMac_PRECHECK(GetBestControlRect);

   375 #endif

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

   377 		return NULL;

   378 	_err = GetBestControlRect(_self->ob_itself,

   379 	                          &outRect,

   380 	                          &outBaseLineOffset);

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

   382 	_res = Py_BuildValue("O&h",

   383 	                     PyMac_BuildRect, &outRect,

   384 	                     outBaseLineOffset);

   385 	return _res;

   386 }

   387 

   388 static PyObject *CtlObj_SetControlFontStyle(ControlObject *_self, PyObject *_args)

   389 {

   390 	PyObject *_res = NULL;

   391 	OSErr _err;

   392 	ControlFontStyleRec inStyle;

   393 #ifndef SetControlFontStyle

   394 	PyMac_PRECHECK(SetControlFontStyle);

   395 #endif

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

   397 	                      ControlFontStyle_Convert, &inStyle))

   398 		return NULL;

   399 	_err = SetControlFontStyle(_self->ob_itself,

   400 	                           &inStyle);

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

   402 	Py_INCREF(Py_None);

   403 	_res = Py_None;

   404 	return _res;

   405 }

   406 

   407 static PyObject *CtlObj_DrawControlInCurrentPort(ControlObject *_self, PyObject *_args)

   408 {

   409 	PyObject *_res = NULL;

   410 #ifndef DrawControlInCurrentPort

   411 	PyMac_PRECHECK(DrawControlInCurrentPort);

   412 #endif

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

   414 		return NULL;

   415 	DrawControlInCurrentPort(_self->ob_itself);

   416 	Py_INCREF(Py_None);

   417 	_res = Py_None;

   418 	return _res;

   419 }

   420 

   421 static PyObject *CtlObj_SetUpControlBackground(ControlObject *_self, PyObject *_args)

   422 {

   423 	PyObject *_res = NULL;

   424 	OSErr _err;

   425 	SInt16 inDepth;

   426 	Boolean inIsColorDevice;

   427 #ifndef SetUpControlBackground

   428 	PyMac_PRECHECK(SetUpControlBackground);

   429 #endif

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

   431 	                      &inDepth,

   432 	                      &inIsColorDevice))

   433 		return NULL;

   434 	_err = SetUpControlBackground(_self->ob_itself,

   435 	                              inDepth,

   436 	                              inIsColorDevice);

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

   438 	Py_INCREF(Py_None);

   439 	_res = Py_None;

   440 	return _res;

   441 }

   442 

   443 static PyObject *CtlObj_SetUpControlTextColor(ControlObject *_self, PyObject *_args)

   444 {

   445 	PyObject *_res = NULL;

   446 	OSErr _err;

   447 	SInt16 inDepth;

   448 	Boolean inIsColorDevice;

   449 #ifndef SetUpControlTextColor

   450 	PyMac_PRECHECK(SetUpControlTextColor);

   451 #endif

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

   453 	                      &inDepth,

   454 	                      &inIsColorDevice))

   455 		return NULL;

   456 	_err = SetUpControlTextColor(_self->ob_itself,

   457 	                             inDepth,

   458 	                             inIsColorDevice);

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

   460 	Py_INCREF(Py_None);

   461 	_res = Py_None;

   462 	return _res;

   463 }

   464 

   465 static PyObject *CtlObj_DragControl(ControlObject *_self, PyObject *_args)

   466 {

   467 	PyObject *_res = NULL;

   468 	Point startPoint;

   469 	Rect limitRect;

   470 	Rect slopRect;

   471 	DragConstraint axis;

   472 #ifndef DragControl

   473 	PyMac_PRECHECK(DragControl);

   474 #endif

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

   476 	                      PyMac_GetPoint, &startPoint,

   477 	                      PyMac_GetRect, &limitRect,

   478 	                      PyMac_GetRect, &slopRect,

   479 	                      &axis))

   480 		return NULL;

   481 	DragControl(_self->ob_itself,

   482 	            startPoint,

   483 	            &limitRect,

   484 	            &slopRect,

   485 	            axis);

   486 	Py_INCREF(Py_None);

   487 	_res = Py_None;

   488 	return _res;

   489 }

   490 

   491 static PyObject *CtlObj_TestControl(ControlObject *_self, PyObject *_args)

   492 {

   493 	PyObject *_res = NULL;

   494 	ControlPartCode _rv;

   495 	Point testPoint;

   496 #ifndef TestControl

   497 	PyMac_PRECHECK(TestControl);

   498 #endif

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

   500 	                      PyMac_GetPoint, &testPoint))

   501 		return NULL;

   502 	_rv = TestControl(_self->ob_itself,

   503 	                  testPoint);

   504 	_res = Py_BuildValue("h",

   505 	                     _rv);

   506 	return _res;

   507 }

   508 

   509 static PyObject *CtlObj_HandleControlContextualMenuClick(ControlObject *_self, PyObject *_args)

   510 {

   511 	PyObject *_res = NULL;

   512 	OSStatus _err;

   513 	Point inWhere;

   514 	Boolean menuDisplayed;

   515 #ifndef HandleControlContextualMenuClick

   516 	PyMac_PRECHECK(HandleControlContextualMenuClick);

   517 #endif

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

   519 	                      PyMac_GetPoint, &inWhere))

   520 		return NULL;

   521 	_err = HandleControlContextualMenuClick(_self->ob_itself,

   522 	                                        inWhere,

   523 	                                        &menuDisplayed);

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

   525 	_res = Py_BuildValue("b",

   526 	                     menuDisplayed);

   527 	return _res;

   528 }

   529 

   530 static PyObject *CtlObj_GetControlClickActivation(ControlObject *_self, PyObject *_args)

   531 {

   532 	PyObject *_res = NULL;

   533 	OSStatus _err;

   534 	Point inWhere;

   535 	EventModifiers inModifiers;

   536 	ClickActivationResult outResult;

   537 #ifndef GetControlClickActivation

   538 	PyMac_PRECHECK(GetControlClickActivation);

   539 #endif

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

   541 	                      PyMac_GetPoint, &inWhere,

   542 	                      &inModifiers))

   543 		return NULL;

   544 	_err = GetControlClickActivation(_self->ob_itself,

   545 	                                 inWhere,

   546 	                                 inModifiers,

   547 	                                 &outResult);

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

   549 	_res = Py_BuildValue("l",

   550 	                     outResult);

   551 	return _res;

   552 }

   553 

   554 static PyObject *CtlObj_HandleControlKey(ControlObject *_self, PyObject *_args)

   555 {

   556 	PyObject *_res = NULL;

   557 	ControlPartCode _rv;

   558 	SInt16 inKeyCode;

   559 	SInt16 inCharCode;

   560 	EventModifiers inModifiers;

   561 #ifndef HandleControlKey

   562 	PyMac_PRECHECK(HandleControlKey);

   563 #endif

   564 	if (!PyArg_ParseTuple(_args, "hhH",

   565 	                      &inKeyCode,

   566 	                      &inCharCode,

   567 	                      &inModifiers))

   568 		return NULL;

   569 	_rv = HandleControlKey(_self->ob_itself,

   570 	                       inKeyCode,

   571 	                       inCharCode,

   572 	                       inModifiers);

   573 	_res = Py_BuildValue("h",

   574 	                     _rv);

   575 	return _res;

   576 }

   577 

   578 static PyObject *CtlObj_HandleControlSetCursor(ControlObject *_self, PyObject *_args)

   579 {

   580 	PyObject *_res = NULL;

   581 	OSStatus _err;

   582 	Point localPoint;

   583 	EventModifiers modifiers;

   584 	Boolean cursorWasSet;

   585 #ifndef HandleControlSetCursor

   586 	PyMac_PRECHECK(HandleControlSetCursor);

   587 #endif

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

   589 	                      PyMac_GetPoint, &localPoint,

   590 	                      &modifiers))

   591 		return NULL;

   592 	_err = HandleControlSetCursor(_self->ob_itself,

   593 	                              localPoint,

   594 	                              modifiers,

   595 	                              &cursorWasSet);

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

   597 	_res = Py_BuildValue("b",

   598 	                     cursorWasSet);

   599 	return _res;

   600 }

   601 

   602 static PyObject *CtlObj_MoveControl(ControlObject *_self, PyObject *_args)

   603 {

   604 	PyObject *_res = NULL;

   605 	SInt16 h;

   606 	SInt16 v;

   607 #ifndef MoveControl

   608 	PyMac_PRECHECK(MoveControl);

   609 #endif

   610 	if (!PyArg_ParseTuple(_args, "hh",

   611 	                      &h,

   612 	                      &v))

   613 		return NULL;

   614 	MoveControl(_self->ob_itself,

   615 	            h,

   616 	            v);

   617 	Py_INCREF(Py_None);

   618 	_res = Py_None;

   619 	return _res;

   620 }

   621 

   622 static PyObject *CtlObj_SizeControl(ControlObject *_self, PyObject *_args)

   623 {

   624 	PyObject *_res = NULL;

   625 	SInt16 w;

   626 	SInt16 h;

   627 #ifndef SizeControl

   628 	PyMac_PRECHECK(SizeControl);

   629 #endif

   630 	if (!PyArg_ParseTuple(_args, "hh",

   631 	                      &w,

   632 	                      &h))

   633 		return NULL;

   634 	SizeControl(_self->ob_itself,

   635 	            w,

   636 	            h);

   637 	Py_INCREF(Py_None);

   638 	_res = Py_None;

   639 	return _res;

   640 }

   641 

   642 static PyObject *CtlObj_SetControlTitle(ControlObject *_self, PyObject *_args)

   643 {

   644 	PyObject *_res = NULL;

   645 	Str255 title;

   646 #ifndef SetControlTitle

   647 	PyMac_PRECHECK(SetControlTitle);

   648 #endif

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

   650 	                      PyMac_GetStr255, title))

   651 		return NULL;

   652 	SetControlTitle(_self->ob_itself,

   653 	                title);

   654 	Py_INCREF(Py_None);

   655 	_res = Py_None;

   656 	return _res;

   657 }

   658 

   659 static PyObject *CtlObj_GetControlTitle(ControlObject *_self, PyObject *_args)

   660 {

   661 	PyObject *_res = NULL;

   662 	Str255 title;

   663 #ifndef GetControlTitle

   664 	PyMac_PRECHECK(GetControlTitle);

   665 #endif

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

   667 		return NULL;

   668 	GetControlTitle(_self->ob_itself,

   669 	                title);

   670 	_res = Py_BuildValue("O&",

   671 	                     PyMac_BuildStr255, title);

   672 	return _res;

   673 }

   674 

   675 static PyObject *CtlObj_SetControlTitleWithCFString(ControlObject *_self, PyObject *_args)

   676 {

   677 	PyObject *_res = NULL;

   678 	OSStatus _err;

   679 	CFStringRef inString;

   680 #ifndef SetControlTitleWithCFString

   681 	PyMac_PRECHECK(SetControlTitleWithCFString);

   682 #endif

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

   684 	                      CFStringRefObj_Convert, &inString))

   685 		return NULL;

   686 	_err = SetControlTitleWithCFString(_self->ob_itself,

   687 	                                   inString);

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

   689 	Py_INCREF(Py_None);

   690 	_res = Py_None;

   691 	return _res;

   692 }

   693 

   694 static PyObject *CtlObj_CopyControlTitleAsCFString(ControlObject *_self, PyObject *_args)

   695 {

   696 	PyObject *_res = NULL;

   697 	OSStatus _err;

   698 	CFStringRef outString;

   699 #ifndef CopyControlTitleAsCFString

   700 	PyMac_PRECHECK(CopyControlTitleAsCFString);

   701 #endif

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

   703 		return NULL;

   704 	_err = CopyControlTitleAsCFString(_self->ob_itself,

   705 	                                  &outString);

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

   707 	_res = Py_BuildValue("O&",

   708 	                     CFStringRefObj_New, outString);

   709 	return _res;

   710 }

   711 

   712 static PyObject *CtlObj_GetControlValue(ControlObject *_self, PyObject *_args)

   713 {

   714 	PyObject *_res = NULL;

   715 	SInt16 _rv;

   716 #ifndef GetControlValue

   717 	PyMac_PRECHECK(GetControlValue);

   718 #endif

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

   720 		return NULL;

   721 	_rv = GetControlValue(_self->ob_itself);

   722 	_res = Py_BuildValue("h",

   723 	                     _rv);

   724 	return _res;

   725 }

   726 

   727 static PyObject *CtlObj_SetControlValue(ControlObject *_self, PyObject *_args)

   728 {

   729 	PyObject *_res = NULL;

   730 	SInt16 newValue;

   731 #ifndef SetControlValue

   732 	PyMac_PRECHECK(SetControlValue);

   733 #endif

   734 	if (!PyArg_ParseTuple(_args, "h",

   735 	                      &newValue))

   736 		return NULL;

   737 	SetControlValue(_self->ob_itself,

   738 	                newValue);

   739 	Py_INCREF(Py_None);

   740 	_res = Py_None;

   741 	return _res;

   742 }

   743 

   744 static PyObject *CtlObj_GetControlMinimum(ControlObject *_self, PyObject *_args)

   745 {

   746 	PyObject *_res = NULL;

   747 	SInt16 _rv;

   748 #ifndef GetControlMinimum

   749 	PyMac_PRECHECK(GetControlMinimum);

   750 #endif

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

   752 		return NULL;

   753 	_rv = GetControlMinimum(_self->ob_itself);

   754 	_res = Py_BuildValue("h",

   755 	                     _rv);

   756 	return _res;

   757 }

   758 

   759 static PyObject *CtlObj_SetControlMinimum(ControlObject *_self, PyObject *_args)

   760 {

   761 	PyObject *_res = NULL;

   762 	SInt16 newMinimum;

   763 #ifndef SetControlMinimum

   764 	PyMac_PRECHECK(SetControlMinimum);

   765 #endif

   766 	if (!PyArg_ParseTuple(_args, "h",

   767 	                      &newMinimum))

   768 		return NULL;

   769 	SetControlMinimum(_self->ob_itself,

   770 	                  newMinimum);

   771 	Py_INCREF(Py_None);

   772 	_res = Py_None;

   773 	return _res;

   774 }

   775 

   776 static PyObject *CtlObj_GetControlMaximum(ControlObject *_self, PyObject *_args)

   777 {

   778 	PyObject *_res = NULL;

   779 	SInt16 _rv;

   780 #ifndef GetControlMaximum

   781 	PyMac_PRECHECK(GetControlMaximum);

   782 #endif

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

   784 		return NULL;

   785 	_rv = GetControlMaximum(_self->ob_itself);

   786 	_res = Py_BuildValue("h",

   787 	                     _rv);

   788 	return _res;

   789 }

   790 

   791 static PyObject *CtlObj_SetControlMaximum(ControlObject *_self, PyObject *_args)

   792 {

   793 	PyObject *_res = NULL;

   794 	SInt16 newMaximum;

   795 #ifndef SetControlMaximum

   796 	PyMac_PRECHECK(SetControlMaximum);

   797 #endif

   798 	if (!PyArg_ParseTuple(_args, "h",

   799 	                      &newMaximum))

   800 		return NULL;

   801 	SetControlMaximum(_self->ob_itself,

   802 	                  newMaximum);

   803 	Py_INCREF(Py_None);

   804 	_res = Py_None;

   805 	return _res;

   806 }

   807 

   808 static PyObject *CtlObj_GetControlViewSize(ControlObject *_self, PyObject *_args)

   809 {

   810 	PyObject *_res = NULL;

   811 	SInt32 _rv;

   812 #ifndef GetControlViewSize

   813 	PyMac_PRECHECK(GetControlViewSize);

   814 #endif

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

   816 		return NULL;

   817 	_rv = GetControlViewSize(_self->ob_itself);

   818 	_res = Py_BuildValue("l",

   819 	                     _rv);

   820 	return _res;

   821 }

   822 

   823 static PyObject *CtlObj_SetControlViewSize(ControlObject *_self, PyObject *_args)

   824 {

   825 	PyObject *_res = NULL;

   826 	SInt32 newViewSize;

   827 #ifndef SetControlViewSize

   828 	PyMac_PRECHECK(SetControlViewSize);

   829 #endif

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

   831 	                      &newViewSize))

   832 		return NULL;

   833 	SetControlViewSize(_self->ob_itself,

   834 	                   newViewSize);

   835 	Py_INCREF(Py_None);

   836 	_res = Py_None;

   837 	return _res;

   838 }

   839 

   840 static PyObject *CtlObj_GetControl32BitValue(ControlObject *_self, PyObject *_args)

   841 {

   842 	PyObject *_res = NULL;

   843 	SInt32 _rv;

   844 #ifndef GetControl32BitValue

   845 	PyMac_PRECHECK(GetControl32BitValue);

   846 #endif

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

   848 		return NULL;

   849 	_rv = GetControl32BitValue(_self->ob_itself);

   850 	_res = Py_BuildValue("l",

   851 	                     _rv);

   852 	return _res;

   853 }

   854 

   855 static PyObject *CtlObj_SetControl32BitValue(ControlObject *_self, PyObject *_args)

   856 {

   857 	PyObject *_res = NULL;

   858 	SInt32 newValue;

   859 #ifndef SetControl32BitValue

   860 	PyMac_PRECHECK(SetControl32BitValue);

   861 #endif

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

   863 	                      &newValue))

   864 		return NULL;

   865 	SetControl32BitValue(_self->ob_itself,

   866 	                     newValue);

   867 	Py_INCREF(Py_None);

   868 	_res = Py_None;

   869 	return _res;

   870 }

   871 

   872 static PyObject *CtlObj_GetControl32BitMaximum(ControlObject *_self, PyObject *_args)

   873 {

   874 	PyObject *_res = NULL;

   875 	SInt32 _rv;

   876 #ifndef GetControl32BitMaximum

   877 	PyMac_PRECHECK(GetControl32BitMaximum);

   878 #endif

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

   880 		return NULL;

   881 	_rv = GetControl32BitMaximum(_self->ob_itself);

   882 	_res = Py_BuildValue("l",

   883 	                     _rv);

   884 	return _res;

   885 }

   886 

   887 static PyObject *CtlObj_SetControl32BitMaximum(ControlObject *_self, PyObject *_args)

   888 {

   889 	PyObject *_res = NULL;

   890 	SInt32 newMaximum;

   891 #ifndef SetControl32BitMaximum

   892 	PyMac_PRECHECK(SetControl32BitMaximum);

   893 #endif

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

   895 	                      &newMaximum))

   896 		return NULL;

   897 	SetControl32BitMaximum(_self->ob_itself,

   898 	                       newMaximum);

   899 	Py_INCREF(Py_None);

   900 	_res = Py_None;

   901 	return _res;

   902 }

   903 

   904 static PyObject *CtlObj_GetControl32BitMinimum(ControlObject *_self, PyObject *_args)

   905 {

   906 	PyObject *_res = NULL;

   907 	SInt32 _rv;

   908 #ifndef GetControl32BitMinimum

   909 	PyMac_PRECHECK(GetControl32BitMinimum);

   910 #endif

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

   912 		return NULL;

   913 	_rv = GetControl32BitMinimum(_self->ob_itself);

   914 	_res = Py_BuildValue("l",

   915 	                     _rv);

   916 	return _res;

   917 }

   918 

   919 static PyObject *CtlObj_SetControl32BitMinimum(ControlObject *_self, PyObject *_args)

   920 {

   921 	PyObject *_res = NULL;

   922 	SInt32 newMinimum;

   923 #ifndef SetControl32BitMinimum

   924 	PyMac_PRECHECK(SetControl32BitMinimum);

   925 #endif

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

   927 	                      &newMinimum))

   928 		return NULL;

   929 	SetControl32BitMinimum(_self->ob_itself,

   930 	                       newMinimum);

   931 	Py_INCREF(Py_None);

   932 	_res = Py_None;

   933 	return _res;

   934 }

   935 

   936 static PyObject *CtlObj_IsValidControlHandle(ControlObject *_self, PyObject *_args)

   937 {

   938 	PyObject *_res = NULL;

   939 	Boolean _rv;

   940 #ifndef IsValidControlHandle

   941 	PyMac_PRECHECK(IsValidControlHandle);

   942 #endif

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

   944 		return NULL;

   945 	_rv = IsValidControlHandle(_self->ob_itself);

   946 	_res = Py_BuildValue("b",

   947 	                     _rv);

   948 	return _res;

   949 }

   950 

   951 static PyObject *CtlObj_SetControlID(ControlObject *_self, PyObject *_args)

   952 {

   953 	PyObject *_res = NULL;

   954 	OSStatus _err;

   955 	ControlID inID;

   956 #ifndef SetControlID

   957 	PyMac_PRECHECK(SetControlID);

   958 #endif

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

   960 	                      PyControlID_Convert, &inID))

   961 		return NULL;

   962 	_err = SetControlID(_self->ob_itself,

   963 	                    &inID);

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

   965 	Py_INCREF(Py_None);

   966 	_res = Py_None;

   967 	return _res;

   968 }

   969 

   970 static PyObject *CtlObj_GetControlID(ControlObject *_self, PyObject *_args)

   971 {

   972 	PyObject *_res = NULL;

   973 	OSStatus _err;

   974 	ControlID outID;

   975 #ifndef GetControlID

   976 	PyMac_PRECHECK(GetControlID);

   977 #endif

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

   979 		return NULL;

   980 	_err = GetControlID(_self->ob_itself,

   981 	                    &outID);

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

   983 	_res = Py_BuildValue("O&",

   984 	                     PyControlID_New, &outID);

   985 	return _res;

   986 }

   987 

   988 static PyObject *CtlObj_SetControlCommandID(ControlObject *_self, PyObject *_args)

   989 {

   990 	PyObject *_res = NULL;

   991 	OSStatus _err;

   992 	UInt32 inCommandID;

   993 #ifndef SetControlCommandID

   994 	PyMac_PRECHECK(SetControlCommandID);

   995 #endif

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

   997 	                      &inCommandID))

   998 		return NULL;

   999 	_err = SetControlCommandID(_self->ob_itself,

  1000 	                           inCommandID);

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

  1002 	Py_INCREF(Py_None);

  1003 	_res = Py_None;

  1004 	return _res;

  1005 }

  1006 

  1007 static PyObject *CtlObj_GetControlCommandID(ControlObject *_self, PyObject *_args)

  1008 {

  1009 	PyObject *_res = NULL;

  1010 	OSStatus _err;

  1011 	UInt32 outCommandID;

  1012 #ifndef GetControlCommandID

  1013 	PyMac_PRECHECK(GetControlCommandID);

  1014 #endif

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

  1016 		return NULL;

  1017 	_err = GetControlCommandID(_self->ob_itself,

  1018 	                           &outCommandID);

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

  1020 	_res = Py_BuildValue("l",

  1021 	                     outCommandID);

  1022 	return _res;

  1023 }

  1024 

  1025 static PyObject *CtlObj_RemoveControlProperty(ControlObject *_self, PyObject *_args)

  1026 {

  1027 	PyObject *_res = NULL;

  1028 	OSStatus _err;

  1029 	OSType propertyCreator;

  1030 	OSType propertyTag;

  1031 #ifndef RemoveControlProperty

  1032 	PyMac_PRECHECK(RemoveControlProperty);

  1033 #endif

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

  1035 	                      PyMac_GetOSType, &propertyCreator,

  1036 	                      PyMac_GetOSType, &propertyTag))

  1037 		return NULL;

  1038 	_err = RemoveControlProperty(_self->ob_itself,

  1039 	                             propertyCreator,

  1040 	                             propertyTag);

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

  1042 	Py_INCREF(Py_None);

  1043 	_res = Py_None;

  1044 	return _res;

  1045 }

  1046 

  1047 static PyObject *CtlObj_GetControlPropertyAttributes(ControlObject *_self, PyObject *_args)

  1048 {

  1049 	PyObject *_res = NULL;

  1050 	OSStatus _err;

  1051 	OSType propertyCreator;

  1052 	OSType propertyTag;

  1053 	UInt32 attributes;

  1054 #ifndef GetControlPropertyAttributes

  1055 	PyMac_PRECHECK(GetControlPropertyAttributes);

  1056 #endif

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

  1058 	                      PyMac_GetOSType, &propertyCreator,

  1059 	                      PyMac_GetOSType, &propertyTag))

  1060 		return NULL;

  1061 	_err = GetControlPropertyAttributes(_self->ob_itself,

  1062 	                                    propertyCreator,

  1063 	                                    propertyTag,

  1064 	                                    &attributes);

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

  1066 	_res = Py_BuildValue("l",

  1067 	                     attributes);

  1068 	return _res;

  1069 }

  1070 

  1071 static PyObject *CtlObj_ChangeControlPropertyAttributes(ControlObject *_self, PyObject *_args)

  1072 {

  1073 	PyObject *_res = NULL;

  1074 	OSStatus _err;

  1075 	OSType propertyCreator;

  1076 	OSType propertyTag;

  1077 	UInt32 attributesToSet;

  1078 	UInt32 attributesToClear;

  1079 #ifndef ChangeControlPropertyAttributes

  1080 	PyMac_PRECHECK(ChangeControlPropertyAttributes);

  1081 #endif

  1082 	if (!PyArg_ParseTuple(_args, "O&O&ll",

  1083 	                      PyMac_GetOSType, &propertyCreator,

  1084 	                      PyMac_GetOSType, &propertyTag,

  1085 	                      &attributesToSet,

  1086 	                      &attributesToClear))

  1087 		return NULL;

  1088 	_err = ChangeControlPropertyAttributes(_self->ob_itself,

  1089 	                                       propertyCreator,

  1090 	                                       propertyTag,

  1091 	                                       attributesToSet,

  1092 	                                       attributesToClear);

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

  1094 	Py_INCREF(Py_None);

  1095 	_res = Py_None;

  1096 	return _res;

  1097 }

  1098 

  1099 static PyObject *CtlObj_GetControlRegion(ControlObject *_self, PyObject *_args)

  1100 {

  1101 	PyObject *_res = NULL;

  1102 	OSStatus _err;

  1103 	ControlPartCode inPart;

  1104 	RgnHandle outRegion;

  1105 #ifndef GetControlRegion

  1106 	PyMac_PRECHECK(GetControlRegion);

  1107 #endif

  1108 	if (!PyArg_ParseTuple(_args, "hO&",

  1109 	                      &inPart,

  1110 	                      ResObj_Convert, &outRegion))

  1111 		return NULL;

  1112 	_err = GetControlRegion(_self->ob_itself,

  1113 	                        inPart,

  1114 	                        outRegion);

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

  1116 	Py_INCREF(Py_None);

  1117 	_res = Py_None;

  1118 	return _res;

  1119 }

  1120 

  1121 static PyObject *CtlObj_GetControlVariant(ControlObject *_self, PyObject *_args)

  1122 {

  1123 	PyObject *_res = NULL;

  1124 	ControlVariant _rv;

  1125 #ifndef GetControlVariant

  1126 	PyMac_PRECHECK(GetControlVariant);

  1127 #endif

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

  1129 		return NULL;

  1130 	_rv = GetControlVariant(_self->ob_itself);

  1131 	_res = Py_BuildValue("h",

  1132 	                     _rv);

  1133 	return _res;

  1134 }

  1135