| |
| /* ========================== Module _Ctl =========================== */ |
| |
| #include "Python.h" |
| |
| |
| |
| #include "pymactoolbox.h" |
| |
| /* Macro to test whether a weak-loaded CFM function exists */ |
| #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\ |
| PyErr_SetString(PyExc_NotImplementedError, \ |
| "Not available in this shared library/OS version"); \ |
| return NULL; \ |
| }} while(0) |
| |
| |
| #include <Carbon/Carbon.h> |
| |
| #ifdef USE_TOOLBOX_OBJECT_GLUE |
| extern PyObject *_CtlObj_New(ControlHandle); |
| extern int _CtlObj_Convert(PyObject *, ControlHandle *); |
| |
| #define CtlObj_New _CtlObj_New |
| #define CtlObj_Convert _CtlObj_Convert |
| #endif |
| |
| static PyObject *CtlObj_WhichControl(ControlHandle); |
| |
| #define as_Control(h) ((ControlHandle)h) |
| #define as_Resource(ctl) ((Handle)ctl) |
| #define GetControlRect(ctl, rectp) GetControlBounds(ctl, rectp) |
| |
| #define MAXTABS 32 /* maximum number of tabs that we support in a tabs control */ |
| /* |
| ** Parse/generate ControlFontStyleRec records |
| */ |
| #if 0 /* Not needed */ |
| static PyObject * |
| ControlFontStyle_New(ControlFontStyleRec *itself) |
| { |
| |
| return Py_BuildValue("hhhhhhO&O&", itself->flags, itself->font, |
| itself->size, itself->style, itself->mode, itself->just, |
| QdRGB_New, &itself->foreColor, QdRGB_New, &itself->backColor); |
| } |
| #endif |
| |
| static int |
| ControlFontStyle_Convert(PyObject *v, ControlFontStyleRec *itself) |
| { |
| return PyArg_Parse(v, "(hhhhhhO&O&)", &itself->flags, |
| &itself->font, &itself->size, &itself->style, &itself->mode, |
| &itself->just, QdRGB_Convert, &itself->foreColor, |
| QdRGB_Convert, &itself->backColor); |
| } |
| |
| /* |
| ** Parse/generate ControlID records |
| */ |
| static PyObject * |
| PyControlID_New(ControlID *itself) |
| { |
| |
| return Py_BuildValue("O&l", PyMac_BuildOSType, itself->signature, itself->id); |
| } |
| |
| static int |
| PyControlID_Convert(PyObject *v, ControlID *itself) |
| { |
| return PyArg_Parse(v, "(O&l)", PyMac_GetOSType, &itself->signature, &itself->id); |
| } |
| |
| /* |
| ** generate DataBrowserListViewColumnDesc records |
| */ |
| static int |
| DataBrowserTableViewColumnDesc_Convert(PyObject *v, DataBrowserTableViewColumnDesc *itself) |
| { |
| return PyArg_Parse(v, "(lO&l)", |
| &itself->propertyID, |
| PyMac_GetOSType, &itself->propertyType, |
| &itself->propertyFlags); |
| } |
| |
| static int |
| ControlButtonContentInfo_Convert(PyObject *v, ControlButtonContentInfo *itself) |
| { |
| return PyArg_Parse(v, "(hO&)", |
| &itself->contentType, |
| OptResObj_Convert, &itself->u.iconSuite); |
| } |
| |
| static int |
| DataBrowserListViewHeaderDesc_Convert(PyObject *v, DataBrowserListViewHeaderDesc *itself) |
| { |
| itself->version = kDataBrowserListViewLatestHeaderDesc; |
| return PyArg_Parse(v, "(HHhO&HO&O&)", |
| &itself->minimumWidth, |
| &itself->maximumWidth, |
| &itself->titleOffset, |
| CFStringRefObj_Convert, &itself->titleString, |
| &itself->initialOrder, |
| ControlFontStyle_Convert, &itself->btnFontStyle, |
| ControlButtonContentInfo_Convert, &itself->btnContentInfo); |
| } |
| |
| static int |
| DataBrowserListViewColumnDesc_Convert(PyObject *v, DataBrowserListViewColumnDesc *itself) |
| { |
| return PyArg_Parse(v, "(O&O&)", |
| DataBrowserTableViewColumnDesc_Convert, &itself->propertyDesc, |
| DataBrowserListViewHeaderDesc_Convert, &itself->headerBtnDesc); |
| } |
| |
| /* TrackControl and HandleControlClick callback support */ |
| #define kMyControlActionProcTag 'ACTN' /* not an official tag, only for internal use */ |
| static PyObject *tracker; |
| static ControlActionUPP mytracker_upp; |
| static ControlActionUPP myactionproc_upp; |
| static ControlUserPaneKeyDownUPP mykeydownproc_upp; |
| static ControlUserPaneFocusUPP myfocusproc_upp; |
| static ControlUserPaneDrawUPP mydrawproc_upp; |
| static ControlUserPaneIdleUPP myidleproc_upp; |
| static ControlUserPaneHitTestUPP myhittestproc_upp; |
| static ControlUserPaneTrackingUPP mytrackingproc_upp; |
| |
| static int settrackfunc(PyObject *); /* forward */ |
| static void clrtrackfunc(void); /* forward */ |
| static int setcallback(PyObject *, OSType, PyObject *, UniversalProcPtr *); |
| |
| static PyObject *Ctl_Error; |
| |
| /* ---------------------- Object type Control ----------------------- */ |
| |
| PyTypeObject Control_Type; |
| |
| #define CtlObj_Check(x) (Py_Type(x) == &Control_Type || PyObject_TypeCheck((x), &Control_Type)) |
| |
| typedef struct ControlObject { |
| PyObject_HEAD |
| ControlHandle ob_itself; |
| PyObject *ob_callbackdict; |
| } ControlObject; |
| |
| PyObject *CtlObj_New(ControlHandle itself) |
| { |
| ControlObject *it; |
| if (itself == NULL) return PyMac_Error(resNotFound); |
| it = PyObject_NEW(ControlObject, &Control_Type); |
| if (it == NULL) return NULL; |
| it->ob_itself = itself; |
| SetControlReference(itself, (long)it); |
| it->ob_callbackdict = NULL; |
| return (PyObject *)it; |
| } |
| |
| int CtlObj_Convert(PyObject *v, ControlHandle *p_itself) |
| { |
| if (!CtlObj_Check(v)) |
| { |
| PyErr_SetString(PyExc_TypeError, "Control required"); |
| return 0; |
| } |
| *p_itself = ((ControlObject *)v)->ob_itself; |
| return 1; |
| } |
| |
| static void CtlObj_dealloc(ControlObject *self) |
| { |
| Py_XDECREF(self->ob_callbackdict); |
| if (self->ob_itself)SetControlReference(self->ob_itself, (long)0); /* Make it forget about us */ |
| Py_Type(self)->tp_free((PyObject *)self); |
| } |
| |
| static PyObject *CtlObj_HiliteControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ControlPartCode hiliteState; |
| #ifndef HiliteControl |
| PyMac_PRECHECK(HiliteControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &hiliteState)) |
| return NULL; |
| HiliteControl(_self->ob_itself, |
| hiliteState); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_ShowControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef ShowControl |
| PyMac_PRECHECK(ShowControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| ShowControl(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_HideControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef HideControl |
| PyMac_PRECHECK(HideControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| HideControl(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_IsControlActive(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| #ifndef IsControlActive |
| PyMac_PRECHECK(IsControlActive); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = IsControlActive(_self->ob_itself); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_IsControlVisible(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| #ifndef IsControlVisible |
| PyMac_PRECHECK(IsControlVisible); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = IsControlVisible(_self->ob_itself); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_ActivateControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| #ifndef ActivateControl |
| PyMac_PRECHECK(ActivateControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = ActivateControl(_self->ob_itself); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_DeactivateControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| #ifndef DeactivateControl |
| PyMac_PRECHECK(DeactivateControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = DeactivateControl(_self->ob_itself); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlVisibility(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Boolean inIsVisible; |
| Boolean inDoDraw; |
| #ifndef SetControlVisibility |
| PyMac_PRECHECK(SetControlVisibility); |
| #endif |
| if (!PyArg_ParseTuple(_args, "bb", |
| &inIsVisible, |
| &inDoDraw)) |
| return NULL; |
| _err = SetControlVisibility(_self->ob_itself, |
| inIsVisible, |
| inDoDraw); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_IsControlEnabled(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| #ifndef IsControlEnabled |
| PyMac_PRECHECK(IsControlEnabled); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = IsControlEnabled(_self->ob_itself); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_EnableControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| #ifndef EnableControl |
| PyMac_PRECHECK(EnableControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = EnableControl(_self->ob_itself); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_DisableControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| #ifndef DisableControl |
| PyMac_PRECHECK(DisableControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = DisableControl(_self->ob_itself); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_Draw1Control(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef Draw1Control |
| PyMac_PRECHECK(Draw1Control); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| Draw1Control(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetBestControlRect(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Rect outRect; |
| SInt16 outBaseLineOffset; |
| #ifndef GetBestControlRect |
| PyMac_PRECHECK(GetBestControlRect); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetBestControlRect(_self->ob_itself, |
| &outRect, |
| &outBaseLineOffset); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&h", |
| PyMac_BuildRect, &outRect, |
| outBaseLineOffset); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlFontStyle(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| ControlFontStyleRec inStyle; |
| #ifndef SetControlFontStyle |
| PyMac_PRECHECK(SetControlFontStyle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ControlFontStyle_Convert, &inStyle)) |
| return NULL; |
| _err = SetControlFontStyle(_self->ob_itself, |
| &inStyle); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_DrawControlInCurrentPort(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef DrawControlInCurrentPort |
| PyMac_PRECHECK(DrawControlInCurrentPort); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| DrawControlInCurrentPort(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetUpControlBackground(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 inDepth; |
| Boolean inIsColorDevice; |
| #ifndef SetUpControlBackground |
| PyMac_PRECHECK(SetUpControlBackground); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hb", |
| &inDepth, |
| &inIsColorDevice)) |
| return NULL; |
| _err = SetUpControlBackground(_self->ob_itself, |
| inDepth, |
| inIsColorDevice); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetUpControlTextColor(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 inDepth; |
| Boolean inIsColorDevice; |
| #ifndef SetUpControlTextColor |
| PyMac_PRECHECK(SetUpControlTextColor); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hb", |
| &inDepth, |
| &inIsColorDevice)) |
| return NULL; |
| _err = SetUpControlTextColor(_self->ob_itself, |
| inDepth, |
| inIsColorDevice); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_DragControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Point startPoint; |
| Rect limitRect; |
| Rect slopRect; |
| DragConstraint axis; |
| #ifndef DragControl |
| PyMac_PRECHECK(DragControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&H", |
| PyMac_GetPoint, &startPoint, |
| PyMac_GetRect, &limitRect, |
| PyMac_GetRect, &slopRect, |
| &axis)) |
| return NULL; |
| DragControl(_self->ob_itself, |
| startPoint, |
| &limitRect, |
| &slopRect, |
| axis); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_TestControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ControlPartCode _rv; |
| Point testPoint; |
| #ifndef TestControl |
| PyMac_PRECHECK(TestControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetPoint, &testPoint)) |
| return NULL; |
| _rv = TestControl(_self->ob_itself, |
| testPoint); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_HandleControlContextualMenuClick(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Point inWhere; |
| Boolean menuDisplayed; |
| #ifndef HandleControlContextualMenuClick |
| PyMac_PRECHECK(HandleControlContextualMenuClick); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetPoint, &inWhere)) |
| return NULL; |
| _err = HandleControlContextualMenuClick(_self->ob_itself, |
| inWhere, |
| &menuDisplayed); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("b", |
| menuDisplayed); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlClickActivation(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Point inWhere; |
| EventModifiers inModifiers; |
| ClickActivationResult outResult; |
| #ifndef GetControlClickActivation |
| PyMac_PRECHECK(GetControlClickActivation); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&H", |
| PyMac_GetPoint, &inWhere, |
| &inModifiers)) |
| return NULL; |
| _err = GetControlClickActivation(_self->ob_itself, |
| inWhere, |
| inModifiers, |
| &outResult); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| outResult); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_HandleControlKey(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ControlPartCode _rv; |
| SInt16 inKeyCode; |
| SInt16 inCharCode; |
| EventModifiers inModifiers; |
| #ifndef HandleControlKey |
| PyMac_PRECHECK(HandleControlKey); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hhH", |
| &inKeyCode, |
| &inCharCode, |
| &inModifiers)) |
| return NULL; |
| _rv = HandleControlKey(_self->ob_itself, |
| inKeyCode, |
| inCharCode, |
| inModifiers); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_HandleControlSetCursor(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Point localPoint; |
| EventModifiers modifiers; |
| Boolean cursorWasSet; |
| #ifndef HandleControlSetCursor |
| PyMac_PRECHECK(HandleControlSetCursor); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&H", |
| PyMac_GetPoint, &localPoint, |
| &modifiers)) |
| return NULL; |
| _err = HandleControlSetCursor(_self->ob_itself, |
| localPoint, |
| modifiers, |
| &cursorWasSet); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("b", |
| cursorWasSet); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_MoveControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt16 h; |
| SInt16 v; |
| #ifndef MoveControl |
| PyMac_PRECHECK(MoveControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hh", |
| &h, |
| &v)) |
| return NULL; |
| MoveControl(_self->ob_itself, |
| h, |
| v); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SizeControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt16 w; |
| SInt16 h; |
| #ifndef SizeControl |
| PyMac_PRECHECK(SizeControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hh", |
| &w, |
| &h)) |
| return NULL; |
| SizeControl(_self->ob_itself, |
| w, |
| h); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlTitle(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Str255 title; |
| #ifndef SetControlTitle |
| PyMac_PRECHECK(SetControlTitle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetStr255, title)) |
| return NULL; |
| SetControlTitle(_self->ob_itself, |
| title); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlTitle(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Str255 title; |
| #ifndef GetControlTitle |
| PyMac_PRECHECK(GetControlTitle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetControlTitle(_self->ob_itself, |
| title); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildStr255, title); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlTitleWithCFString(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| CFStringRef inString; |
| #ifndef SetControlTitleWithCFString |
| PyMac_PRECHECK(SetControlTitleWithCFString); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CFStringRefObj_Convert, &inString)) |
| return NULL; |
| _err = SetControlTitleWithCFString(_self->ob_itself, |
| inString); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_CopyControlTitleAsCFString(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| CFStringRef outString; |
| #ifndef CopyControlTitleAsCFString |
| PyMac_PRECHECK(CopyControlTitleAsCFString); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = CopyControlTitleAsCFString(_self->ob_itself, |
| &outString); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CFStringRefObj_New, outString); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlValue(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt16 _rv; |
| #ifndef GetControlValue |
| PyMac_PRECHECK(GetControlValue); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetControlValue(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlValue(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt16 newValue; |
| #ifndef SetControlValue |
| PyMac_PRECHECK(SetControlValue); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &newValue)) |
| return NULL; |
| SetControlValue(_self->ob_itself, |
| newValue); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlMinimum(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt16 _rv; |
| #ifndef GetControlMinimum |
| PyMac_PRECHECK(GetControlMinimum); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetControlMinimum(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlMinimum(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt16 newMinimum; |
| #ifndef SetControlMinimum |
| PyMac_PRECHECK(SetControlMinimum); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &newMinimum)) |
| return NULL; |
| SetControlMinimum(_self->ob_itself, |
| newMinimum); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlMaximum(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt16 _rv; |
| #ifndef GetControlMaximum |
| PyMac_PRECHECK(GetControlMaximum); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetControlMaximum(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlMaximum(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt16 newMaximum; |
| #ifndef SetControlMaximum |
| PyMac_PRECHECK(SetControlMaximum); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &newMaximum)) |
| return NULL; |
| SetControlMaximum(_self->ob_itself, |
| newMaximum); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlViewSize(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt32 _rv; |
| #ifndef GetControlViewSize |
| PyMac_PRECHECK(GetControlViewSize); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetControlViewSize(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlViewSize(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt32 newViewSize; |
| #ifndef SetControlViewSize |
| PyMac_PRECHECK(SetControlViewSize); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &newViewSize)) |
| return NULL; |
| SetControlViewSize(_self->ob_itself, |
| newViewSize); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControl32BitValue(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt32 _rv; |
| #ifndef GetControl32BitValue |
| PyMac_PRECHECK(GetControl32BitValue); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetControl32BitValue(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControl32BitValue(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt32 newValue; |
| #ifndef SetControl32BitValue |
| PyMac_PRECHECK(SetControl32BitValue); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &newValue)) |
| return NULL; |
| SetControl32BitValue(_self->ob_itself, |
| newValue); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControl32BitMaximum(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt32 _rv; |
| #ifndef GetControl32BitMaximum |
| PyMac_PRECHECK(GetControl32BitMaximum); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetControl32BitMaximum(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControl32BitMaximum(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt32 newMaximum; |
| #ifndef SetControl32BitMaximum |
| PyMac_PRECHECK(SetControl32BitMaximum); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &newMaximum)) |
| return NULL; |
| SetControl32BitMaximum(_self->ob_itself, |
| newMaximum); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControl32BitMinimum(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt32 _rv; |
| #ifndef GetControl32BitMinimum |
| PyMac_PRECHECK(GetControl32BitMinimum); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetControl32BitMinimum(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControl32BitMinimum(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt32 newMinimum; |
| #ifndef SetControl32BitMinimum |
| PyMac_PRECHECK(SetControl32BitMinimum); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &newMinimum)) |
| return NULL; |
| SetControl32BitMinimum(_self->ob_itself, |
| newMinimum); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_IsValidControlHandle(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| #ifndef IsValidControlHandle |
| PyMac_PRECHECK(IsValidControlHandle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = IsValidControlHandle(_self->ob_itself); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlID(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| ControlID inID; |
| #ifndef SetControlID |
| PyMac_PRECHECK(SetControlID); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyControlID_Convert, &inID)) |
| return NULL; |
| _err = SetControlID(_self->ob_itself, |
| &inID); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlID(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| ControlID outID; |
| #ifndef GetControlID |
| PyMac_PRECHECK(GetControlID); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetControlID(_self->ob_itself, |
| &outID); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| PyControlID_New, &outID); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlCommandID(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 inCommandID; |
| #ifndef SetControlCommandID |
| PyMac_PRECHECK(SetControlCommandID); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &inCommandID)) |
| return NULL; |
| _err = SetControlCommandID(_self->ob_itself, |
| inCommandID); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlCommandID(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 outCommandID; |
| #ifndef GetControlCommandID |
| PyMac_PRECHECK(GetControlCommandID); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetControlCommandID(_self->ob_itself, |
| &outCommandID); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| outCommandID); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_RemoveControlProperty(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| OSType propertyCreator; |
| OSType propertyTag; |
| #ifndef RemoveControlProperty |
| PyMac_PRECHECK(RemoveControlProperty); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| PyMac_GetOSType, &propertyCreator, |
| PyMac_GetOSType, &propertyTag)) |
| return NULL; |
| _err = RemoveControlProperty(_self->ob_itself, |
| propertyCreator, |
| propertyTag); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlPropertyAttributes(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| OSType propertyCreator; |
| OSType propertyTag; |
| UInt32 attributes; |
| #ifndef GetControlPropertyAttributes |
| PyMac_PRECHECK(GetControlPropertyAttributes); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| PyMac_GetOSType, &propertyCreator, |
| PyMac_GetOSType, &propertyTag)) |
| return NULL; |
| _err = GetControlPropertyAttributes(_self->ob_itself, |
| propertyCreator, |
| propertyTag, |
| &attributes); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| attributes); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_ChangeControlPropertyAttributes(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| OSType propertyCreator; |
| OSType propertyTag; |
| UInt32 attributesToSet; |
| UInt32 attributesToClear; |
| #ifndef ChangeControlPropertyAttributes |
| PyMac_PRECHECK(ChangeControlPropertyAttributes); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&ll", |
| PyMac_GetOSType, &propertyCreator, |
| PyMac_GetOSType, &propertyTag, |
| &attributesToSet, |
| &attributesToClear)) |
| return NULL; |
| _err = ChangeControlPropertyAttributes(_self->ob_itself, |
| propertyCreator, |
| propertyTag, |
| attributesToSet, |
| attributesToClear); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlRegion(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| ControlPartCode inPart; |
| RgnHandle outRegion; |
| #ifndef GetControlRegion |
| PyMac_PRECHECK(GetControlRegion); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hO&", |
| &inPart, |
| ResObj_Convert, &outRegion)) |
| return NULL; |
| _err = GetControlRegion(_self->ob_itself, |
| inPart, |
| outRegion); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlVariant(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ControlVariant _rv; |
| #ifndef GetControlVariant |
| PyMac_PRECHECK(GetControlVariant); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetControlVariant(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlAction(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| PyObject* actionProc; |
| UniversalProcPtr c_callback; |
| #ifndef SetControlAction |
| PyMac_PRECHECK(SetControlAction); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O", |
| &actionProc)) |
| return NULL; |
| SetControlAction(_self->ob_itself, |
| myactionproc_upp); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| setcallback((PyObject*)_self, kMyControlActionProcTag, actionProc, &c_callback); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlReference(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt32 data; |
| #ifndef SetControlReference |
| PyMac_PRECHECK(SetControlReference); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &data)) |
| return NULL; |
| SetControlReference(_self->ob_itself, |
| data); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlReference(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt32 _rv; |
| #ifndef GetControlReference |
| PyMac_PRECHECK(GetControlReference); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetControlReference(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_EmbedControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| ControlHandle inContainer; |
| #ifndef EmbedControl |
| PyMac_PRECHECK(EmbedControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CtlObj_Convert, &inContainer)) |
| return NULL; |
| _err = EmbedControl(_self->ob_itself, |
| inContainer); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_AutoEmbedControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| WindowPtr inWindow; |
| #ifndef AutoEmbedControl |
| PyMac_PRECHECK(AutoEmbedControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &inWindow)) |
| return NULL; |
| _err = AutoEmbedControl(_self->ob_itself, |
| inWindow); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetSuperControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| ControlHandle outParent; |
| #ifndef GetSuperControl |
| PyMac_PRECHECK(GetSuperControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetSuperControl(_self->ob_itself, |
| &outParent); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_WhichControl, outParent); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_CountSubControls(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| UInt16 outNumChildren; |
| #ifndef CountSubControls |
| PyMac_PRECHECK(CountSubControls); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = CountSubControls(_self->ob_itself, |
| &outNumChildren); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("H", |
| outNumChildren); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetIndexedSubControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| UInt16 inIndex; |
| ControlHandle outSubControl; |
| #ifndef GetIndexedSubControl |
| PyMac_PRECHECK(GetIndexedSubControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "H", |
| &inIndex)) |
| return NULL; |
| _err = GetIndexedSubControl(_self->ob_itself, |
| inIndex, |
| &outSubControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_WhichControl, outSubControl); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlSupervisor(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| ControlHandle inBoss; |
| #ifndef SetControlSupervisor |
| PyMac_PRECHECK(SetControlSupervisor); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CtlObj_Convert, &inBoss)) |
| return NULL; |
| _err = SetControlSupervisor(_self->ob_itself, |
| inBoss); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlFeatures(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| UInt32 outFeatures; |
| #ifndef GetControlFeatures |
| PyMac_PRECHECK(GetControlFeatures); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetControlFeatures(_self->ob_itself, |
| &outFeatures); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| outFeatures); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlDataSize(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| ControlPartCode inPart; |
| ResType inTagName; |
| Size outMaxSize; |
| #ifndef GetControlDataSize |
| PyMac_PRECHECK(GetControlDataSize); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hO&", |
| &inPart, |
| PyMac_GetOSType, &inTagName)) |
| return NULL; |
| _err = GetControlDataSize(_self->ob_itself, |
| inPart, |
| inTagName, |
| &outMaxSize); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| outMaxSize); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_HandleControlDragTracking(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| DragTrackingMessage inMessage; |
| DragReference inDrag; |
| Boolean outLikesDrag; |
| #ifndef HandleControlDragTracking |
| PyMac_PRECHECK(HandleControlDragTracking); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hO&", |
| &inMessage, |
| DragObj_Convert, &inDrag)) |
| return NULL; |
| _err = HandleControlDragTracking(_self->ob_itself, |
| inMessage, |
| inDrag, |
| &outLikesDrag); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("b", |
| outLikesDrag); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_HandleControlDragReceive(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| DragReference inDrag; |
| #ifndef HandleControlDragReceive |
| PyMac_PRECHECK(HandleControlDragReceive); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| DragObj_Convert, &inDrag)) |
| return NULL; |
| _err = HandleControlDragReceive(_self->ob_itself, |
| inDrag); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlDragTrackingEnabled(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Boolean inTracks; |
| #ifndef SetControlDragTrackingEnabled |
| PyMac_PRECHECK(SetControlDragTrackingEnabled); |
| #endif |
| if (!PyArg_ParseTuple(_args, "b", |
| &inTracks)) |
| return NULL; |
| _err = SetControlDragTrackingEnabled(_self->ob_itself, |
| inTracks); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_IsControlDragTrackingEnabled(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Boolean outTracks; |
| #ifndef IsControlDragTrackingEnabled |
| PyMac_PRECHECK(IsControlDragTrackingEnabled); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = IsControlDragTrackingEnabled(_self->ob_itself, |
| &outTracks); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("b", |
| outTracks); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlBounds(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Rect bounds; |
| #ifndef GetControlBounds |
| PyMac_PRECHECK(GetControlBounds); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetControlBounds(_self->ob_itself, |
| &bounds); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildRect, &bounds); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_IsControlHilited(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| #ifndef IsControlHilited |
| PyMac_PRECHECK(IsControlHilited); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = IsControlHilited(_self->ob_itself); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlHilite(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| UInt16 _rv; |
| #ifndef GetControlHilite |
| PyMac_PRECHECK(GetControlHilite); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetControlHilite(_self->ob_itself); |
| _res = Py_BuildValue("H", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlOwner(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| WindowPtr _rv; |
| #ifndef GetControlOwner |
| PyMac_PRECHECK(GetControlOwner); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetControlOwner(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| WinObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlDataHandle(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Handle _rv; |
| #ifndef GetControlDataHandle |
| PyMac_PRECHECK(GetControlDataHandle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetControlDataHandle(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlPopupMenuHandle(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| MenuHandle _rv; |
| #ifndef GetControlPopupMenuHandle |
| PyMac_PRECHECK(GetControlPopupMenuHandle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetControlPopupMenuHandle(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| MenuObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlPopupMenuID(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short _rv; |
| #ifndef GetControlPopupMenuID |
| PyMac_PRECHECK(GetControlPopupMenuID); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetControlPopupMenuID(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlDataHandle(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Handle dataHandle; |
| #ifndef SetControlDataHandle |
| PyMac_PRECHECK(SetControlDataHandle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &dataHandle)) |
| return NULL; |
| SetControlDataHandle(_self->ob_itself, |
| dataHandle); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlBounds(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Rect bounds; |
| #ifndef SetControlBounds |
| PyMac_PRECHECK(SetControlBounds); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetRect, &bounds)) |
| return NULL; |
| SetControlBounds(_self->ob_itself, |
| &bounds); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlPopupMenuHandle(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| MenuHandle popupMenu; |
| #ifndef SetControlPopupMenuHandle |
| PyMac_PRECHECK(SetControlPopupMenuHandle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| MenuObj_Convert, &popupMenu)) |
| return NULL; |
| SetControlPopupMenuHandle(_self->ob_itself, |
| popupMenu); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetControlPopupMenuID(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short menuID; |
| #ifndef SetControlPopupMenuID |
| PyMac_PRECHECK(SetControlPopupMenuID); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &menuID)) |
| return NULL; |
| SetControlPopupMenuID(_self->ob_itself, |
| menuID); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetBevelButtonMenuValue(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 outValue; |
| #ifndef GetBevelButtonMenuValue |
| PyMac_PRECHECK(GetBevelButtonMenuValue); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetBevelButtonMenuValue(_self->ob_itself, |
| &outValue); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("h", |
| outValue); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetBevelButtonMenuValue(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 inValue; |
| #ifndef SetBevelButtonMenuValue |
| PyMac_PRECHECK(SetBevelButtonMenuValue); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &inValue)) |
| return NULL; |
| _err = SetBevelButtonMenuValue(_self->ob_itself, |
| inValue); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetBevelButtonMenuHandle(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| MenuHandle outHandle; |
| #ifndef GetBevelButtonMenuHandle |
| PyMac_PRECHECK(GetBevelButtonMenuHandle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetBevelButtonMenuHandle(_self->ob_itself, |
| &outHandle); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| MenuObj_New, outHandle); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetBevelButtonContentInfo(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| ControlButtonContentInfo inContent; |
| #ifndef SetBevelButtonContentInfo |
| PyMac_PRECHECK(SetBevelButtonContentInfo); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ControlButtonContentInfo_Convert, &inContent)) |
| return NULL; |
| _err = SetBevelButtonContentInfo(_self->ob_itself, |
| &inContent); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetBevelButtonTransform(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| IconTransformType transform; |
| #ifndef SetBevelButtonTransform |
| PyMac_PRECHECK(SetBevelButtonTransform); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &transform)) |
| return NULL; |
| _err = SetBevelButtonTransform(_self->ob_itself, |
| transform); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDisclosureTriangleLastValue(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 inValue; |
| #ifndef SetDisclosureTriangleLastValue |
| PyMac_PRECHECK(SetDisclosureTriangleLastValue); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &inValue)) |
| return NULL; |
| _err = SetDisclosureTriangleLastValue(_self->ob_itself, |
| inValue); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetTabContentRect(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Rect outContentRect; |
| #ifndef GetTabContentRect |
| PyMac_PRECHECK(GetTabContentRect); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetTabContentRect(_self->ob_itself, |
| &outContentRect); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildRect, &outContentRect); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetTabEnabled(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 inTabToHilite; |
| Boolean inEnabled; |
| #ifndef SetTabEnabled |
| PyMac_PRECHECK(SetTabEnabled); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hb", |
| &inTabToHilite, |
| &inEnabled)) |
| return NULL; |
| _err = SetTabEnabled(_self->ob_itself, |
| inTabToHilite, |
| inEnabled); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetImageWellContentInfo(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| ControlButtonContentInfo inContent; |
| #ifndef SetImageWellContentInfo |
| PyMac_PRECHECK(SetImageWellContentInfo); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ControlButtonContentInfo_Convert, &inContent)) |
| return NULL; |
| _err = SetImageWellContentInfo(_self->ob_itself, |
| &inContent); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetImageWellTransform(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| IconTransformType inTransform; |
| #ifndef SetImageWellTransform |
| PyMac_PRECHECK(SetImageWellTransform); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &inTransform)) |
| return NULL; |
| _err = SetImageWellTransform(_self->ob_itself, |
| inTransform); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserViewStyle(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| OSType style; |
| #ifndef GetDataBrowserViewStyle |
| PyMac_PRECHECK(GetDataBrowserViewStyle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserViewStyle(_self->ob_itself, |
| &style); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildOSType, style); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserViewStyle(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| OSType style; |
| #ifndef SetDataBrowserViewStyle |
| PyMac_PRECHECK(SetDataBrowserViewStyle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetOSType, &style)) |
| return NULL; |
| _err = SetDataBrowserViewStyle(_self->ob_itself, |
| style); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_EnableDataBrowserEditCommand(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| UInt32 command; |
| #ifndef EnableDataBrowserEditCommand |
| PyMac_PRECHECK(EnableDataBrowserEditCommand); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &command)) |
| return NULL; |
| _rv = EnableDataBrowserEditCommand(_self->ob_itself, |
| command); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_ExecuteDataBrowserEditCommand(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 command; |
| #ifndef ExecuteDataBrowserEditCommand |
| PyMac_PRECHECK(ExecuteDataBrowserEditCommand); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &command)) |
| return NULL; |
| _err = ExecuteDataBrowserEditCommand(_self->ob_itself, |
| command); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserSelectionAnchor(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 first; |
| UInt32 last; |
| #ifndef GetDataBrowserSelectionAnchor |
| PyMac_PRECHECK(GetDataBrowserSelectionAnchor); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserSelectionAnchor(_self->ob_itself, |
| &first, |
| &last); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("ll", |
| first, |
| last); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_MoveDataBrowserSelectionAnchor(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 direction; |
| Boolean extendSelection; |
| #ifndef MoveDataBrowserSelectionAnchor |
| PyMac_PRECHECK(MoveDataBrowserSelectionAnchor); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lb", |
| &direction, |
| &extendSelection)) |
| return NULL; |
| _err = MoveDataBrowserSelectionAnchor(_self->ob_itself, |
| direction, |
| extendSelection); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_OpenDataBrowserContainer(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 container; |
| #ifndef OpenDataBrowserContainer |
| PyMac_PRECHECK(OpenDataBrowserContainer); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &container)) |
| return NULL; |
| _err = OpenDataBrowserContainer(_self->ob_itself, |
| container); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_CloseDataBrowserContainer(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 container; |
| #ifndef CloseDataBrowserContainer |
| PyMac_PRECHECK(CloseDataBrowserContainer); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &container)) |
| return NULL; |
| _err = CloseDataBrowserContainer(_self->ob_itself, |
| container); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SortDataBrowserContainer(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 container; |
| Boolean sortChildren; |
| #ifndef SortDataBrowserContainer |
| PyMac_PRECHECK(SortDataBrowserContainer); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lb", |
| &container, |
| &sortChildren)) |
| return NULL; |
| _err = SortDataBrowserContainer(_self->ob_itself, |
| container, |
| sortChildren); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserItems(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 container; |
| Boolean recurse; |
| UInt32 state; |
| Handle items; |
| #ifndef GetDataBrowserItems |
| PyMac_PRECHECK(GetDataBrowserItems); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lblO&", |
| &container, |
| &recurse, |
| &state, |
| ResObj_Convert, &items)) |
| return NULL; |
| _err = GetDataBrowserItems(_self->ob_itself, |
| container, |
| recurse, |
| state, |
| items); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserItemCount(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 container; |
| Boolean recurse; |
| UInt32 state; |
| UInt32 numItems; |
| #ifndef GetDataBrowserItemCount |
| PyMac_PRECHECK(GetDataBrowserItemCount); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lbl", |
| &container, |
| &recurse, |
| &state)) |
| return NULL; |
| _err = GetDataBrowserItemCount(_self->ob_itself, |
| container, |
| recurse, |
| state, |
| &numItems); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| numItems); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_IsDataBrowserItemSelected(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| UInt32 item; |
| #ifndef IsDataBrowserItemSelected |
| PyMac_PRECHECK(IsDataBrowserItemSelected); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &item)) |
| return NULL; |
| _rv = IsDataBrowserItemSelected(_self->ob_itself, |
| item); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserItemState(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 item; |
| UInt32 state; |
| #ifndef GetDataBrowserItemState |
| PyMac_PRECHECK(GetDataBrowserItemState); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &item)) |
| return NULL; |
| _err = GetDataBrowserItemState(_self->ob_itself, |
| item, |
| &state); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| state); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_RevealDataBrowserItem(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 item; |
| UInt32 propertyID; |
| UInt8 options; |
| #ifndef RevealDataBrowserItem |
| PyMac_PRECHECK(RevealDataBrowserItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "llb", |
| &item, |
| &propertyID, |
| &options)) |
| return NULL; |
| _err = RevealDataBrowserItem(_self->ob_itself, |
| item, |
| propertyID, |
| options); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserActiveItems(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Boolean active; |
| #ifndef SetDataBrowserActiveItems |
| PyMac_PRECHECK(SetDataBrowserActiveItems); |
| #endif |
| if (!PyArg_ParseTuple(_args, "b", |
| &active)) |
| return NULL; |
| _err = SetDataBrowserActiveItems(_self->ob_itself, |
| active); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserActiveItems(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Boolean active; |
| #ifndef GetDataBrowserActiveItems |
| PyMac_PRECHECK(GetDataBrowserActiveItems); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserActiveItems(_self->ob_itself, |
| &active); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("b", |
| active); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserScrollBarInset(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Rect insetRect; |
| #ifndef SetDataBrowserScrollBarInset |
| PyMac_PRECHECK(SetDataBrowserScrollBarInset); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = SetDataBrowserScrollBarInset(_self->ob_itself, |
| &insetRect); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildRect, &insetRect); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserScrollBarInset(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Rect insetRect; |
| #ifndef GetDataBrowserScrollBarInset |
| PyMac_PRECHECK(GetDataBrowserScrollBarInset); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserScrollBarInset(_self->ob_itself, |
| &insetRect); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildRect, &insetRect); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserTarget(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 target; |
| #ifndef SetDataBrowserTarget |
| PyMac_PRECHECK(SetDataBrowserTarget); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &target)) |
| return NULL; |
| _err = SetDataBrowserTarget(_self->ob_itself, |
| target); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserTarget(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 target; |
| #ifndef GetDataBrowserTarget |
| PyMac_PRECHECK(GetDataBrowserTarget); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserTarget(_self->ob_itself, |
| &target); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| target); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserSortOrder(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt16 order; |
| #ifndef SetDataBrowserSortOrder |
| PyMac_PRECHECK(SetDataBrowserSortOrder); |
| #endif |
| if (!PyArg_ParseTuple(_args, "H", |
| &order)) |
| return NULL; |
| _err = SetDataBrowserSortOrder(_self->ob_itself, |
| order); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserSortOrder(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt16 order; |
| #ifndef GetDataBrowserSortOrder |
| PyMac_PRECHECK(GetDataBrowserSortOrder); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserSortOrder(_self->ob_itself, |
| &order); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("H", |
| order); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserScrollPosition(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 top; |
| UInt32 left; |
| #ifndef SetDataBrowserScrollPosition |
| PyMac_PRECHECK(SetDataBrowserScrollPosition); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &top, |
| &left)) |
| return NULL; |
| _err = SetDataBrowserScrollPosition(_self->ob_itself, |
| top, |
| left); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserScrollPosition(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 top; |
| UInt32 left; |
| #ifndef GetDataBrowserScrollPosition |
| PyMac_PRECHECK(GetDataBrowserScrollPosition); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserScrollPosition(_self->ob_itself, |
| &top, |
| &left); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("ll", |
| top, |
| left); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserHasScrollBars(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Boolean horiz; |
| Boolean vert; |
| #ifndef SetDataBrowserHasScrollBars |
| PyMac_PRECHECK(SetDataBrowserHasScrollBars); |
| #endif |
| if (!PyArg_ParseTuple(_args, "bb", |
| &horiz, |
| &vert)) |
| return NULL; |
| _err = SetDataBrowserHasScrollBars(_self->ob_itself, |
| horiz, |
| vert); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserHasScrollBars(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Boolean horiz; |
| Boolean vert; |
| #ifndef GetDataBrowserHasScrollBars |
| PyMac_PRECHECK(GetDataBrowserHasScrollBars); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserHasScrollBars(_self->ob_itself, |
| &horiz, |
| &vert); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("bb", |
| horiz, |
| vert); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserSortProperty(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 property; |
| #ifndef SetDataBrowserSortProperty |
| PyMac_PRECHECK(SetDataBrowserSortProperty); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &property)) |
| return NULL; |
| _err = SetDataBrowserSortProperty(_self->ob_itself, |
| property); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserSortProperty(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 property; |
| #ifndef GetDataBrowserSortProperty |
| PyMac_PRECHECK(GetDataBrowserSortProperty); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserSortProperty(_self->ob_itself, |
| &property); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| property); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserSelectionFlags(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 selectionFlags; |
| #ifndef SetDataBrowserSelectionFlags |
| PyMac_PRECHECK(SetDataBrowserSelectionFlags); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &selectionFlags)) |
| return NULL; |
| _err = SetDataBrowserSelectionFlags(_self->ob_itself, |
| selectionFlags); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserSelectionFlags(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 selectionFlags; |
| #ifndef GetDataBrowserSelectionFlags |
| PyMac_PRECHECK(GetDataBrowserSelectionFlags); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserSelectionFlags(_self->ob_itself, |
| &selectionFlags); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| selectionFlags); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserPropertyFlags(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 property; |
| UInt32 flags; |
| #ifndef SetDataBrowserPropertyFlags |
| PyMac_PRECHECK(SetDataBrowserPropertyFlags); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &property, |
| &flags)) |
| return NULL; |
| _err = SetDataBrowserPropertyFlags(_self->ob_itself, |
| property, |
| flags); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserPropertyFlags(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 property; |
| UInt32 flags; |
| #ifndef GetDataBrowserPropertyFlags |
| PyMac_PRECHECK(GetDataBrowserPropertyFlags); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &property)) |
| return NULL; |
| _err = GetDataBrowserPropertyFlags(_self->ob_itself, |
| property, |
| &flags); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| flags); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserEditText(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| CFStringRef text; |
| #ifndef SetDataBrowserEditText |
| PyMac_PRECHECK(SetDataBrowserEditText); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CFStringRefObj_Convert, &text)) |
| return NULL; |
| _err = SetDataBrowserEditText(_self->ob_itself, |
| text); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_CopyDataBrowserEditText(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| CFStringRef text; |
| #ifndef CopyDataBrowserEditText |
| PyMac_PRECHECK(CopyDataBrowserEditText); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = CopyDataBrowserEditText(_self->ob_itself, |
| &text); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CFStringRefObj_New, text); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserEditText(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| CFMutableStringRef text; |
| #ifndef GetDataBrowserEditText |
| PyMac_PRECHECK(GetDataBrowserEditText); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CFMutableStringRefObj_Convert, &text)) |
| return NULL; |
| _err = GetDataBrowserEditText(_self->ob_itself, |
| text); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserEditItem(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 item; |
| UInt32 property; |
| #ifndef SetDataBrowserEditItem |
| PyMac_PRECHECK(SetDataBrowserEditItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &item, |
| &property)) |
| return NULL; |
| _err = SetDataBrowserEditItem(_self->ob_itself, |
| item, |
| property); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserEditItem(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 item; |
| UInt32 property; |
| #ifndef GetDataBrowserEditItem |
| PyMac_PRECHECK(GetDataBrowserEditItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserEditItem(_self->ob_itself, |
| &item, |
| &property); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("ll", |
| item, |
| property); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserItemPartBounds(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 item; |
| UInt32 property; |
| OSType part; |
| Rect bounds; |
| #ifndef GetDataBrowserItemPartBounds |
| PyMac_PRECHECK(GetDataBrowserItemPartBounds); |
| #endif |
| if (!PyArg_ParseTuple(_args, "llO&", |
| &item, |
| &property, |
| PyMac_GetOSType, &part)) |
| return NULL; |
| _err = GetDataBrowserItemPartBounds(_self->ob_itself, |
| item, |
| property, |
| part, |
| &bounds); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildRect, &bounds); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_RemoveDataBrowserTableViewColumn(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 column; |
| #ifndef RemoveDataBrowserTableViewColumn |
| PyMac_PRECHECK(RemoveDataBrowserTableViewColumn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &column)) |
| return NULL; |
| _err = RemoveDataBrowserTableViewColumn(_self->ob_itself, |
| column); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserTableViewColumnCount(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 numColumns; |
| #ifndef GetDataBrowserTableViewColumnCount |
| PyMac_PRECHECK(GetDataBrowserTableViewColumnCount); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserTableViewColumnCount(_self->ob_itself, |
| &numColumns); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| numColumns); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserTableViewHiliteStyle(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 hiliteStyle; |
| #ifndef SetDataBrowserTableViewHiliteStyle |
| PyMac_PRECHECK(SetDataBrowserTableViewHiliteStyle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &hiliteStyle)) |
| return NULL; |
| _err = SetDataBrowserTableViewHiliteStyle(_self->ob_itself, |
| hiliteStyle); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserTableViewHiliteStyle(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 hiliteStyle; |
| #ifndef GetDataBrowserTableViewHiliteStyle |
| PyMac_PRECHECK(GetDataBrowserTableViewHiliteStyle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserTableViewHiliteStyle(_self->ob_itself, |
| &hiliteStyle); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| hiliteStyle); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserTableViewRowHeight(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt16 height; |
| #ifndef SetDataBrowserTableViewRowHeight |
| PyMac_PRECHECK(SetDataBrowserTableViewRowHeight); |
| #endif |
| if (!PyArg_ParseTuple(_args, "H", |
| &height)) |
| return NULL; |
| _err = SetDataBrowserTableViewRowHeight(_self->ob_itself, |
| height); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserTableViewRowHeight(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt16 height; |
| #ifndef GetDataBrowserTableViewRowHeight |
| PyMac_PRECHECK(GetDataBrowserTableViewRowHeight); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserTableViewRowHeight(_self->ob_itself, |
| &height); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("H", |
| height); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserTableViewColumnWidth(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt16 width; |
| #ifndef SetDataBrowserTableViewColumnWidth |
| PyMac_PRECHECK(SetDataBrowserTableViewColumnWidth); |
| #endif |
| if (!PyArg_ParseTuple(_args, "H", |
| &width)) |
| return NULL; |
| _err = SetDataBrowserTableViewColumnWidth(_self->ob_itself, |
| width); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserTableViewColumnWidth(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt16 width; |
| #ifndef GetDataBrowserTableViewColumnWidth |
| PyMac_PRECHECK(GetDataBrowserTableViewColumnWidth); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserTableViewColumnWidth(_self->ob_itself, |
| &width); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("H", |
| width); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserTableViewItemRowHeight(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 item; |
| UInt16 height; |
| #ifndef SetDataBrowserTableViewItemRowHeight |
| PyMac_PRECHECK(SetDataBrowserTableViewItemRowHeight); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lH", |
| &item, |
| &height)) |
| return NULL; |
| _err = SetDataBrowserTableViewItemRowHeight(_self->ob_itself, |
| item, |
| height); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserTableViewItemRowHeight(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 item; |
| UInt16 height; |
| #ifndef GetDataBrowserTableViewItemRowHeight |
| PyMac_PRECHECK(GetDataBrowserTableViewItemRowHeight); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &item)) |
| return NULL; |
| _err = GetDataBrowserTableViewItemRowHeight(_self->ob_itself, |
| item, |
| &height); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("H", |
| height); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserTableViewNamedColumnWidth(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 column; |
| UInt16 width; |
| #ifndef SetDataBrowserTableViewNamedColumnWidth |
| PyMac_PRECHECK(SetDataBrowserTableViewNamedColumnWidth); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lH", |
| &column, |
| &width)) |
| return NULL; |
| _err = SetDataBrowserTableViewNamedColumnWidth(_self->ob_itself, |
| column, |
| width); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserTableViewNamedColumnWidth(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 column; |
| UInt16 width; |
| #ifndef GetDataBrowserTableViewNamedColumnWidth |
| PyMac_PRECHECK(GetDataBrowserTableViewNamedColumnWidth); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &column)) |
| return NULL; |
| _err = GetDataBrowserTableViewNamedColumnWidth(_self->ob_itself, |
| column, |
| &width); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("H", |
| width); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserTableViewGeometry(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Boolean variableWidthColumns; |
| Boolean variableHeightRows; |
| #ifndef SetDataBrowserTableViewGeometry |
| PyMac_PRECHECK(SetDataBrowserTableViewGeometry); |
| #endif |
| if (!PyArg_ParseTuple(_args, "bb", |
| &variableWidthColumns, |
| &variableHeightRows)) |
| return NULL; |
| _err = SetDataBrowserTableViewGeometry(_self->ob_itself, |
| variableWidthColumns, |
| variableHeightRows); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserTableViewGeometry(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Boolean variableWidthColumns; |
| Boolean variableHeightRows; |
| #ifndef GetDataBrowserTableViewGeometry |
| PyMac_PRECHECK(GetDataBrowserTableViewGeometry); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserTableViewGeometry(_self->ob_itself, |
| &variableWidthColumns, |
| &variableHeightRows); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("bb", |
| variableWidthColumns, |
| variableHeightRows); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserTableViewItemID(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 row; |
| UInt32 item; |
| #ifndef GetDataBrowserTableViewItemID |
| PyMac_PRECHECK(GetDataBrowserTableViewItemID); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &row)) |
| return NULL; |
| _err = GetDataBrowserTableViewItemID(_self->ob_itself, |
| row, |
| &item); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| item); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserTableViewItemRow(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 item; |
| UInt32 row; |
| #ifndef SetDataBrowserTableViewItemRow |
| PyMac_PRECHECK(SetDataBrowserTableViewItemRow); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &item, |
| &row)) |
| return NULL; |
| _err = SetDataBrowserTableViewItemRow(_self->ob_itself, |
| item, |
| row); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserTableViewItemRow(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 item; |
| UInt32 row; |
| #ifndef GetDataBrowserTableViewItemRow |
| PyMac_PRECHECK(GetDataBrowserTableViewItemRow); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &item)) |
| return NULL; |
| _err = GetDataBrowserTableViewItemRow(_self->ob_itself, |
| item, |
| &row); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| row); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserTableViewColumnPosition(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 column; |
| UInt32 position; |
| #ifndef SetDataBrowserTableViewColumnPosition |
| PyMac_PRECHECK(SetDataBrowserTableViewColumnPosition); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &column, |
| &position)) |
| return NULL; |
| _err = SetDataBrowserTableViewColumnPosition(_self->ob_itself, |
| column, |
| position); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserTableViewColumnPosition(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 column; |
| UInt32 position; |
| #ifndef GetDataBrowserTableViewColumnPosition |
| PyMac_PRECHECK(GetDataBrowserTableViewColumnPosition); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &column)) |
| return NULL; |
| _err = GetDataBrowserTableViewColumnPosition(_self->ob_itself, |
| column, |
| &position); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| position); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserTableViewColumnProperty(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 column; |
| UInt32 property; |
| #ifndef GetDataBrowserTableViewColumnProperty |
| PyMac_PRECHECK(GetDataBrowserTableViewColumnProperty); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &column)) |
| return NULL; |
| _err = GetDataBrowserTableViewColumnProperty(_self->ob_itself, |
| column, |
| &property); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| property); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_AutoSizeDataBrowserListViewColumns(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| #ifndef AutoSizeDataBrowserListViewColumns |
| PyMac_PRECHECK(AutoSizeDataBrowserListViewColumns); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = AutoSizeDataBrowserListViewColumns(_self->ob_itself); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_AddDataBrowserListViewColumn(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| DataBrowserListViewColumnDesc columnDesc; |
| UInt32 position; |
| #ifndef AddDataBrowserListViewColumn |
| PyMac_PRECHECK(AddDataBrowserListViewColumn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| DataBrowserListViewColumnDesc_Convert, &columnDesc, |
| &position)) |
| return NULL; |
| _err = AddDataBrowserListViewColumn(_self->ob_itself, |
| &columnDesc, |
| position); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserListViewHeaderBtnHeight(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt16 height; |
| #ifndef SetDataBrowserListViewHeaderBtnHeight |
| PyMac_PRECHECK(SetDataBrowserListViewHeaderBtnHeight); |
| #endif |
| if (!PyArg_ParseTuple(_args, "H", |
| &height)) |
| return NULL; |
| _err = SetDataBrowserListViewHeaderBtnHeight(_self->ob_itself, |
| height); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserListViewHeaderBtnHeight(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt16 height; |
| #ifndef GetDataBrowserListViewHeaderBtnHeight |
| PyMac_PRECHECK(GetDataBrowserListViewHeaderBtnHeight); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserListViewHeaderBtnHeight(_self->ob_itself, |
| &height); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("H", |
| height); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserListViewUsePlainBackground(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Boolean usePlainBackground; |
| #ifndef SetDataBrowserListViewUsePlainBackground |
| PyMac_PRECHECK(SetDataBrowserListViewUsePlainBackground); |
| #endif |
| if (!PyArg_ParseTuple(_args, "b", |
| &usePlainBackground)) |
| return NULL; |
| _err = SetDataBrowserListViewUsePlainBackground(_self->ob_itself, |
| usePlainBackground); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserListViewUsePlainBackground(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Boolean usePlainBackground; |
| #ifndef GetDataBrowserListViewUsePlainBackground |
| PyMac_PRECHECK(GetDataBrowserListViewUsePlainBackground); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserListViewUsePlainBackground(_self->ob_itself, |
| &usePlainBackground); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("b", |
| usePlainBackground); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserListViewDisclosureColumn(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 column; |
| Boolean expandableRows; |
| #ifndef SetDataBrowserListViewDisclosureColumn |
| PyMac_PRECHECK(SetDataBrowserListViewDisclosureColumn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lb", |
| &column, |
| &expandableRows)) |
| return NULL; |
| _err = SetDataBrowserListViewDisclosureColumn(_self->ob_itself, |
| column, |
| expandableRows); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserListViewDisclosureColumn(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 column; |
| Boolean expandableRows; |
| #ifndef GetDataBrowserListViewDisclosureColumn |
| PyMac_PRECHECK(GetDataBrowserListViewDisclosureColumn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserListViewDisclosureColumn(_self->ob_itself, |
| &column, |
| &expandableRows); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("lb", |
| column, |
| expandableRows); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserColumnViewPath(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Handle path; |
| #ifndef GetDataBrowserColumnViewPath |
| PyMac_PRECHECK(GetDataBrowserColumnViewPath); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &path)) |
| return NULL; |
| _err = GetDataBrowserColumnViewPath(_self->ob_itself, |
| path); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserColumnViewPathLength(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 pathLength; |
| #ifndef GetDataBrowserColumnViewPathLength |
| PyMac_PRECHECK(GetDataBrowserColumnViewPathLength); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserColumnViewPathLength(_self->ob_itself, |
| &pathLength); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| pathLength); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_SetDataBrowserColumnViewDisplayType(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| OSType propertyType; |
| #ifndef SetDataBrowserColumnViewDisplayType |
| PyMac_PRECHECK(SetDataBrowserColumnViewDisplayType); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetOSType, &propertyType)) |
| return NULL; |
| _err = SetDataBrowserColumnViewDisplayType(_self->ob_itself, |
| propertyType); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetDataBrowserColumnViewDisplayType(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| OSType propertyType; |
| #ifndef GetDataBrowserColumnViewDisplayType |
| PyMac_PRECHECK(GetDataBrowserColumnViewDisplayType); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDataBrowserColumnViewDisplayType(_self->ob_itself, |
| &propertyType); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildOSType, propertyType); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_as_Resource(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Handle _rv; |
| #ifndef as_Resource |
| PyMac_PRECHECK(as_Resource); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = as_Resource(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_GetControlRect(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Rect rect; |
| #ifndef GetControlRect |
| PyMac_PRECHECK(GetControlRect); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetControlRect(_self->ob_itself, |
| &rect); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildRect, &rect); |
| return _res; |
| } |
| |
| static PyObject *CtlObj_DisposeControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| if ( _self->ob_itself ) { |
| SetControlReference(_self->ob_itself, (long)0); /* Make it forget about us */ |
| DisposeControl(_self->ob_itself); |
| _self->ob_itself = NULL; |
| } |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| |
| } |
| |
| static PyObject *CtlObj_TrackControl(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| |
| ControlPartCode _rv; |
| Point startPoint; |
| ControlActionUPP upp = 0; |
| PyObject *callback = 0; |
| |
| if (!PyArg_ParseTuple(_args, "O&|O", |
| PyMac_GetPoint, &startPoint, &callback)) |
| return NULL; |
| if (callback && callback != Py_None) { |
| if (PyLong_Check(callback) && PyLong_AS_LONG(callback) == -1) |
| upp = (ControlActionUPP)-1; |
| else { |
| settrackfunc(callback); |
| upp = mytracker_upp; |
| } |
| } |
| _rv = TrackControl(_self->ob_itself, |
| startPoint, |
| upp); |
| clrtrackfunc(); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| |
| } |
| |
| static PyObject *CtlObj_HandleControlClick(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| |
| ControlPartCode _rv; |
| Point startPoint; |
| SInt16 modifiers; |
| ControlActionUPP upp = 0; |
| PyObject *callback = 0; |
| |
| if (!PyArg_ParseTuple(_args, "O&h|O", |
| PyMac_GetPoint, &startPoint, |
| &modifiers, |
| &callback)) |
| return NULL; |
| if (callback && callback != Py_None) { |
| if (PyLong_Check(callback) && PyLong_AS_LONG(callback) == -1) |
| upp = (ControlActionUPP)-1; |
| else { |
| settrackfunc(callback); |
| upp = mytracker_upp; |
| } |
| } |
| _rv = HandleControlClick(_self->ob_itself, |
| startPoint, |
| modifiers, |
| upp); |
| clrtrackfunc(); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| |
| } |
| |
| static PyObject *CtlObj_SetControlData(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| |
| OSErr _err; |
| ControlPartCode inPart; |
| ResType inTagName; |
| Size bufferSize; |
| Ptr buffer; |
| |
| if (!PyArg_ParseTuple(_args, "hO&s#", |
| &inPart, |
| PyMac_GetOSType, &inTagName, |
| &buffer, &bufferSize)) |
| return NULL; |
| |
| _err = SetControlData(_self->ob_itself, |
| inPart, |
| inTagName, |
| bufferSize, |
| buffer); |
| |
| if (_err != noErr) |
| return PyMac_Error(_err); |
| _res = Py_None; |
| return _res; |
| |
| } |
| |
| static PyObject *CtlObj_GetControlData(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| |
| OSErr _err; |
| ControlPartCode inPart; |
| ResType inTagName; |
| Size bufferSize; |
| Ptr buffer; |
| Size outSize; |
| |
| if (!PyArg_ParseTuple(_args, "hO&", |
| &inPart, |
| PyMac_GetOSType, &inTagName)) |
| return NULL; |
| |
| /* allocate a buffer for the data */ |
| _err = GetControlDataSize(_self->ob_itself, |
| inPart, |
| inTagName, |
| &bufferSize); |
| if (_err != noErr) |
| return PyMac_Error(_err); |
| buffer = PyMem_NEW(char, bufferSize); |
| if (buffer == NULL) |
| return PyErr_NoMemory(); |
| |
| _err = GetControlData(_self->ob_itself, |
| inPart, |
| inTagName, |
| bufferSize, |
| buffer, |
| &outSize); |
| |
| if (_err != noErr) { |
| PyMem_DEL(buffer); |
| return PyMac_Error(_err); |
| } |
| _res = Py_BuildValue("s#", buffer, outSize); |
| PyMem_DEL(buffer); |
| return _res; |
| |
| } |
| |
| static PyObject *CtlObj_SetControlData_Handle(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| |
| OSErr _err; |
| ControlPartCode inPart; |
| ResType inTagName; |
| Handle buffer; |
| |
| if (!PyArg_ParseTuple(_args, "hO&O&", |
| &inPart, |
| PyMac_GetOSType, &inTagName, |
| OptResObj_Convert, &buffer)) |
| return NULL; |
| |
| _err = SetControlData(_self->ob_itself, |
| inPart, |
| inTagName, |
| sizeof(buffer), |
| (Ptr)&buffer); |
| |
| if (_err != noErr) |
| return PyMac_Error(_err); |
| _res = Py_None; |
| return _res; |
| |
| } |
| |
| static PyObject *CtlObj_GetControlData_Handle(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| |
| OSErr _err; |
| ControlPartCode inPart; |
| ResType inTagName; |
| Size bufferSize; |
| Handle hdl; |
| |
| if (!PyArg_ParseTuple(_args, "hO&", |
| &inPart, |
| PyMac_GetOSType, &inTagName)) |
| return NULL; |
| |
| /* Check it is handle-sized */ |
| _err = GetControlDataSize(_self->ob_itself, |
| inPart, |
| inTagName, |
| &bufferSize); |
| if (_err != noErr) |
| return PyMac_Error(_err); |
| if (bufferSize != sizeof(Handle)) { |
| PyErr_SetString(Ctl_Error, "GetControlDataSize() != sizeof(Handle)"); |
| return NULL; |
| } |
| |
| _err = GetControlData(_self->ob_itself, |
| inPart, |
| inTagName, |
| sizeof(Handle), |
| (Ptr)&hdl, |
| &bufferSize); |
| |
| if (_err != noErr) { |
| return PyMac_Error(_err); |
| } |
| _res = Py_BuildValue("O&", OptResObj_New, hdl); |
| return _res; |
| |
| } |
| |
| static PyObject *CtlObj_SetControlData_Callback(ControlObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| |
| OSErr _err; |
| ControlPartCode inPart; |
| ResType inTagName; |
| PyObject *callback; |
| UniversalProcPtr c_callback; |
| |
| if (!PyArg_ParseTuple(_args, "hO&O", |
| &inPart, |
| PyMac_GetOSType, &inTagName, |
| &callback)) |
| return NULL; |
| |
| if ( setcallback((PyObject *)_self, inTagName, callback, &c_callback) < 0 ) |
| return NULL; |
| _err = SetControlData(_self->ob_itself, |
| inPart, |
| inTagName, |
| sizeof(c_callback), |
| (Ptr)&c_callback); |
| |
| if (_err != noErr) |
| return PyMac_Error(_err); |
| _res = Py_None; |
| return _res; |
| |
| } |
| |
| static PyMethodDef CtlObj_methods[] = { |
| {"HiliteControl", (PyCFunction)CtlObj_HiliteControl, 1, |
| PyDoc_STR("(ControlPartCode hiliteState) -> None")}, |
| {"ShowControl", (PyCFunction)CtlObj_ShowControl, 1, |
| PyDoc_STR("() -> None")}, |
| {"HideControl", (PyCFunction)CtlObj_HideControl, 1, |
| PyDoc_STR("() -> None")}, |
| {"IsControlActive", (PyCFunction)CtlObj_IsControlActive, 1, |
| PyDoc_STR("() -> (Boolean _rv)")}, |
| {"IsControlVisible", (PyCFunction)CtlObj_IsControlVisible, 1, |
| PyDoc_STR("() -> (Boolean _rv)")}, |
| {"ActivateControl", (PyCFunction)CtlObj_ActivateControl, 1, |
| PyDoc_STR("() -> None")}, |
| {"DeactivateControl", (PyCFunction)CtlObj_DeactivateControl, 1, |
| PyDoc_STR("() -> None")}, |
| {"SetControlVisibility", (PyCFunction)CtlObj_SetControlVisibility, 1, |
| PyDoc_STR("(Boolean inIsVisible, Boolean inDoDraw) -> None")}, |
| {"IsControlEnabled", (PyCFunction)CtlObj_IsControlEnabled, 1, |
| PyDoc_STR("() -> (Boolean _rv)")}, |
| {"EnableControl", (PyCFunction)CtlObj_EnableControl, 1, |
| PyDoc_STR("() -> None")}, |
| {"DisableControl", (PyCFunction)CtlObj_DisableControl, 1, |
| PyDoc_STR("() -> None")}, |
| {"Draw1Control", (PyCFunction)CtlObj_Draw1Control, 1, |
| PyDoc_STR("() -> None")}, |
| {"GetBestControlRect", (PyCFunction)CtlObj_GetBestControlRect, 1, |
| PyDoc_STR("() -> (Rect outRect, SInt16 outBaseLineOffset)")}, |
| {"SetControlFontStyle", (PyCFunction)CtlObj_SetControlFontStyle, 1, |
| PyDoc_STR("(ControlFontStyleRec inStyle) -> None")}, |
| {"DrawControlInCurrentPort", (PyCFunction)CtlObj_DrawControlInCurrentPort, 1, |
| PyDoc_STR("() -> None")}, |
| {"SetUpControlBackground", (PyCFunction)CtlObj_SetUpControlBackground, 1, |
| PyDoc_STR("(SInt16 inDepth, Boolean inIsColorDevice) -> None")}, |
| {"SetUpControlTextColor", (PyCFunction)CtlObj_SetUpControlTextColor, 1, |
| PyDoc_STR("(SInt16 inDepth, Boolean inIsColorDevice) -> None")}, |
| {"DragControl", (PyCFunction)CtlObj_DragControl, 1, |
| PyDoc_STR("(Point startPoint, Rect limitRect, Rect slopRect, DragConstraint axis) -> None")}, |
| {"TestControl", (PyCFunction)CtlObj_TestControl, 1, |
| PyDoc_STR("(Point testPoint) -> (ControlPartCode _rv)")}, |
| {"HandleControlContextualMenuClick", (PyCFunction)CtlObj_HandleControlContextualMenuClick, 1, |
| PyDoc_STR("(Point inWhere) -> (Boolean menuDisplayed)")}, |
| {"GetControlClickActivation", (PyCFunction)CtlObj_GetControlClickActivation, 1, |
| PyDoc_STR("(Point inWhere, EventModifiers inModifiers) -> (ClickActivationResult outResult)")}, |
| {"HandleControlKey", (PyCFunction)CtlObj_HandleControlKey, 1, |
| PyDoc_STR("(SInt16 inKeyCode, SInt16 inCharCode, EventModifiers inModifiers) -> (ControlPartCode _rv)")}, |
| {"HandleControlSetCursor", (PyCFunction)CtlObj_HandleControlSetCursor, 1, |
| PyDoc_STR("(Point localPoint, EventModifiers modifiers) -> (Boolean cursorWasSet)")}, |
| {"MoveControl", (PyCFunction)CtlObj_MoveControl, 1, |
| PyDoc_STR("(SInt16 h, SInt16 v) -> None")}, |
| {"SizeControl", (PyCFunction)CtlObj_SizeControl, 1, |
| PyDoc_STR("(SInt16 w, SInt16 h) -> None")}, |
| {"SetControlTitle", (PyCFunction)CtlObj_SetControlTitle, 1, |
| PyDoc_STR("(Str255 title) -> None")}, |
| {"GetControlTitle", (PyCFunction)CtlObj_GetControlTitle, 1, |
| PyDoc_STR("() -> (Str255 title)")}, |
| {"SetControlTitleWithCFString", (PyCFunction)CtlObj_SetControlTitleWithCFString, 1, |
| PyDoc_STR("(CFStringRef inString) -> None")}, |
| {"CopyControlTitleAsCFString", (PyCFunction)CtlObj_CopyControlTitleAsCFString, 1, |
| PyDoc_STR("() -> (CFStringRef outString)")}, |
| {"GetControlValue", (PyCFunction)CtlObj_GetControlValue, 1, |
| PyDoc_STR("() -> (SInt16 _rv)")}, |
| {"SetControlValue", (PyCFunction)CtlObj_SetControlValue, 1, |
| PyDoc_STR("(SInt16 newValue) -> None")}, |
| {"GetControlMinimum", (PyCFunction)CtlObj_GetControlMinimum, 1, |
| PyDoc_STR("() -> (SInt16 _rv)")}, |
| {"SetControlMinimum", (PyCFunction)CtlObj_SetControlMinimum, 1, |
| PyDoc_STR("(SInt16 newMinimum) -> None")}, |
| {"GetControlMaximum", (PyCFunction)CtlObj_GetControlMaximum, 1, |
| PyDoc_STR("() -> (SInt16 _rv)")}, |
| {"SetControlMaximum", (PyCFunction)CtlObj_SetControlMaximum, 1, |
| PyDoc_STR("(SInt16 newMaximum) -> None")}, |
| {"GetControlViewSize", (PyCFunction)CtlObj_GetControlViewSize, 1, |
| PyDoc_STR("() -> (SInt32 _rv)")}, |
| {"SetControlViewSize", (PyCFunction)CtlObj_SetControlViewSize, 1, |
| PyDoc_STR("(SInt32 newViewSize) -> None")}, |
| {"GetControl32BitValue", (PyCFunction)CtlObj_GetControl32BitValue, 1, |
| PyDoc_STR("() -> (SInt32 _rv)")}, |
| {"SetControl32BitValue", (PyCFunction)CtlObj_SetControl32BitValue, 1, |
| PyDoc_STR("(SInt32 newValue) -> None")}, |
| {"GetControl32BitMaximum", (PyCFunction)CtlObj_GetControl32BitMaximum, 1, |
| PyDoc_STR("() -> (SInt32 _rv)")}, |
| {"SetControl32BitMaximum", (PyCFunction)CtlObj_SetControl32BitMaximum, 1, |
| PyDoc_STR("(SInt32 newMaximum) -> None")}, |
| {"GetControl32BitMinimum", (PyCFunction)CtlObj_GetControl32BitMinimum, 1, |
| PyDoc_STR("() -> (SInt32 _rv)")}, |
| {"SetControl32BitMinimum", (PyCFunction)CtlObj_SetControl32BitMinimum, 1, |
| PyDoc_STR("(SInt32 newMinimum) -> None")}, |
| {"IsValidControlHandle", (PyCFunction)CtlObj_IsValidControlHandle, 1, |
| PyDoc_STR("() -> (Boolean _rv)")}, |
| {"SetControlID", (PyCFunction)CtlObj_SetControlID, 1, |
| PyDoc_STR("(ControlID inID) -> None")}, |
| {"GetControlID", (PyCFunction)CtlObj_GetControlID, 1, |
| PyDoc_STR("() -> (ControlID outID)")}, |
| {"SetControlCommandID", (PyCFunction)CtlObj_SetControlCommandID, 1, |
| PyDoc_STR("(UInt32 inCommandID) -> None")}, |
| {"GetControlCommandID", (PyCFunction)CtlObj_GetControlCommandID, 1, |
| PyDoc_STR("() -> (UInt32 outCommandID)")}, |
| {"RemoveControlProperty", (PyCFunction)CtlObj_RemoveControlProperty, 1, |
| PyDoc_STR("(OSType propertyCreator, OSType propertyTag) -> None")}, |
| {"GetControlPropertyAttributes", (PyCFunction)CtlObj_GetControlPropertyAttributes, 1, |
| PyDoc_STR("(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)")}, |
| {"ChangeControlPropertyAttributes", (PyCFunction)CtlObj_ChangeControlPropertyAttributes, 1, |
| PyDoc_STR("(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None")}, |
| {"GetControlRegion", (PyCFunction)CtlObj_GetControlRegion, 1, |
| PyDoc_STR("(ControlPartCode inPart, RgnHandle outRegion) -> None")}, |
| {"GetControlVariant", (PyCFunction)CtlObj_GetControlVariant, 1, |
| PyDoc_STR("() -> (ControlVariant _rv)")}, |
| {"SetControlAction", (PyCFunction)CtlObj_SetControlAction, 1, |
| PyDoc_STR("(PyObject* actionProc) -> None")}, |
| {"SetControlReference", (PyCFunction)CtlObj_SetControlReference, 1, |
| PyDoc_STR("(SInt32 data) -> None")}, |
| {"GetControlReference", (PyCFunction)CtlObj_GetControlReference, 1, |
| PyDoc_STR("() -> (SInt32 _rv)")}, |
| {"EmbedControl", (PyCFunction)CtlObj_EmbedControl, 1, |
| PyDoc_STR("(ControlHandle inContainer) -> None")}, |
| {"AutoEmbedControl", (PyCFunction)CtlObj_AutoEmbedControl, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> None")}, |
| {"GetSuperControl", (PyCFunction)CtlObj_GetSuperControl, 1, |
| PyDoc_STR("() -> (ControlHandle outParent)")}, |
| {"CountSubControls", (PyCFunction)CtlObj_CountSubControls, 1, |
| PyDoc_STR("() -> (UInt16 outNumChildren)")}, |
| {"GetIndexedSubControl", (PyCFunction)CtlObj_GetIndexedSubControl, 1, |
| PyDoc_STR("(UInt16 inIndex) -> (ControlHandle outSubControl)")}, |
| {"SetControlSupervisor", (PyCFunction)CtlObj_SetControlSupervisor, 1, |
| PyDoc_STR("(ControlHandle inBoss) -> None")}, |
| {"GetControlFeatures", (PyCFunction)CtlObj_GetControlFeatures, 1, |
| PyDoc_STR("() -> (UInt32 outFeatures)")}, |
| {"GetControlDataSize", (PyCFunction)CtlObj_GetControlDataSize, 1, |
| PyDoc_STR("(ControlPartCode inPart, ResType inTagName) -> (Size outMaxSize)")}, |
| {"HandleControlDragTracking", (PyCFunction)CtlObj_HandleControlDragTracking, 1, |
| PyDoc_STR("(DragTrackingMessage inMessage, DragReference inDrag) -> (Boolean outLikesDrag)")}, |
| {"HandleControlDragReceive", (PyCFunction)CtlObj_HandleControlDragReceive, 1, |
| PyDoc_STR("(DragReference inDrag) -> None")}, |
| {"SetControlDragTrackingEnabled", (PyCFunction)CtlObj_SetControlDragTrackingEnabled, 1, |
| PyDoc_STR("(Boolean inTracks) -> None")}, |
| {"IsControlDragTrackingEnabled", (PyCFunction)CtlObj_IsControlDragTrackingEnabled, 1, |
| PyDoc_STR("() -> (Boolean outTracks)")}, |
| {"GetControlBounds", (PyCFunction)CtlObj_GetControlBounds, 1, |
| PyDoc_STR("() -> (Rect bounds)")}, |
| {"IsControlHilited", (PyCFunction)CtlObj_IsControlHilited, 1, |
| PyDoc_STR("() -> (Boolean _rv)")}, |
| {"GetControlHilite", (PyCFunction)CtlObj_GetControlHilite, 1, |
| PyDoc_STR("() -> (UInt16 _rv)")}, |
| {"GetControlOwner", (PyCFunction)CtlObj_GetControlOwner, 1, |
| PyDoc_STR("() -> (WindowPtr _rv)")}, |
| {"GetControlDataHandle", (PyCFunction)CtlObj_GetControlDataHandle, 1, |
| PyDoc_STR("() -> (Handle _rv)")}, |
| {"GetControlPopupMenuHandle", (PyCFunction)CtlObj_GetControlPopupMenuHandle, 1, |
| PyDoc_STR("() -> (MenuHandle _rv)")}, |
| {"GetControlPopupMenuID", (PyCFunction)CtlObj_GetControlPopupMenuID, 1, |
| PyDoc_STR("() -> (short _rv)")}, |
| {"SetControlDataHandle", (PyCFunction)CtlObj_SetControlDataHandle, 1, |
| PyDoc_STR("(Handle dataHandle) -> None")}, |
| {"SetControlBounds", (PyCFunction)CtlObj_SetControlBounds, 1, |
| PyDoc_STR("(Rect bounds) -> None")}, |
| {"SetControlPopupMenuHandle", (PyCFunction)CtlObj_SetControlPopupMenuHandle, 1, |
| PyDoc_STR("(MenuHandle popupMenu) -> None")}, |
| {"SetControlPopupMenuID", (PyCFunction)CtlObj_SetControlPopupMenuID, 1, |
| PyDoc_STR("(short menuID) -> None")}, |
| {"GetBevelButtonMenuValue", (PyCFunction)CtlObj_GetBevelButtonMenuValue, 1, |
| PyDoc_STR("() -> (SInt16 outValue)")}, |
| {"SetBevelButtonMenuValue", (PyCFunction)CtlObj_SetBevelButtonMenuValue, 1, |
| PyDoc_STR("(SInt16 inValue) -> None")}, |
| {"GetBevelButtonMenuHandle", (PyCFunction)CtlObj_GetBevelButtonMenuHandle, 1, |
| PyDoc_STR("() -> (MenuHandle outHandle)")}, |
| {"SetBevelButtonContentInfo", (PyCFunction)CtlObj_SetBevelButtonContentInfo, 1, |
| PyDoc_STR("(ControlButtonContentInfo inContent) -> None")}, |
| {"SetBevelButtonTransform", (PyCFunction)CtlObj_SetBevelButtonTransform, 1, |
| PyDoc_STR("(IconTransformType transform) -> None")}, |
| {"SetDisclosureTriangleLastValue", (PyCFunction)CtlObj_SetDisclosureTriangleLastValue, 1, |
| PyDoc_STR("(SInt16 inValue) -> None")}, |
| {"GetTabContentRect", (PyCFunction)CtlObj_GetTabContentRect, 1, |
| PyDoc_STR("() -> (Rect outContentRect)")}, |
| {"SetTabEnabled", (PyCFunction)CtlObj_SetTabEnabled, 1, |
| PyDoc_STR("(SInt16 inTabToHilite, Boolean inEnabled) -> None")}, |
| {"SetImageWellContentInfo", (PyCFunction)CtlObj_SetImageWellContentInfo, 1, |
| PyDoc_STR("(ControlButtonContentInfo inContent) -> None")}, |
| {"SetImageWellTransform", (PyCFunction)CtlObj_SetImageWellTransform, 1, |
| PyDoc_STR("(IconTransformType inTransform) -> None")}, |
| {"GetDataBrowserViewStyle", (PyCFunction)CtlObj_GetDataBrowserViewStyle, 1, |
| PyDoc_STR("() -> (OSType style)")}, |
| {"SetDataBrowserViewStyle", (PyCFunction)CtlObj_SetDataBrowserViewStyle, 1, |
| PyDoc_STR("(OSType style) -> None")}, |
| {"EnableDataBrowserEditCommand", (PyCFunction)CtlObj_EnableDataBrowserEditCommand, 1, |
| PyDoc_STR("(UInt32 command) -> (Boolean _rv)")}, |
| {"ExecuteDataBrowserEditCommand", (PyCFunction)CtlObj_ExecuteDataBrowserEditCommand, 1, |
| PyDoc_STR("(UInt32 command) -> None")}, |
| {"GetDataBrowserSelectionAnchor", (PyCFunction)CtlObj_GetDataBrowserSelectionAnchor, 1, |
| PyDoc_STR("() -> (UInt32 first, UInt32 last)")}, |
| {"MoveDataBrowserSelectionAnchor", (PyCFunction)CtlObj_MoveDataBrowserSelectionAnchor, 1, |
| PyDoc_STR("(UInt32 direction, Boolean extendSelection) -> None")}, |
| {"OpenDataBrowserContainer", (PyCFunction)CtlObj_OpenDataBrowserContainer, 1, |
| PyDoc_STR("(UInt32 container) -> None")}, |
| {"CloseDataBrowserContainer", (PyCFunction)CtlObj_CloseDataBrowserContainer, 1, |
| PyDoc_STR("(UInt32 container) -> None")}, |
| {"SortDataBrowserContainer", (PyCFunction)CtlObj_SortDataBrowserContainer, 1, |
| PyDoc_STR("(UInt32 container, Boolean sortChildren) -> None")}, |
| {"GetDataBrowserItems", (PyCFunction)CtlObj_GetDataBrowserItems, 1, |
| PyDoc_STR("(UInt32 container, Boolean recurse, UInt32 state, Handle items) -> None")}, |
| {"GetDataBrowserItemCount", (PyCFunction)CtlObj_GetDataBrowserItemCount, 1, |
| PyDoc_STR("(UInt32 container, Boolean recurse, UInt32 state) -> (UInt32 numItems)")}, |
| {"IsDataBrowserItemSelected", (PyCFunction)CtlObj_IsDataBrowserItemSelected, 1, |
| PyDoc_STR("(UInt32 item) -> (Boolean _rv)")}, |
| {"GetDataBrowserItemState", (PyCFunction)CtlObj_GetDataBrowserItemState, 1, |
| PyDoc_STR("(UInt32 item) -> (UInt32 state)")}, |
| {"RevealDataBrowserItem", (PyCFunction)CtlObj_RevealDataBrowserItem, 1, |
| PyDoc_STR("(UInt32 item, UInt32 propertyID, UInt8 options) -> None")}, |
| {"SetDataBrowserActiveItems", (PyCFunction)CtlObj_SetDataBrowserActiveItems, 1, |
| PyDoc_STR("(Boolean active) -> None")}, |
| {"GetDataBrowserActiveItems", (PyCFunction)CtlObj_GetDataBrowserActiveItems, 1, |
| PyDoc_STR("() -> (Boolean active)")}, |
| {"SetDataBrowserScrollBarInset", (PyCFunction)CtlObj_SetDataBrowserScrollBarInset, 1, |
| PyDoc_STR("() -> (Rect insetRect)")}, |
| {"GetDataBrowserScrollBarInset", (PyCFunction)CtlObj_GetDataBrowserScrollBarInset, 1, |
| PyDoc_STR("() -> (Rect insetRect)")}, |
| {"SetDataBrowserTarget", (PyCFunction)CtlObj_SetDataBrowserTarget, 1, |
| PyDoc_STR("(UInt32 target) -> None")}, |
| {"GetDataBrowserTarget", (PyCFunction)CtlObj_GetDataBrowserTarget, 1, |
| PyDoc_STR("() -> (UInt32 target)")}, |
| {"SetDataBrowserSortOrder", (PyCFunction)CtlObj_SetDataBrowserSortOrder, 1, |
| PyDoc_STR("(UInt16 order) -> None")}, |
| {"GetDataBrowserSortOrder", (PyCFunction)CtlObj_GetDataBrowserSortOrder, 1, |
| PyDoc_STR("() -> (UInt16 order)")}, |
| {"SetDataBrowserScrollPosition", (PyCFunction)CtlObj_SetDataBrowserScrollPosition, 1, |
| PyDoc_STR("(UInt32 top, UInt32 left) -> None")}, |
| {"GetDataBrowserScrollPosition", (PyCFunction)CtlObj_GetDataBrowserScrollPosition, 1, |
| PyDoc_STR("() -> (UInt32 top, UInt32 left)")}, |
| {"SetDataBrowserHasScrollBars", (PyCFunction)CtlObj_SetDataBrowserHasScrollBars, 1, |
| PyDoc_STR("(Boolean horiz, Boolean vert) -> None")}, |
| {"GetDataBrowserHasScrollBars", (PyCFunction)CtlObj_GetDataBrowserHasScrollBars, 1, |
| PyDoc_STR("() -> (Boolean horiz, Boolean vert)")}, |
| {"SetDataBrowserSortProperty", (PyCFunction)CtlObj_SetDataBrowserSortProperty, 1, |
| PyDoc_STR("(UInt32 property) -> None")}, |
| {"GetDataBrowserSortProperty", (PyCFunction)CtlObj_GetDataBrowserSortProperty, 1, |
| PyDoc_STR("() -> (UInt32 property)")}, |
| {"SetDataBrowserSelectionFlags", (PyCFunction)CtlObj_SetDataBrowserSelectionFlags, 1, |
| PyDoc_STR("(UInt32 selectionFlags) -> None")}, |
| {"GetDataBrowserSelectionFlags", (PyCFunction)CtlObj_GetDataBrowserSelectionFlags, 1, |
| PyDoc_STR("() -> (UInt32 selectionFlags)")}, |
| {"SetDataBrowserPropertyFlags", (PyCFunction)CtlObj_SetDataBrowserPropertyFlags, 1, |
| PyDoc_STR("(UInt32 property, UInt32 flags) -> None")}, |
| {"GetDataBrowserPropertyFlags", (PyCFunction)CtlObj_GetDataBrowserPropertyFlags, 1, |
| PyDoc_STR("(UInt32 property) -> (UInt32 flags)")}, |
| {"SetDataBrowserEditText", (PyCFunction)CtlObj_SetDataBrowserEditText, 1, |
| PyDoc_STR("(CFStringRef text) -> None")}, |
| {"CopyDataBrowserEditText", (PyCFunction)CtlObj_CopyDataBrowserEditText, 1, |
| PyDoc_STR("() -> (CFStringRef text)")}, |
| {"GetDataBrowserEditText", (PyCFunction)CtlObj_GetDataBrowserEditText, 1, |
| PyDoc_STR("(CFMutableStringRef text) -> None")}, |
| {"SetDataBrowserEditItem", (PyCFunction)CtlObj_SetDataBrowserEditItem, 1, |
| PyDoc_STR("(UInt32 item, UInt32 property) -> None")}, |
| {"GetDataBrowserEditItem", (PyCFunction)CtlObj_GetDataBrowserEditItem, 1, |
| PyDoc_STR("() -> (UInt32 item, UInt32 property)")}, |
| {"GetDataBrowserItemPartBounds", (PyCFunction)CtlObj_GetDataBrowserItemPartBounds, 1, |
| PyDoc_STR("(UInt32 item, UInt32 property, OSType part) -> (Rect bounds)")}, |
| {"RemoveDataBrowserTableViewColumn", (PyCFunction)CtlObj_RemoveDataBrowserTableViewColumn, 1, |
| PyDoc_STR("(UInt32 column) -> None")}, |
| {"GetDataBrowserTableViewColumnCount", (PyCFunction)CtlObj_GetDataBrowserTableViewColumnCount, 1, |
| PyDoc_STR("() -> (UInt32 numColumns)")}, |
| {"SetDataBrowserTableViewHiliteStyle", (PyCFunction)CtlObj_SetDataBrowserTableViewHiliteStyle, 1, |
| PyDoc_STR("(UInt32 hiliteStyle) -> None")}, |
| {"GetDataBrowserTableViewHiliteStyle", (PyCFunction)CtlObj_GetDataBrowserTableViewHiliteStyle, 1, |
| PyDoc_STR("() -> (UInt32 hiliteStyle)")}, |
| {"SetDataBrowserTableViewRowHeight", (PyCFunction)CtlObj_SetDataBrowserTableViewRowHeight, 1, |
| PyDoc_STR("(UInt16 height) -> None")}, |
| {"GetDataBrowserTableViewRowHeight", (PyCFunction)CtlObj_GetDataBrowserTableViewRowHeight, 1, |
| PyDoc_STR("() -> (UInt16 height)")}, |
| {"SetDataBrowserTableViewColumnWidth", (PyCFunction)CtlObj_SetDataBrowserTableViewColumnWidth, 1, |
| PyDoc_STR("(UInt16 width) -> None")}, |
| {"GetDataBrowserTableViewColumnWidth", (PyCFunction)CtlObj_GetDataBrowserTableViewColumnWidth, 1, |
| PyDoc_STR("() -> (UInt16 width)")}, |
| {"SetDataBrowserTableViewItemRowHeight", (PyCFunction)CtlObj_SetDataBrowserTableViewItemRowHeight, 1, |
| PyDoc_STR("(UInt32 item, UInt16 height) -> None")}, |
| {"GetDataBrowserTableViewItemRowHeight", (PyCFunction)CtlObj_GetDataBrowserTableViewItemRowHeight, 1, |
| PyDoc_STR("(UInt32 item) -> (UInt16 height)")}, |
| {"SetDataBrowserTableViewNamedColumnWidth", (PyCFunction)CtlObj_SetDataBrowserTableViewNamedColumnWidth, 1, |
| PyDoc_STR("(UInt32 column, UInt16 width) -> None")}, |
| {"GetDataBrowserTableViewNamedColumnWidth", (PyCFunction)CtlObj_GetDataBrowserTableViewNamedColumnWidth, 1, |
| PyDoc_STR("(UInt32 column) -> (UInt16 width)")}, |
| {"SetDataBrowserTableViewGeometry", (PyCFunction)CtlObj_SetDataBrowserTableViewGeometry, 1, |
| PyDoc_STR("(Boolean variableWidthColumns, Boolean variableHeightRows) -> None")}, |
| {"GetDataBrowserTableViewGeometry", (PyCFunction)CtlObj_GetDataBrowserTableViewGeometry, 1, |
| PyDoc_STR("() -> (Boolean variableWidthColumns, Boolean variableHeightRows)")}, |
| {"GetDataBrowserTableViewItemID", (PyCFunction)CtlObj_GetDataBrowserTableViewItemID, 1, |
| PyDoc_STR("(UInt32 row) -> (UInt32 item)")}, |
| {"SetDataBrowserTableViewItemRow", (PyCFunction)CtlObj_SetDataBrowserTableViewItemRow, 1, |
| PyDoc_STR("(UInt32 item, UInt32 row) -> None")}, |
| {"GetDataBrowserTableViewItemRow", (PyCFunction)CtlObj_GetDataBrowserTableViewItemRow, 1, |
| PyDoc_STR("(UInt32 item) -> (UInt32 row)")}, |
| {"SetDataBrowserTableViewColumnPosition", (PyCFunction)CtlObj_SetDataBrowserTableViewColumnPosition, 1, |
| PyDoc_STR("(UInt32 column, UInt32 position) -> None")}, |
| {"GetDataBrowserTableViewColumnPosition", (PyCFunction)CtlObj_GetDataBrowserTableViewColumnPosition, 1, |
| PyDoc_STR("(UInt32 column) -> (UInt32 position)")}, |
| {"GetDataBrowserTableViewColumnProperty", (PyCFunction)CtlObj_GetDataBrowserTableViewColumnProperty, 1, |
| PyDoc_STR("(UInt32 column) -> (UInt32 property)")}, |
| {"AutoSizeDataBrowserListViewColumns", (PyCFunction)CtlObj_AutoSizeDataBrowserListViewColumns, 1, |
| PyDoc_STR("() -> None")}, |
| {"AddDataBrowserListViewColumn", (PyCFunction)CtlObj_AddDataBrowserListViewColumn, 1, |
| PyDoc_STR("(DataBrowserListViewColumnDesc columnDesc, UInt32 position) -> None")}, |
| {"SetDataBrowserListViewHeaderBtnHeight", (PyCFunction)CtlObj_SetDataBrowserListViewHeaderBtnHeight, 1, |
| PyDoc_STR("(UInt16 height) -> None")}, |
| {"GetDataBrowserListViewHeaderBtnHeight", (PyCFunction)CtlObj_GetDataBrowserListViewHeaderBtnHeight, 1, |
| PyDoc_STR("() -> (UInt16 height)")}, |
| {"SetDataBrowserListViewUsePlainBackground", (PyCFunction)CtlObj_SetDataBrowserListViewUsePlainBackground, 1, |
| PyDoc_STR("(Boolean usePlainBackground) -> None")}, |
| {"GetDataBrowserListViewUsePlainBackground", (PyCFunction)CtlObj_GetDataBrowserListViewUsePlainBackground, 1, |
| PyDoc_STR("() -> (Boolean usePlainBackground)")}, |
| {"SetDataBrowserListViewDisclosureColumn", (PyCFunction)CtlObj_SetDataBrowserListViewDisclosureColumn, 1, |
| PyDoc_STR("(UInt32 column, Boolean expandableRows) -> None")}, |
| {"GetDataBrowserListViewDisclosureColumn", (PyCFunction)CtlObj_GetDataBrowserListViewDisclosureColumn, 1, |
| PyDoc_STR("() -> (UInt32 column, Boolean expandableRows)")}, |
| {"GetDataBrowserColumnViewPath", (PyCFunction)CtlObj_GetDataBrowserColumnViewPath, 1, |
| PyDoc_STR("(Handle path) -> None")}, |
| {"GetDataBrowserColumnViewPathLength", (PyCFunction)CtlObj_GetDataBrowserColumnViewPathLength, 1, |
| PyDoc_STR("() -> (UInt32 pathLength)")}, |
| {"SetDataBrowserColumnViewDisplayType", (PyCFunction)CtlObj_SetDataBrowserColumnViewDisplayType, 1, |
| PyDoc_STR("(OSType propertyType) -> None")}, |
| {"GetDataBrowserColumnViewDisplayType", (PyCFunction)CtlObj_GetDataBrowserColumnViewDisplayType, 1, |
| PyDoc_STR("() -> (OSType propertyType)")}, |
| {"as_Resource", (PyCFunction)CtlObj_as_Resource, 1, |
| PyDoc_STR("() -> (Handle _rv)")}, |
| {"GetControlRect", (PyCFunction)CtlObj_GetControlRect, 1, |
| PyDoc_STR("() -> (Rect rect)")}, |
| {"DisposeControl", (PyCFunction)CtlObj_DisposeControl, 1, |
| PyDoc_STR("() -> None")}, |
| {"TrackControl", (PyCFunction)CtlObj_TrackControl, 1, |
| PyDoc_STR("(Point startPoint [,trackercallback]) -> (ControlPartCode _rv)")}, |
| {"HandleControlClick", (PyCFunction)CtlObj_HandleControlClick, 1, |
| PyDoc_STR("(Point startPoint, Integer modifiers, [,trackercallback]) -> (ControlPartCode _rv)")}, |
| {"SetControlData", (PyCFunction)CtlObj_SetControlData, 1, |
| PyDoc_STR("(stuff) -> None")}, |
| {"GetControlData", (PyCFunction)CtlObj_GetControlData, 1, |
| PyDoc_STR("(part, type) -> String")}, |
| {"SetControlData_Handle", (PyCFunction)CtlObj_SetControlData_Handle, 1, |
| PyDoc_STR("(ResObj) -> None")}, |
| {"GetControlData_Handle", (PyCFunction)CtlObj_GetControlData_Handle, 1, |
| PyDoc_STR("(part, type) -> ResObj")}, |
| {"SetControlData_Callback", (PyCFunction)CtlObj_SetControlData_Callback, 1, |
| PyDoc_STR("(callbackfunc) -> None")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define CtlObj_getsetlist NULL |
| |
| |
| static int CtlObj_compare(ControlObject *self, ControlObject *other) |
| { |
| unsigned long v, w; |
| |
| if (!CtlObj_Check((PyObject *)other)) |
| { |
| v=(unsigned long)self; |
| w=(unsigned long)other; |
| } |
| else |
| { |
| v=(unsigned long)self->ob_itself; |
| w=(unsigned long)other->ob_itself; |
| } |
| if( v < w ) return -1; |
| if( v > w ) return 1; |
| return 0; |
| } |
| |
| #define CtlObj_repr NULL |
| |
| static long CtlObj_hash(ControlObject *self) |
| { |
| return (long)self->ob_itself; |
| } |
| #define CtlObj_tp_init 0 |
| |
| #define CtlObj_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *CtlObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) |
| { |
| PyObject *_self; |
| ControlHandle itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CtlObj_Convert, &itself)) return NULL; |
| if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((ControlObject *)_self)->ob_itself = itself; |
| return _self; |
| } |
| |
| #define CtlObj_tp_free PyObject_Del |
| |
| |
| PyTypeObject Control_Type = { |
| PyVarObject_HEAD_INIT(NULL, 0) |
| "_Ctl.Control", /*tp_name*/ |
| sizeof(ControlObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) CtlObj_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*tp_setattr*/ |
| (cmpfunc) CtlObj_compare, /*tp_compare*/ |
| (reprfunc) CtlObj_repr, /*tp_repr*/ |
| (PyNumberMethods *)0, /* tp_as_number */ |
| (PySequenceMethods *)0, /* tp_as_sequence */ |
| (PyMappingMethods *)0, /* tp_as_mapping */ |
| (hashfunc) CtlObj_hash, /*tp_hash*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| CtlObj_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| CtlObj_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| CtlObj_tp_init, /* tp_init */ |
| CtlObj_tp_alloc, /* tp_alloc */ |
| CtlObj_tp_new, /* tp_new */ |
| CtlObj_tp_free, /* tp_free */ |
| }; |
| |
| /* -------------------- End object type Control --------------------- */ |
| |
| |
| static PyObject *Ctl_NewControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ControlHandle _rv; |
| WindowPtr owningWindow; |
| Rect boundsRect; |
| Str255 controlTitle; |
| Boolean initiallyVisible; |
| SInt16 initialValue; |
| SInt16 minimumValue; |
| SInt16 maximumValue; |
| SInt16 procID; |
| SInt32 controlReference; |
| #ifndef NewControl |
| PyMac_PRECHECK(NewControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&bhhhhl", |
| WinObj_Convert, &owningWindow, |
| PyMac_GetRect, &boundsRect, |
| PyMac_GetStr255, controlTitle, |
| &initiallyVisible, |
| &initialValue, |
| &minimumValue, |
| &maximumValue, |
| &procID, |
| &controlReference)) |
| return NULL; |
| _rv = NewControl(owningWindow, |
| &boundsRect, |
| controlTitle, |
| initiallyVisible, |
| initialValue, |
| minimumValue, |
| maximumValue, |
| procID, |
| controlReference); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Ctl_GetNewControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ControlHandle _rv; |
| SInt16 resourceID; |
| WindowPtr owningWindow; |
| #ifndef GetNewControl |
| PyMac_PRECHECK(GetNewControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hO&", |
| &resourceID, |
| WinObj_Convert, &owningWindow)) |
| return NULL; |
| _rv = GetNewControl(resourceID, |
| owningWindow); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Ctl_DrawControls(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| WindowPtr theWindow; |
| #ifndef DrawControls |
| PyMac_PRECHECK(DrawControls); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &theWindow)) |
| return NULL; |
| DrawControls(theWindow); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Ctl_UpdateControls(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| WindowPtr inWindow; |
| RgnHandle inUpdateRegion; |
| #ifndef UpdateControls |
| PyMac_PRECHECK(UpdateControls); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| WinObj_Convert, &inWindow, |
| ResObj_Convert, &inUpdateRegion)) |
| return NULL; |
| UpdateControls(inWindow, |
| inUpdateRegion); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Ctl_FindControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ControlPartCode _rv; |
| Point testPoint; |
| WindowPtr theWindow; |
| ControlHandle theControl; |
| #ifndef FindControl |
| PyMac_PRECHECK(FindControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| PyMac_GetPoint, &testPoint, |
| WinObj_Convert, &theWindow)) |
| return NULL; |
| _rv = FindControl(testPoint, |
| theWindow, |
| &theControl); |
| _res = Py_BuildValue("hO&", |
| _rv, |
| CtlObj_WhichControl, theControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_IdleControls(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| WindowPtr inWindow; |
| #ifndef IdleControls |
| PyMac_PRECHECK(IdleControls); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &inWindow)) |
| return NULL; |
| IdleControls(inWindow); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Ctl_GetControlByID(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr inWindow; |
| ControlID inID; |
| ControlHandle outControl; |
| #ifndef GetControlByID |
| PyMac_PRECHECK(GetControlByID); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| WinObj_Convert, &inWindow, |
| PyControlID_Convert, &inID)) |
| return NULL; |
| _err = GetControlByID(inWindow, |
| &inID, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_WhichControl, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_DumpControlHierarchy(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| WindowPtr inWindow; |
| FSSpec inDumpFile; |
| #ifndef DumpControlHierarchy |
| PyMac_PRECHECK(DumpControlHierarchy); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| WinObj_Convert, &inWindow, |
| PyMac_GetFSSpec, &inDumpFile)) |
| return NULL; |
| _err = DumpControlHierarchy(inWindow, |
| &inDumpFile); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateRootControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| WindowPtr inWindow; |
| ControlHandle outControl; |
| #ifndef CreateRootControl |
| PyMac_PRECHECK(CreateRootControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &inWindow)) |
| return NULL; |
| _err = CreateRootControl(inWindow, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_GetRootControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| WindowPtr inWindow; |
| ControlHandle outControl; |
| #ifndef GetRootControl |
| PyMac_PRECHECK(GetRootControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &inWindow)) |
| return NULL; |
| _err = GetRootControl(inWindow, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_WhichControl, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_GetKeyboardFocus(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| WindowPtr inWindow; |
| ControlHandle outControl; |
| #ifndef GetKeyboardFocus |
| PyMac_PRECHECK(GetKeyboardFocus); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &inWindow)) |
| return NULL; |
| _err = GetKeyboardFocus(inWindow, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_WhichControl, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_SetKeyboardFocus(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| WindowPtr inWindow; |
| ControlHandle inControl; |
| ControlFocusPart inPart; |
| #ifndef SetKeyboardFocus |
| PyMac_PRECHECK(SetKeyboardFocus); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&h", |
| WinObj_Convert, &inWindow, |
| CtlObj_Convert, &inControl, |
| &inPart)) |
| return NULL; |
| _err = SetKeyboardFocus(inWindow, |
| inControl, |
| inPart); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Ctl_AdvanceKeyboardFocus(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| WindowPtr inWindow; |
| #ifndef AdvanceKeyboardFocus |
| PyMac_PRECHECK(AdvanceKeyboardFocus); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &inWindow)) |
| return NULL; |
| _err = AdvanceKeyboardFocus(inWindow); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Ctl_ReverseKeyboardFocus(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| WindowPtr inWindow; |
| #ifndef ReverseKeyboardFocus |
| PyMac_PRECHECK(ReverseKeyboardFocus); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &inWindow)) |
| return NULL; |
| _err = ReverseKeyboardFocus(inWindow); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Ctl_ClearKeyboardFocus(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| WindowPtr inWindow; |
| #ifndef ClearKeyboardFocus |
| PyMac_PRECHECK(ClearKeyboardFocus); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &inWindow)) |
| return NULL; |
| _err = ClearKeyboardFocus(inWindow); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Ctl_SetAutomaticControlDragTrackingEnabledForWindow(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr inWindow; |
| Boolean inTracks; |
| #ifndef SetAutomaticControlDragTrackingEnabledForWindow |
| PyMac_PRECHECK(SetAutomaticControlDragTrackingEnabledForWindow); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&b", |
| WinObj_Convert, &inWindow, |
| &inTracks)) |
| return NULL; |
| _err = SetAutomaticControlDragTrackingEnabledForWindow(inWindow, |
| inTracks); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Ctl_IsAutomaticControlDragTrackingEnabledForWindow(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr inWindow; |
| Boolean outTracks; |
| #ifndef IsAutomaticControlDragTrackingEnabledForWindow |
| PyMac_PRECHECK(IsAutomaticControlDragTrackingEnabledForWindow); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &inWindow)) |
| return NULL; |
| _err = IsAutomaticControlDragTrackingEnabledForWindow(inWindow, |
| &outTracks); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("b", |
| outTracks); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateBevelButtonControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| CFStringRef title; |
| UInt16 thickness; |
| UInt16 behavior; |
| ControlButtonContentInfo info; |
| SInt16 menuID; |
| UInt16 menuBehavior; |
| UInt16 menuPlacement; |
| ControlHandle outControl; |
| #ifndef CreateBevelButtonControl |
| PyMac_PRECHECK(CreateBevelButtonControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&HHO&hHH", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| CFStringRefObj_Convert, &title, |
| &thickness, |
| &behavior, |
| ControlButtonContentInfo_Convert, &info, |
| &menuID, |
| &menuBehavior, |
| &menuPlacement)) |
| return NULL; |
| _err = CreateBevelButtonControl(window, |
| &boundsRect, |
| title, |
| thickness, |
| behavior, |
| &info, |
| menuID, |
| menuBehavior, |
| menuPlacement, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateSliderControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| SInt32 value; |
| SInt32 minimum; |
| SInt32 maximum; |
| UInt16 orientation; |
| UInt16 numTickMarks; |
| Boolean liveTracking; |
| PyObject* liveTrackingProc; |
| UniversalProcPtr c_callback; |
| ControlHandle outControl; |
| #ifndef CreateSliderControl |
| PyMac_PRECHECK(CreateSliderControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&lllHHbO", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| &value, |
| &minimum, |
| &maximum, |
| &orientation, |
| &numTickMarks, |
| &liveTracking, |
| &liveTrackingProc)) |
| return NULL; |
| _err = CreateSliderControl(window, |
| &boundsRect, |
| value, |
| minimum, |
| maximum, |
| orientation, |
| numTickMarks, |
| liveTracking, |
| myactionproc_upp, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| setcallback(_res, kMyControlActionProcTag, liveTrackingProc, &c_callback); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateDisclosureTriangleControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr inWindow; |
| Rect inBoundsRect; |
| UInt16 inOrientation; |
| CFStringRef inTitle; |
| SInt32 inInitialValue; |
| Boolean inDrawTitle; |
| Boolean inAutoToggles; |
| ControlHandle outControl; |
| #ifndef CreateDisclosureTriangleControl |
| PyMac_PRECHECK(CreateDisclosureTriangleControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&HO&lbb", |
| WinObj_Convert, &inWindow, |
| PyMac_GetRect, &inBoundsRect, |
| &inOrientation, |
| CFStringRefObj_Convert, &inTitle, |
| &inInitialValue, |
| &inDrawTitle, |
| &inAutoToggles)) |
| return NULL; |
| _err = CreateDisclosureTriangleControl(inWindow, |
| &inBoundsRect, |
| inOrientation, |
| inTitle, |
| inInitialValue, |
| inDrawTitle, |
| inAutoToggles, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateProgressBarControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| SInt32 value; |
| SInt32 minimum; |
| SInt32 maximum; |
| Boolean indeterminate; |
| ControlHandle outControl; |
| #ifndef CreateProgressBarControl |
| PyMac_PRECHECK(CreateProgressBarControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&lllb", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| &value, |
| &minimum, |
| &maximum, |
| &indeterminate)) |
| return NULL; |
| _err = CreateProgressBarControl(window, |
| &boundsRect, |
| value, |
| minimum, |
| maximum, |
| indeterminate, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateRelevanceBarControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| SInt32 value; |
| SInt32 minimum; |
| SInt32 maximum; |
| ControlHandle outControl; |
| #ifndef CreateRelevanceBarControl |
| PyMac_PRECHECK(CreateRelevanceBarControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&lll", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| &value, |
| &minimum, |
| &maximum)) |
| return NULL; |
| _err = CreateRelevanceBarControl(window, |
| &boundsRect, |
| value, |
| minimum, |
| maximum, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateLittleArrowsControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| SInt32 value; |
| SInt32 minimum; |
| SInt32 maximum; |
| SInt32 increment; |
| ControlHandle outControl; |
| #ifndef CreateLittleArrowsControl |
| PyMac_PRECHECK(CreateLittleArrowsControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&llll", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| &value, |
| &minimum, |
| &maximum, |
| &increment)) |
| return NULL; |
| _err = CreateLittleArrowsControl(window, |
| &boundsRect, |
| value, |
| minimum, |
| maximum, |
| increment, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateChasingArrowsControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| ControlHandle outControl; |
| #ifndef CreateChasingArrowsControl |
| PyMac_PRECHECK(CreateChasingArrowsControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect)) |
| return NULL; |
| _err = CreateChasingArrowsControl(window, |
| &boundsRect, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateSeparatorControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| ControlHandle outControl; |
| #ifndef CreateSeparatorControl |
| PyMac_PRECHECK(CreateSeparatorControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect)) |
| return NULL; |
| _err = CreateSeparatorControl(window, |
| &boundsRect, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateGroupBoxControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| CFStringRef title; |
| Boolean primary; |
| ControlHandle outControl; |
| #ifndef CreateGroupBoxControl |
| PyMac_PRECHECK(CreateGroupBoxControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&b", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| CFStringRefObj_Convert, &title, |
| &primary)) |
| return NULL; |
| _err = CreateGroupBoxControl(window, |
| &boundsRect, |
| title, |
| primary, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateCheckGroupBoxControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| CFStringRef title; |
| SInt32 initialValue; |
| Boolean primary; |
| Boolean autoToggle; |
| ControlHandle outControl; |
| #ifndef CreateCheckGroupBoxControl |
| PyMac_PRECHECK(CreateCheckGroupBoxControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&lbb", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| CFStringRefObj_Convert, &title, |
| &initialValue, |
| &primary, |
| &autoToggle)) |
| return NULL; |
| _err = CreateCheckGroupBoxControl(window, |
| &boundsRect, |
| title, |
| initialValue, |
| primary, |
| autoToggle, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreatePopupGroupBoxControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| CFStringRef title; |
| Boolean primary; |
| SInt16 menuID; |
| Boolean variableWidth; |
| SInt16 titleWidth; |
| SInt16 titleJustification; |
| Style titleStyle; |
| ControlHandle outControl; |
| #ifndef CreatePopupGroupBoxControl |
| PyMac_PRECHECK(CreatePopupGroupBoxControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&bhbhhb", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| CFStringRefObj_Convert, &title, |
| &primary, |
| &menuID, |
| &variableWidth, |
| &titleWidth, |
| &titleJustification, |
| &titleStyle)) |
| return NULL; |
| _err = CreatePopupGroupBoxControl(window, |
| &boundsRect, |
| title, |
| primary, |
| menuID, |
| variableWidth, |
| titleWidth, |
| titleJustification, |
| titleStyle, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateImageWellControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| ControlButtonContentInfo info; |
| ControlHandle outControl; |
| #ifndef CreateImageWellControl |
| PyMac_PRECHECK(CreateImageWellControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| ControlButtonContentInfo_Convert, &info)) |
| return NULL; |
| _err = CreateImageWellControl(window, |
| &boundsRect, |
| &info, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreatePopupArrowControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| UInt16 orientation; |
| UInt16 size; |
| ControlHandle outControl; |
| #ifndef CreatePopupArrowControl |
| PyMac_PRECHECK(CreatePopupArrowControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&HH", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| &orientation, |
| &size)) |
| return NULL; |
| _err = CreatePopupArrowControl(window, |
| &boundsRect, |
| orientation, |
| size, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreatePlacardControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| ControlHandle outControl; |
| #ifndef CreatePlacardControl |
| PyMac_PRECHECK(CreatePlacardControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect)) |
| return NULL; |
| _err = CreatePlacardControl(window, |
| &boundsRect, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateClockControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| UInt16 clockType; |
| UInt32 clockFlags; |
| ControlHandle outControl; |
| #ifndef CreateClockControl |
| PyMac_PRECHECK(CreateClockControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&Hl", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| &clockType, |
| &clockFlags)) |
| return NULL; |
| _err = CreateClockControl(window, |
| &boundsRect, |
| clockType, |
| clockFlags, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateUserPaneControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| UInt32 features; |
| ControlHandle outControl; |
| #ifndef CreateUserPaneControl |
| PyMac_PRECHECK(CreateUserPaneControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&l", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| &features)) |
| return NULL; |
| _err = CreateUserPaneControl(window, |
| &boundsRect, |
| features, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateEditTextControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| CFStringRef text; |
| Boolean isPassword; |
| Boolean useInlineInput; |
| ControlFontStyleRec style; |
| ControlHandle outControl; |
| #ifndef CreateEditTextControl |
| PyMac_PRECHECK(CreateEditTextControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&bbO&", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| CFStringRefObj_Convert, &text, |
| &isPassword, |
| &useInlineInput, |
| ControlFontStyle_Convert, &style)) |
| return NULL; |
| _err = CreateEditTextControl(window, |
| &boundsRect, |
| text, |
| isPassword, |
| useInlineInput, |
| &style, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateStaticTextControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| CFStringRef text; |
| ControlFontStyleRec style; |
| ControlHandle outControl; |
| #ifndef CreateStaticTextControl |
| PyMac_PRECHECK(CreateStaticTextControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&O&", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| CFStringRefObj_Convert, &text, |
| ControlFontStyle_Convert, &style)) |
| return NULL; |
| _err = CreateStaticTextControl(window, |
| &boundsRect, |
| text, |
| &style, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreatePictureControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| ControlButtonContentInfo content; |
| Boolean dontTrack; |
| ControlHandle outControl; |
| #ifndef CreatePictureControl |
| PyMac_PRECHECK(CreatePictureControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&b", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| ControlButtonContentInfo_Convert, &content, |
| &dontTrack)) |
| return NULL; |
| _err = CreatePictureControl(window, |
| &boundsRect, |
| &content, |
| dontTrack, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateIconControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr inWindow; |
| Rect inBoundsRect; |
| ControlButtonContentInfo inIconContent; |
| Boolean inDontTrack; |
| ControlHandle outControl; |
| #ifndef CreateIconControl |
| PyMac_PRECHECK(CreateIconControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&b", |
| WinObj_Convert, &inWindow, |
| PyMac_GetRect, &inBoundsRect, |
| ControlButtonContentInfo_Convert, &inIconContent, |
| &inDontTrack)) |
| return NULL; |
| _err = CreateIconControl(inWindow, |
| &inBoundsRect, |
| &inIconContent, |
| inDontTrack, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateWindowHeaderControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| Boolean isListHeader; |
| ControlHandle outControl; |
| #ifndef CreateWindowHeaderControl |
| PyMac_PRECHECK(CreateWindowHeaderControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&b", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| &isListHeader)) |
| return NULL; |
| _err = CreateWindowHeaderControl(window, |
| &boundsRect, |
| isListHeader, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreatePushButtonControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| CFStringRef title; |
| ControlHandle outControl; |
| #ifndef CreatePushButtonControl |
| PyMac_PRECHECK(CreatePushButtonControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| CFStringRefObj_Convert, &title)) |
| return NULL; |
| _err = CreatePushButtonControl(window, |
| &boundsRect, |
| title, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreatePushButtonWithIconControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| CFStringRef title; |
| ControlButtonContentInfo icon; |
| UInt16 iconAlignment; |
| ControlHandle outControl; |
| #ifndef CreatePushButtonWithIconControl |
| PyMac_PRECHECK(CreatePushButtonWithIconControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&O&H", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| CFStringRefObj_Convert, &title, |
| ControlButtonContentInfo_Convert, &icon, |
| &iconAlignment)) |
| return NULL; |
| _err = CreatePushButtonWithIconControl(window, |
| &boundsRect, |
| title, |
| &icon, |
| iconAlignment, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateRadioButtonControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| CFStringRef title; |
| SInt32 initialValue; |
| Boolean autoToggle; |
| ControlHandle outControl; |
| #ifndef CreateRadioButtonControl |
| PyMac_PRECHECK(CreateRadioButtonControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&lb", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| CFStringRefObj_Convert, &title, |
| &initialValue, |
| &autoToggle)) |
| return NULL; |
| _err = CreateRadioButtonControl(window, |
| &boundsRect, |
| title, |
| initialValue, |
| autoToggle, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateCheckBoxControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| CFStringRef title; |
| SInt32 initialValue; |
| Boolean autoToggle; |
| ControlHandle outControl; |
| #ifndef CreateCheckBoxControl |
| PyMac_PRECHECK(CreateCheckBoxControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&lb", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| CFStringRefObj_Convert, &title, |
| &initialValue, |
| &autoToggle)) |
| return NULL; |
| _err = CreateCheckBoxControl(window, |
| &boundsRect, |
| title, |
| initialValue, |
| autoToggle, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateScrollBarControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| SInt32 value; |
| SInt32 minimum; |
| SInt32 maximum; |
| SInt32 viewSize; |
| Boolean liveTracking; |
| PyObject* liveTrackingProc; |
| UniversalProcPtr c_callback; |
| ControlHandle outControl; |
| #ifndef CreateScrollBarControl |
| PyMac_PRECHECK(CreateScrollBarControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&llllbO", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| &value, |
| &minimum, |
| &maximum, |
| &viewSize, |
| &liveTracking, |
| &liveTrackingProc)) |
| return NULL; |
| _err = CreateScrollBarControl(window, |
| &boundsRect, |
| value, |
| minimum, |
| maximum, |
| viewSize, |
| liveTracking, |
| myactionproc_upp, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| setcallback(_res, kMyControlActionProcTag, liveTrackingProc, &c_callback); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreatePopupButtonControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| CFStringRef title; |
| SInt16 menuID; |
| Boolean variableWidth; |
| SInt16 titleWidth; |
| SInt16 titleJustification; |
| Style titleStyle; |
| ControlHandle outControl; |
| #ifndef CreatePopupButtonControl |
| PyMac_PRECHECK(CreatePopupButtonControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&hbhhb", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| CFStringRefObj_Convert, &title, |
| &menuID, |
| &variableWidth, |
| &titleWidth, |
| &titleJustification, |
| &titleStyle)) |
| return NULL; |
| _err = CreatePopupButtonControl(window, |
| &boundsRect, |
| title, |
| menuID, |
| variableWidth, |
| titleWidth, |
| titleJustification, |
| titleStyle, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateRadioGroupControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| ControlHandle outControl; |
| #ifndef CreateRadioGroupControl |
| PyMac_PRECHECK(CreateRadioGroupControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect)) |
| return NULL; |
| _err = CreateRadioGroupControl(window, |
| &boundsRect, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateScrollingTextBoxControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| SInt16 contentResID; |
| Boolean autoScroll; |
| UInt32 delayBeforeAutoScroll; |
| UInt32 delayBetweenAutoScroll; |
| UInt16 autoScrollAmount; |
| ControlHandle outControl; |
| #ifndef CreateScrollingTextBoxControl |
| PyMac_PRECHECK(CreateScrollingTextBoxControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&hbllH", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| &contentResID, |
| &autoScroll, |
| &delayBeforeAutoScroll, |
| &delayBetweenAutoScroll, |
| &autoScrollAmount)) |
| return NULL; |
| _err = CreateScrollingTextBoxControl(window, |
| &boundsRect, |
| contentResID, |
| autoScroll, |
| delayBeforeAutoScroll, |
| delayBetweenAutoScroll, |
| autoScrollAmount, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateDisclosureButtonControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr inWindow; |
| Rect inBoundsRect; |
| SInt32 inValue; |
| Boolean inAutoToggles; |
| ControlHandle outControl; |
| #ifndef CreateDisclosureButtonControl |
| PyMac_PRECHECK(CreateDisclosureButtonControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&lb", |
| WinObj_Convert, &inWindow, |
| PyMac_GetRect, &inBoundsRect, |
| &inValue, |
| &inAutoToggles)) |
| return NULL; |
| _err = CreateDisclosureButtonControl(inWindow, |
| &inBoundsRect, |
| inValue, |
| inAutoToggles, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateRoundButtonControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr inWindow; |
| Rect inBoundsRect; |
| SInt16 inSize; |
| ControlButtonContentInfo inContent; |
| ControlHandle outControl; |
| #ifndef CreateRoundButtonControl |
| PyMac_PRECHECK(CreateRoundButtonControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&hO&", |
| WinObj_Convert, &inWindow, |
| PyMac_GetRect, &inBoundsRect, |
| &inSize, |
| ControlButtonContentInfo_Convert, &inContent)) |
| return NULL; |
| _err = CreateRoundButtonControl(inWindow, |
| &inBoundsRect, |
| inSize, |
| &inContent, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateDataBrowserControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| OSType style; |
| ControlHandle outControl; |
| #ifndef CreateDataBrowserControl |
| PyMac_PRECHECK(CreateDataBrowserControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| PyMac_GetOSType, &style)) |
| return NULL; |
| _err = CreateDataBrowserControl(window, |
| &boundsRect, |
| style, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateEditUnicodeTextControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| CFStringRef text; |
| Boolean isPassword; |
| ControlFontStyleRec style; |
| ControlHandle outControl; |
| #ifndef CreateEditUnicodeTextControl |
| PyMac_PRECHECK(CreateEditUnicodeTextControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&bO&", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| CFStringRefObj_Convert, &text, |
| &isPassword, |
| ControlFontStyle_Convert, &style)) |
| return NULL; |
| _err = CreateEditUnicodeTextControl(window, |
| &boundsRect, |
| text, |
| isPassword, |
| &style, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *Ctl_FindControlUnderMouse(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ControlHandle _rv; |
| Point inWhere; |
| WindowPtr inWindow; |
| SInt16 outPart; |
| #ifndef FindControlUnderMouse |
| PyMac_PRECHECK(FindControlUnderMouse); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| PyMac_GetPoint, &inWhere, |
| WinObj_Convert, &inWindow)) |
| return NULL; |
| _rv = FindControlUnderMouse(inWhere, |
| inWindow, |
| &outPart); |
| _res = Py_BuildValue("O&h", |
| CtlObj_WhichControl, _rv, |
| outPart); |
| return _res; |
| } |
| |
| static PyObject *Ctl_as_Control(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ControlHandle _rv; |
| Handle h; |
| #ifndef as_Control |
| PyMac_PRECHECK(as_Control); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &h)) |
| return NULL; |
| _rv = as_Control(h); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Ctl_CreateTabsControl(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr window; |
| Rect boundsRect; |
| UInt16 size; |
| UInt16 direction; |
| int i; |
| UInt16 numTabs; |
| ControlTabEntry tabArray[MAXTABS]; |
| ControlHandle outControl; |
| PyObject *tabArrayObj, *tabEntry; |
| |
| #ifndef CreateTabsControl |
| PyMac_PRECHECK(CreateTabsControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&HHO", |
| WinObj_Convert, &window, |
| PyMac_GetRect, &boundsRect, |
| &size, |
| &direction, |
| &tabArrayObj)) |
| return NULL; |
| |
| i = PySequence_Length(tabArrayObj); |
| if (i == -1) |
| return NULL; |
| if (i > MAXTABS) { |
| PyErr_SetString(Ctl_Error, "Too many tabs"); |
| return NULL; |
| } |
| numTabs = i; |
| for (i=0; i<numTabs; i++) { |
| tabEntry = PySequence_GetItem(tabArrayObj, i); |
| if (tabEntry == NULL) |
| return NULL; |
| if (!PyArg_Parse(tabEntry, "(O&O&B)", |
| ControlButtonContentInfo_Convert, &tabArray[i].icon, |
| CFStringRefObj_Convert, &tabArray[i].name, |
| &tabArray[i].enabled |
| )) |
| return NULL; |
| } |
| |
| _err = CreateTabsControl(window, |
| &boundsRect, |
| size, |
| direction, |
| numTabs, |
| tabArray, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyMethodDef Ctl_methods[] = { |
| {"NewControl", (PyCFunction)Ctl_NewControl, 1, |
| PyDoc_STR("(WindowPtr owningWindow, Rect boundsRect, Str255 controlTitle, Boolean initiallyVisible, SInt16 initialValue, SInt16 minimumValue, SInt16 maximumValue, SInt16 procID, SInt32 controlReference) -> (ControlHandle _rv)")}, |
| {"GetNewControl", (PyCFunction)Ctl_GetNewControl, 1, |
| PyDoc_STR("(SInt16 resourceID, WindowPtr owningWindow) -> (ControlHandle _rv)")}, |
| {"DrawControls", (PyCFunction)Ctl_DrawControls, 1, |
| PyDoc_STR("(WindowPtr theWindow) -> None")}, |
| {"UpdateControls", (PyCFunction)Ctl_UpdateControls, 1, |
| PyDoc_STR("(WindowPtr inWindow, RgnHandle inUpdateRegion) -> None")}, |
| {"FindControl", (PyCFunction)Ctl_FindControl, 1, |
| PyDoc_STR("(Point testPoint, WindowPtr theWindow) -> (ControlPartCode _rv, ControlHandle theControl)")}, |
| {"IdleControls", (PyCFunction)Ctl_IdleControls, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> None")}, |
| {"GetControlByID", (PyCFunction)Ctl_GetControlByID, 1, |
| PyDoc_STR("(WindowPtr inWindow, ControlID inID) -> (ControlHandle outControl)")}, |
| {"DumpControlHierarchy", (PyCFunction)Ctl_DumpControlHierarchy, 1, |
| PyDoc_STR("(WindowPtr inWindow, FSSpec inDumpFile) -> None")}, |
| {"CreateRootControl", (PyCFunction)Ctl_CreateRootControl, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")}, |
| {"GetRootControl", (PyCFunction)Ctl_GetRootControl, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")}, |
| {"GetKeyboardFocus", (PyCFunction)Ctl_GetKeyboardFocus, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")}, |
| {"SetKeyboardFocus", (PyCFunction)Ctl_SetKeyboardFocus, 1, |
| PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl, ControlFocusPart inPart) -> None")}, |
| {"AdvanceKeyboardFocus", (PyCFunction)Ctl_AdvanceKeyboardFocus, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> None")}, |
| {"ReverseKeyboardFocus", (PyCFunction)Ctl_ReverseKeyboardFocus, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> None")}, |
| {"ClearKeyboardFocus", (PyCFunction)Ctl_ClearKeyboardFocus, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> None")}, |
| {"SetAutomaticControlDragTrackingEnabledForWindow", (PyCFunction)Ctl_SetAutomaticControlDragTrackingEnabledForWindow, 1, |
| PyDoc_STR("(WindowPtr inWindow, Boolean inTracks) -> None")}, |
| {"IsAutomaticControlDragTrackingEnabledForWindow", (PyCFunction)Ctl_IsAutomaticControlDragTrackingEnabledForWindow, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> (Boolean outTracks)")}, |
| {"CreateBevelButtonControl", (PyCFunction)Ctl_CreateBevelButtonControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, UInt16 thickness, UInt16 behavior, ControlButtonContentInfo info, SInt16 menuID, UInt16 menuBehavior, UInt16 menuPlacement) -> (ControlHandle outControl)")}, |
| {"CreateSliderControl", (PyCFunction)Ctl_CreateSliderControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, UInt16 orientation, UInt16 numTickMarks, Boolean liveTracking, PyObject* liveTrackingProc) -> (ControlHandle outControl)")}, |
| {"CreateDisclosureTriangleControl", (PyCFunction)Ctl_CreateDisclosureTriangleControl, 1, |
| PyDoc_STR("(WindowPtr inWindow, Rect inBoundsRect, UInt16 inOrientation, CFStringRef inTitle, SInt32 inInitialValue, Boolean inDrawTitle, Boolean inAutoToggles) -> (ControlHandle outControl)")}, |
| {"CreateProgressBarControl", (PyCFunction)Ctl_CreateProgressBarControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, Boolean indeterminate) -> (ControlHandle outControl)")}, |
| {"CreateRelevanceBarControl", (PyCFunction)Ctl_CreateRelevanceBarControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum) -> (ControlHandle outControl)")}, |
| {"CreateLittleArrowsControl", (PyCFunction)Ctl_CreateLittleArrowsControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, SInt32 increment) -> (ControlHandle outControl)")}, |
| {"CreateChasingArrowsControl", (PyCFunction)Ctl_CreateChasingArrowsControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)")}, |
| {"CreateSeparatorControl", (PyCFunction)Ctl_CreateSeparatorControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)")}, |
| {"CreateGroupBoxControl", (PyCFunction)Ctl_CreateGroupBoxControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, Boolean primary) -> (ControlHandle outControl)")}, |
| {"CreateCheckGroupBoxControl", (PyCFunction)Ctl_CreateCheckGroupBoxControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, SInt32 initialValue, Boolean primary, Boolean autoToggle) -> (ControlHandle outControl)")}, |
| {"CreatePopupGroupBoxControl", (PyCFunction)Ctl_CreatePopupGroupBoxControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, Boolean primary, SInt16 menuID, Boolean variableWidth, SInt16 titleWidth, SInt16 titleJustification, Style titleStyle) -> (ControlHandle outControl)")}, |
| {"CreateImageWellControl", (PyCFunction)Ctl_CreateImageWellControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, ControlButtonContentInfo info) -> (ControlHandle outControl)")}, |
| {"CreatePopupArrowControl", (PyCFunction)Ctl_CreatePopupArrowControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, UInt16 orientation, UInt16 size) -> (ControlHandle outControl)")}, |
| {"CreatePlacardControl", (PyCFunction)Ctl_CreatePlacardControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)")}, |
| {"CreateClockControl", (PyCFunction)Ctl_CreateClockControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, UInt16 clockType, UInt32 clockFlags) -> (ControlHandle outControl)")}, |
| {"CreateUserPaneControl", (PyCFunction)Ctl_CreateUserPaneControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, UInt32 features) -> (ControlHandle outControl)")}, |
| {"CreateEditTextControl", (PyCFunction)Ctl_CreateEditTextControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef text, Boolean isPassword, Boolean useInlineInput, ControlFontStyleRec style) -> (ControlHandle outControl)")}, |
| {"CreateStaticTextControl", (PyCFunction)Ctl_CreateStaticTextControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef text, ControlFontStyleRec style) -> (ControlHandle outControl)")}, |
| {"CreatePictureControl", (PyCFunction)Ctl_CreatePictureControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, ControlButtonContentInfo content, Boolean dontTrack) -> (ControlHandle outControl)")}, |
| {"CreateIconControl", (PyCFunction)Ctl_CreateIconControl, 1, |
| PyDoc_STR("(WindowPtr inWindow, Rect inBoundsRect, ControlButtonContentInfo inIconContent, Boolean inDontTrack) -> (ControlHandle outControl)")}, |
| {"CreateWindowHeaderControl", (PyCFunction)Ctl_CreateWindowHeaderControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, Boolean isListHeader) -> (ControlHandle outControl)")}, |
| {"CreatePushButtonControl", (PyCFunction)Ctl_CreatePushButtonControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title) -> (ControlHandle outControl)")}, |
| {"CreatePushButtonWithIconControl", (PyCFunction)Ctl_CreatePushButtonWithIconControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, ControlButtonContentInfo icon, UInt16 iconAlignment) -> (ControlHandle outControl)")}, |
| {"CreateRadioButtonControl", (PyCFunction)Ctl_CreateRadioButtonControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, SInt32 initialValue, Boolean autoToggle) -> (ControlHandle outControl)")}, |
| {"CreateCheckBoxControl", (PyCFunction)Ctl_CreateCheckBoxControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, SInt32 initialValue, Boolean autoToggle) -> (ControlHandle outControl)")}, |
| {"CreateScrollBarControl", (PyCFunction)Ctl_CreateScrollBarControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, SInt32 viewSize, Boolean liveTracking, PyObject* liveTrackingProc) -> (ControlHandle outControl)")}, |
| {"CreatePopupButtonControl", (PyCFunction)Ctl_CreatePopupButtonControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, SInt16 menuID, Boolean variableWidth, SInt16 titleWidth, SInt16 titleJustification, Style titleStyle) -> (ControlHandle outControl)")}, |
| {"CreateRadioGroupControl", (PyCFunction)Ctl_CreateRadioGroupControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)")}, |
| {"CreateScrollingTextBoxControl", (PyCFunction)Ctl_CreateScrollingTextBoxControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt16 contentResID, Boolean autoScroll, UInt32 delayBeforeAutoScroll, UInt32 delayBetweenAutoScroll, UInt16 autoScrollAmount) -> (ControlHandle outControl)")}, |
| {"CreateDisclosureButtonControl", (PyCFunction)Ctl_CreateDisclosureButtonControl, 1, |
| PyDoc_STR("(WindowPtr inWindow, Rect inBoundsRect, SInt32 inValue, Boolean inAutoToggles) -> (ControlHandle outControl)")}, |
| {"CreateRoundButtonControl", (PyCFunction)Ctl_CreateRoundButtonControl, 1, |
| PyDoc_STR("(WindowPtr inWindow, Rect inBoundsRect, SInt16 inSize, ControlButtonContentInfo inContent) -> (ControlHandle outControl)")}, |
| {"CreateDataBrowserControl", (PyCFunction)Ctl_CreateDataBrowserControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, OSType style) -> (ControlHandle outControl)")}, |
| {"CreateEditUnicodeTextControl", (PyCFunction)Ctl_CreateEditUnicodeTextControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef text, Boolean isPassword, ControlFontStyleRec style) -> (ControlHandle outControl)")}, |
| {"FindControlUnderMouse", (PyCFunction)Ctl_FindControlUnderMouse, 1, |
| PyDoc_STR("(Point inWhere, WindowPtr inWindow) -> (ControlHandle _rv, SInt16 outPart)")}, |
| {"as_Control", (PyCFunction)Ctl_as_Control, 1, |
| PyDoc_STR("(Handle h) -> (ControlHandle _rv)")}, |
| {"CreateTabsControl", (PyCFunction)Ctl_CreateTabsControl, 1, |
| PyDoc_STR("(WindowPtr window, Rect boundsRect, UInt16 size, UInt16 direction, ControlTabEntry tabArray) -> (ControlHandle outControl)")}, |
| {NULL, NULL, 0} |
| }; |
| |
| |
| |
| static PyObject * |
| CtlObj_NewUnmanaged(ControlHandle itself) |
| { |
| ControlObject *it; |
| if (itself == NULL) return PyMac_Error(resNotFound); |
| it = PyObject_NEW(ControlObject, &Control_Type); |
| if (it == NULL) return NULL; |
| it->ob_itself = itself; |
| it->ob_callbackdict = NULL; |
| return (PyObject *)it; |
| } |
| |
| static PyObject * |
| CtlObj_WhichControl(ControlHandle c) |
| { |
| PyObject *it; |
| |
| if (c == NULL) |
| it = Py_None; |
| else { |
| it = (PyObject *) GetControlReference(c); |
| /* |
| ** If the refcon is zero or doesn't point back to the Python object |
| ** the control is not ours. Return a temporary object. |
| */ |
| if (it == NULL || ((ControlObject *)it)->ob_itself != c) |
| return CtlObj_NewUnmanaged(c); |
| } |
| Py_INCREF(it); |
| return it; |
| } |
| |
| static int |
| settrackfunc(PyObject *obj) |
| { |
| if (tracker) { |
| PyErr_SetString(Ctl_Error, "Tracker function in use"); |
| return 0; |
| } |
| tracker = obj; |
| Py_INCREF(tracker); |
| return 1; |
| } |
| |
| static void |
| clrtrackfunc(void) |
| { |
| Py_XDECREF(tracker); |
| tracker = 0; |
| } |
| |
| static pascal void |
| mytracker(ControlHandle ctl, short part) |
| { |
| PyObject *args, *rv=0; |
| |
| args = Py_BuildValue("(O&i)", CtlObj_WhichControl, ctl, (int)part); |
| if (args && tracker) { |
| rv = PyEval_CallObject(tracker, args); |
| Py_DECREF(args); |
| } |
| if (rv) |
| Py_DECREF(rv); |
| else { |
| PySys_WriteStderr("TrackControl or HandleControlClick: exception in tracker function\n"); |
| PyErr_Print(); |
| } |
| } |
| |
| static int |
| setcallback(PyObject *myself, OSType which, PyObject *callback, UniversalProcPtr *uppp) |
| { |
| ControlObject *self = (ControlObject *)myself; |
| char keybuf[9]; |
| |
| if ( which == kMyControlActionProcTag ) |
| *uppp = (UniversalProcPtr)myactionproc_upp; |
| else if ( which == kControlUserPaneKeyDownProcTag ) |
| *uppp = (UniversalProcPtr)mykeydownproc_upp; |
| else if ( which == kControlUserPaneFocusProcTag ) |
| *uppp = (UniversalProcPtr)myfocusproc_upp; |
| else if ( which == kControlUserPaneDrawProcTag ) |
| *uppp = (UniversalProcPtr)mydrawproc_upp; |
| else if ( which == kControlUserPaneIdleProcTag ) |
| *uppp = (UniversalProcPtr)myidleproc_upp; |
| else if ( which == kControlUserPaneHitTestProcTag ) |
| *uppp = (UniversalProcPtr)myhittestproc_upp; |
| else if ( which == kControlUserPaneTrackingProcTag ) |
| *uppp = (UniversalProcPtr)mytrackingproc_upp; |
| else |
| return -1; |
| /* Only now do we test for clearing of the callback: */ |
| if ( callback == Py_None ) |
| *uppp = NULL; |
| /* Create the dict if it doesn't exist yet (so we don't get such a dict for every control) */ |
| if ( self->ob_callbackdict == NULL ) |
| if ( (self->ob_callbackdict = PyDict_New()) == NULL ) |
| return -1; |
| /* And store the Python callback */ |
| sprintf(keybuf, "%x", (unsigned)which); |
| if (PyDict_SetItemString(self->ob_callbackdict, keybuf, callback) < 0) |
| return -1; |
| return 0; |
| } |
| |
| static PyObject * |
| callcallback(ControlObject *self, OSType which, PyObject *arglist) |
| { |
| char keybuf[9]; |
| PyObject *func, *rv; |
| |
| sprintf(keybuf, "%x", (unsigned)which); |
| if ( self->ob_callbackdict == NULL || |
| (func = PyDict_GetItemString(self->ob_callbackdict, keybuf)) == NULL ) { |
| PySys_WriteStderr("Control callback %x without callback object\n", (unsigned)which); |
| return NULL; |
| } |
| rv = PyEval_CallObject(func, arglist); |
| if ( rv == NULL ) { |
| PySys_WriteStderr("Exception in control callback %x handler\n", (unsigned)which); |
| PyErr_Print(); |
| } |
| return rv; |
| } |
| |
| static pascal void |
| myactionproc(ControlHandle control, SInt16 part) |
| { |
| ControlObject *ctl_obj; |
| PyObject *arglist, *rv; |
| |
| ctl_obj = (ControlObject *)CtlObj_WhichControl(control); |
| arglist = Py_BuildValue("Oh", ctl_obj, part); |
| rv = callcallback(ctl_obj, kMyControlActionProcTag, arglist); |
| Py_XDECREF(arglist); |
| Py_XDECREF(rv); |
| } |
| |
| static pascal ControlPartCode |
| mykeydownproc(ControlHandle control, SInt16 keyCode, SInt16 charCode, SInt16 modifiers) |
| { |
| ControlObject *ctl_obj; |
| PyObject *arglist, *rv; |
| short c_rv = 0; |
| |
| ctl_obj = (ControlObject *)CtlObj_WhichControl(control); |
| arglist = Py_BuildValue("Ohhh", ctl_obj, keyCode, charCode, modifiers); |
| rv = callcallback(ctl_obj, kControlUserPaneKeyDownProcTag, arglist); |
| Py_XDECREF(arglist); |
| if ( rv ) |
| if (!PyArg_Parse(rv, "h", &c_rv)) |
| PyErr_Clear(); |
| Py_XDECREF(rv); |
| return (ControlPartCode)c_rv; |
| } |
| |
| static pascal ControlPartCode |
| myfocusproc(ControlHandle control, ControlPartCode part) |
| { |
| ControlObject *ctl_obj; |
| PyObject *arglist, *rv; |
| short c_rv = kControlFocusNoPart; |
| |
| ctl_obj = (ControlObject *)CtlObj_WhichControl(control); |
| arglist = Py_BuildValue("Oh", ctl_obj, part); |
| rv = callcallback(ctl_obj, kControlUserPaneFocusProcTag, arglist); |
| Py_XDECREF(arglist); |
| if ( rv ) |
| if (!PyArg_Parse(rv, "h", &c_rv)) |
| PyErr_Clear(); |
| Py_XDECREF(rv); |
| return (ControlPartCode)c_rv; |
| } |
| |
| static pascal void |
| mydrawproc(ControlHandle control, SInt16 part) |
| { |
| ControlObject *ctl_obj; |
| PyObject *arglist, *rv; |
| |
| ctl_obj = (ControlObject *)CtlObj_WhichControl(control); |
| arglist = Py_BuildValue("Oh", ctl_obj, part); |
| rv = callcallback(ctl_obj, kControlUserPaneDrawProcTag, arglist); |
| Py_XDECREF(arglist); |
| Py_XDECREF(rv); |
| } |
| |
| static pascal void |
| myidleproc(ControlHandle control) |
| { |
| ControlObject *ctl_obj; |
| PyObject *arglist, *rv; |
| |
| ctl_obj = (ControlObject *)CtlObj_WhichControl(control); |
| arglist = Py_BuildValue("O", ctl_obj); |
| rv = callcallback(ctl_obj, kControlUserPaneIdleProcTag, arglist); |
| Py_XDECREF(arglist); |
| Py_XDECREF(rv); |
| } |
| |
| static pascal ControlPartCode |
| myhittestproc(ControlHandle control, Point where) |
| { |
| ControlObject *ctl_obj; |
| PyObject *arglist, *rv; |
| short c_rv = -1; |
| |
| ctl_obj = (ControlObject *)CtlObj_WhichControl(control); |
| arglist = Py_BuildValue("OO&", ctl_obj, PyMac_BuildPoint, where); |
| rv = callcallback(ctl_obj, kControlUserPaneHitTestProcTag, arglist); |
| Py_XDECREF(arglist); |
| /* Ignore errors, nothing we can do about them */ |
| if ( rv ) |
| if (!PyArg_Parse(rv, "h", &c_rv)) |
| PyErr_Clear(); |
| Py_XDECREF(rv); |
| return (ControlPartCode)c_rv; |
| } |
| |
| static pascal ControlPartCode |
| mytrackingproc(ControlHandle control, Point startPt, ControlActionUPP actionProc) |
| { |
| ControlObject *ctl_obj; |
| PyObject *arglist, *rv; |
| short c_rv = -1; |
| |
| ctl_obj = (ControlObject *)CtlObj_WhichControl(control); |
| /* We cannot pass the actionProc without lots of work */ |
| arglist = Py_BuildValue("OO&", ctl_obj, PyMac_BuildPoint, startPt); |
| rv = callcallback(ctl_obj, kControlUserPaneTrackingProcTag, arglist); |
| Py_XDECREF(arglist); |
| if ( rv ) |
| if (!PyArg_Parse(rv, "h", &c_rv)) |
| PyErr_Clear(); |
| Py_XDECREF(rv); |
| return (ControlPartCode)c_rv; |
| } |
| |
| |
| void init_Ctl(void) |
| { |
| PyObject *m; |
| PyObject *d; |
| |
| |
| |
| mytracker_upp = NewControlActionUPP(mytracker); |
| myactionproc_upp = NewControlActionUPP(myactionproc); |
| mykeydownproc_upp = NewControlUserPaneKeyDownUPP(mykeydownproc); |
| myfocusproc_upp = NewControlUserPaneFocusUPP(myfocusproc); |
| mydrawproc_upp = NewControlUserPaneDrawUPP(mydrawproc); |
| myidleproc_upp = NewControlUserPaneIdleUPP(myidleproc); |
| myhittestproc_upp = NewControlUserPaneHitTestUPP(myhittestproc); |
| mytrackingproc_upp = NewControlUserPaneTrackingUPP(mytrackingproc); |
| PyMac_INIT_TOOLBOX_OBJECT_NEW(ControlHandle, CtlObj_New); |
| PyMac_INIT_TOOLBOX_OBJECT_CONVERT(ControlHandle, CtlObj_Convert); |
| |
| |
| m = Py_InitModule("_Ctl", Ctl_methods); |
| d = PyModule_GetDict(m); |
| Ctl_Error = PyMac_GetOSErrException(); |
| if (Ctl_Error == NULL || |
| PyDict_SetItemString(d, "Error", Ctl_Error) != 0) |
| return; |
| Py_Type(&Control_Type) = &PyType_Type; |
| if (PyType_Ready(&Control_Type) < 0) return; |
| Py_INCREF(&Control_Type); |
| PyModule_AddObject(m, "Control", (PyObject *)&Control_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&Control_Type); |
| PyModule_AddObject(m, "ControlType", (PyObject *)&Control_Type); |
| } |
| |
| /* ======================== End module _Ctl ========================= */ |
| |