/* ========================== Module _Ctl =========================== */ #include "Python.h" #include "macglue.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) #ifdef WITHOUT_FRAMEWORKS #include #include #else #include #endif #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 staticforward PyObject *CtlObj_WhichControl(ControlHandle); #define as_Control(h) ((ControlHandle)h) #define as_Resource(ctl) ((Handle)ctl) #if TARGET_API_MAC_CARBON #define GetControlRect(ctl, rectp) GetControlBounds(ctl, rectp) #else #define GetControlRect(ctl, rectp) (*(rectp) = ((*(ctl))->contrlRect)) #endif /* ** 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_ParseTuple(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_ParseTuple(v, "O&l", PyMac_GetOSType, &itself->signature, &itself->id); } /* TrackControl and HandleControlClick callback support */ static PyObject *tracker; static ControlActionUPP mytracker_upp; static ControlUserPaneDrawUPP mydrawproc_upp; static ControlUserPaneIdleUPP myidleproc_upp; static ControlUserPaneHitTestUPP myhittestproc_upp; static ControlUserPaneTrackingUPP mytrackingproc_upp; staticforward int settrackfunc(PyObject *); /* forward */ staticforward void clrtrackfunc(void); /* forward */ staticforward int setcallback(PyObject *, OSType, PyObject *, UniversalProcPtr *); static PyObject *Ctl_Error; /* ---------------------- Object type Control ----------------------- */ PyTypeObject Control_Type; #define CtlObj_Check(x) ((x)->ob_type == &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 */ PyMem_DEL(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_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; } #if TARGET_API_MAC_CARBON 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; } #endif #if TARGET_API_MAC_CARBON 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; } #endif static PyObject *CtlObj_HandleControlKey(ControlObject *_self, PyObject *_args) { PyObject *_res = NULL; SInt16 _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; } #if TARGET_API_MAC_CARBON 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; } #endif 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_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; } #if TARGET_API_MAC_CARBON 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; } #endif #if TARGET_API_MAC_CARBON 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; } #endif 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; } #if TARGET_API_MAC_CARBON 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; } #endif #if TARGET_API_MAC_CARBON 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; } #endif 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_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; } #if !TARGET_API_MAC_CARBON static PyObject *CtlObj_GetAuxiliaryControlRecord(ControlObject *_self, PyObject *_args) { PyObject *_res = NULL; Boolean _rv; AuxCtlHandle acHndl; #ifndef GetAuxiliaryControlRecord PyMac_PRECHECK(GetAuxiliaryControlRecord); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetAuxiliaryControlRecord(_self->ob_itself, &acHndl); _res = Py_BuildValue("bO&", _rv, ResObj_New, acHndl); return _res; } #endif #if !TARGET_API_MAC_CARBON static PyObject *CtlObj_SetControlColor(ControlObject *_self, PyObject *_args) { PyObject *_res = NULL; CCTabHandle newColorTable; #ifndef SetControlColor PyMac_PRECHECK(SetControlColor); #endif if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &newColorTable)) return NULL; SetControlColor(_self->ob_itself, newColorTable); Py_INCREF(Py_None); _res = Py_None; return _res; } #endif 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; } #if TARGET_API_MAC_CARBON 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; } #endif #if TARGET_API_MAC_CARBON 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; } #endif #if TARGET_API_MAC_CARBON static PyObject *CtlObj_SetControlDragTrackingEnabled(ControlObject *_self, PyObject *_args) { PyObject *_res = NULL; OSStatus _err; Boolean tracks; #ifndef SetControlDragTrackingEnabled PyMac_PRECHECK(SetControlDragTrackingEnabled); #endif if (!PyArg_ParseTuple(_args, "b", &tracks)) return NULL; _err = SetControlDragTrackingEnabled(_self->ob_itself, tracks); if (_err != noErr) return PyMac_Error(_err); Py_INCREF(Py_None); _res = Py_None; return _res; } #endif #if TARGET_API_MAC_CARBON static PyObject *CtlObj_IsControlDragTrackingEnabled(ControlObject *_self, PyObject *_args) { PyObject *_res = NULL; OSStatus _err; Boolean tracks; #ifndef IsControlDragTrackingEnabled PyMac_PRECHECK(IsControlDragTrackingEnabled); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; _err = IsControlDragTrackingEnabled(_self->ob_itself, &tracks); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("b", tracks); return _res; } #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS 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; } #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS 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; } #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS 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; } #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS 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; } #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS 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; } #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS 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; } #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS 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; } #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS 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; } #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS 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; } #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS 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; } #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS 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; } #endif 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_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_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_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 (PyInt_Check(callback) && PyInt_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 (PyInt_Check(callback) && PyInt_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; } #if !TARGET_API_MAC_CARBON static PyObject *CtlObj_GetPopupData(ControlObject *_self, PyObject *_args) { PyObject *_res = NULL; PopupPrivateDataHandle hdl; if ( (*_self->ob_itself)->contrlData == NULL ) { PyErr_SetString(Ctl_Error, "No contrlData handle in control"); return 0; } hdl = (PopupPrivateDataHandle)(*_self->ob_itself)->contrlData; HLock((Handle)hdl); _res = Py_BuildValue("O&i", MenuObj_New, (*hdl)->mHandle, (int)(*hdl)->mID); HUnlock((Handle)hdl); return _res; } #endif #if !TARGET_API_MAC_CARBON static PyObject *CtlObj_SetPopupData(ControlObject *_self, PyObject *_args) { PyObject *_res = NULL; PopupPrivateDataHandle hdl; MenuHandle mHandle; short mID; if (!PyArg_ParseTuple(_args, "O&h", MenuObj_Convert, &mHandle, &mID) ) return 0; if ( (*_self->ob_itself)->contrlData == NULL ) { PyErr_SetString(Ctl_Error, "No contrlData handle in control"); return 0; } hdl = (PopupPrivateDataHandle)(*_self->ob_itself)->contrlData; (*hdl)->mHandle = mHandle; (*hdl)->mID = mID; Py_INCREF(Py_None); return Py_None; } #endif static PyMethodDef CtlObj_methods[] = { {"HiliteControl", (PyCFunction)CtlObj_HiliteControl, 1, "(ControlPartCode hiliteState) -> None"}, {"ShowControl", (PyCFunction)CtlObj_ShowControl, 1, "() -> None"}, {"HideControl", (PyCFunction)CtlObj_HideControl, 1, "() -> None"}, {"IsControlActive", (PyCFunction)CtlObj_IsControlActive, 1, "() -> (Boolean _rv)"}, {"IsControlVisible", (PyCFunction)CtlObj_IsControlVisible, 1, "() -> (Boolean _rv)"}, {"ActivateControl", (PyCFunction)CtlObj_ActivateControl, 1, "() -> None"}, {"DeactivateControl", (PyCFunction)CtlObj_DeactivateControl, 1, "() -> None"}, {"SetControlVisibility", (PyCFunction)CtlObj_SetControlVisibility, 1, "(Boolean inIsVisible, Boolean inDoDraw) -> None"}, {"Draw1Control", (PyCFunction)CtlObj_Draw1Control, 1, "() -> None"}, {"GetBestControlRect", (PyCFunction)CtlObj_GetBestControlRect, 1, "() -> (Rect outRect, SInt16 outBaseLineOffset)"}, {"SetControlFontStyle", (PyCFunction)CtlObj_SetControlFontStyle, 1, "(ControlFontStyleRec inStyle) -> None"}, {"DrawControlInCurrentPort", (PyCFunction)CtlObj_DrawControlInCurrentPort, 1, "() -> None"}, {"SetUpControlBackground", (PyCFunction)CtlObj_SetUpControlBackground, 1, "(SInt16 inDepth, Boolean inIsColorDevice) -> None"}, {"SetUpControlTextColor", (PyCFunction)CtlObj_SetUpControlTextColor, 1, "(SInt16 inDepth, Boolean inIsColorDevice) -> None"}, {"DragControl", (PyCFunction)CtlObj_DragControl, 1, "(Point startPoint, Rect limitRect, Rect slopRect, DragConstraint axis) -> None"}, {"TestControl", (PyCFunction)CtlObj_TestControl, 1, "(Point testPoint) -> (ControlPartCode _rv)"}, #if TARGET_API_MAC_CARBON {"HandleControlContextualMenuClick", (PyCFunction)CtlObj_HandleControlContextualMenuClick, 1, "(Point inWhere) -> (Boolean menuDisplayed)"}, #endif #if TARGET_API_MAC_CARBON {"GetControlClickActivation", (PyCFunction)CtlObj_GetControlClickActivation, 1, "(Point inWhere, EventModifiers inModifiers) -> (ClickActivationResult outResult)"}, #endif {"HandleControlKey", (PyCFunction)CtlObj_HandleControlKey, 1, "(SInt16 inKeyCode, SInt16 inCharCode, EventModifiers inModifiers) -> (SInt16 _rv)"}, #if TARGET_API_MAC_CARBON {"HandleControlSetCursor", (PyCFunction)CtlObj_HandleControlSetCursor, 1, "(Point localPoint, EventModifiers modifiers) -> (Boolean cursorWasSet)"}, #endif {"MoveControl", (PyCFunction)CtlObj_MoveControl, 1, "(SInt16 h, SInt16 v) -> None"}, {"SizeControl", (PyCFunction)CtlObj_SizeControl, 1, "(SInt16 w, SInt16 h) -> None"}, {"SetControlTitle", (PyCFunction)CtlObj_SetControlTitle, 1, "(Str255 title) -> None"}, {"GetControlTitle", (PyCFunction)CtlObj_GetControlTitle, 1, "() -> (Str255 title)"}, {"GetControlValue", (PyCFunction)CtlObj_GetControlValue, 1, "() -> (SInt16 _rv)"}, {"SetControlValue", (PyCFunction)CtlObj_SetControlValue, 1, "(SInt16 newValue) -> None"}, {"GetControlMinimum", (PyCFunction)CtlObj_GetControlMinimum, 1, "() -> (SInt16 _rv)"}, {"SetControlMinimum", (PyCFunction)CtlObj_SetControlMinimum, 1, "(SInt16 newMinimum) -> None"}, {"GetControlMaximum", (PyCFunction)CtlObj_GetControlMaximum, 1, "() -> (SInt16 _rv)"}, {"SetControlMaximum", (PyCFunction)CtlObj_SetControlMaximum, 1, "(SInt16 newMaximum) -> None"}, {"GetControlViewSize", (PyCFunction)CtlObj_GetControlViewSize, 1, "() -> (SInt32 _rv)"}, {"SetControlViewSize", (PyCFunction)CtlObj_SetControlViewSize, 1, "(SInt32 newViewSize) -> None"}, {"GetControl32BitValue", (PyCFunction)CtlObj_GetControl32BitValue, 1, "() -> (SInt32 _rv)"}, {"SetControl32BitValue", (PyCFunction)CtlObj_SetControl32BitValue, 1, "(SInt32 newValue) -> None"}, {"GetControl32BitMaximum", (PyCFunction)CtlObj_GetControl32BitMaximum, 1, "() -> (SInt32 _rv)"}, {"SetControl32BitMaximum", (PyCFunction)CtlObj_SetControl32BitMaximum, 1, "(SInt32 newMaximum) -> None"}, {"GetControl32BitMinimum", (PyCFunction)CtlObj_GetControl32BitMinimum, 1, "() -> (SInt32 _rv)"}, {"SetControl32BitMinimum", (PyCFunction)CtlObj_SetControl32BitMinimum, 1, "(SInt32 newMinimum) -> None"}, {"IsValidControlHandle", (PyCFunction)CtlObj_IsValidControlHandle, 1, "() -> (Boolean _rv)"}, #if TARGET_API_MAC_CARBON {"SetControlID", (PyCFunction)CtlObj_SetControlID, 1, "(ControlID inID) -> None"}, #endif #if TARGET_API_MAC_CARBON {"GetControlID", (PyCFunction)CtlObj_GetControlID, 1, "() -> (ControlID outID)"}, #endif {"RemoveControlProperty", (PyCFunction)CtlObj_RemoveControlProperty, 1, "(OSType propertyCreator, OSType propertyTag) -> None"}, #if TARGET_API_MAC_CARBON {"GetControlPropertyAttributes", (PyCFunction)CtlObj_GetControlPropertyAttributes, 1, "(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"}, #endif #if TARGET_API_MAC_CARBON {"ChangeControlPropertyAttributes", (PyCFunction)CtlObj_ChangeControlPropertyAttributes, 1, "(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"}, #endif {"GetControlRegion", (PyCFunction)CtlObj_GetControlRegion, 1, "(ControlPartCode inPart, RgnHandle outRegion) -> None"}, {"GetControlVariant", (PyCFunction)CtlObj_GetControlVariant, 1, "() -> (ControlVariant _rv)"}, {"SetControlReference", (PyCFunction)CtlObj_SetControlReference, 1, "(SInt32 data) -> None"}, {"GetControlReference", (PyCFunction)CtlObj_GetControlReference, 1, "() -> (SInt32 _rv)"}, #if !TARGET_API_MAC_CARBON {"GetAuxiliaryControlRecord", (PyCFunction)CtlObj_GetAuxiliaryControlRecord, 1, "() -> (Boolean _rv, AuxCtlHandle acHndl)"}, #endif #if !TARGET_API_MAC_CARBON {"SetControlColor", (PyCFunction)CtlObj_SetControlColor, 1, "(CCTabHandle newColorTable) -> None"}, #endif {"EmbedControl", (PyCFunction)CtlObj_EmbedControl, 1, "(ControlHandle inContainer) -> None"}, {"AutoEmbedControl", (PyCFunction)CtlObj_AutoEmbedControl, 1, "(WindowPtr inWindow) -> None"}, {"GetSuperControl", (PyCFunction)CtlObj_GetSuperControl, 1, "() -> (ControlHandle outParent)"}, {"CountSubControls", (PyCFunction)CtlObj_CountSubControls, 1, "() -> (UInt16 outNumChildren)"}, {"GetIndexedSubControl", (PyCFunction)CtlObj_GetIndexedSubControl, 1, "(UInt16 inIndex) -> (ControlHandle outSubControl)"}, {"SetControlSupervisor", (PyCFunction)CtlObj_SetControlSupervisor, 1, "(ControlHandle inBoss) -> None"}, {"GetControlFeatures", (PyCFunction)CtlObj_GetControlFeatures, 1, "() -> (UInt32 outFeatures)"}, {"GetControlDataSize", (PyCFunction)CtlObj_GetControlDataSize, 1, "(ControlPartCode inPart, ResType inTagName) -> (Size outMaxSize)"}, #if TARGET_API_MAC_CARBON {"HandleControlDragTracking", (PyCFunction)CtlObj_HandleControlDragTracking, 1, "(DragTrackingMessage inMessage, DragReference inDrag) -> (Boolean outLikesDrag)"}, #endif #if TARGET_API_MAC_CARBON {"HandleControlDragReceive", (PyCFunction)CtlObj_HandleControlDragReceive, 1, "(DragReference inDrag) -> None"}, #endif #if TARGET_API_MAC_CARBON {"SetControlDragTrackingEnabled", (PyCFunction)CtlObj_SetControlDragTrackingEnabled, 1, "(Boolean tracks) -> None"}, #endif #if TARGET_API_MAC_CARBON {"IsControlDragTrackingEnabled", (PyCFunction)CtlObj_IsControlDragTrackingEnabled, 1, "() -> (Boolean tracks)"}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"GetControlBounds", (PyCFunction)CtlObj_GetControlBounds, 1, "() -> (Rect bounds)"}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"IsControlHilited", (PyCFunction)CtlObj_IsControlHilited, 1, "() -> (Boolean _rv)"}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"GetControlHilite", (PyCFunction)CtlObj_GetControlHilite, 1, "() -> (UInt16 _rv)"}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"GetControlOwner", (PyCFunction)CtlObj_GetControlOwner, 1, "() -> (WindowPtr _rv)"}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"GetControlDataHandle", (PyCFunction)CtlObj_GetControlDataHandle, 1, "() -> (Handle _rv)"}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"GetControlPopupMenuHandle", (PyCFunction)CtlObj_GetControlPopupMenuHandle, 1, "() -> (MenuHandle _rv)"}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"GetControlPopupMenuID", (PyCFunction)CtlObj_GetControlPopupMenuID, 1, "() -> (short _rv)"}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"SetControlDataHandle", (PyCFunction)CtlObj_SetControlDataHandle, 1, "(Handle dataHandle) -> None"}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"SetControlBounds", (PyCFunction)CtlObj_SetControlBounds, 1, "(Rect bounds) -> None"}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"SetControlPopupMenuHandle", (PyCFunction)CtlObj_SetControlPopupMenuHandle, 1, "(MenuHandle popupMenu) -> None"}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"SetControlPopupMenuID", (PyCFunction)CtlObj_SetControlPopupMenuID, 1, "(short menuID) -> None"}, #endif {"GetBevelButtonMenuValue", (PyCFunction)CtlObj_GetBevelButtonMenuValue, 1, "() -> (SInt16 outValue)"}, {"SetBevelButtonMenuValue", (PyCFunction)CtlObj_SetBevelButtonMenuValue, 1, "(SInt16 inValue) -> None"}, {"GetBevelButtonMenuHandle", (PyCFunction)CtlObj_GetBevelButtonMenuHandle, 1, "() -> (MenuHandle outHandle)"}, {"SetBevelButtonTransform", (PyCFunction)CtlObj_SetBevelButtonTransform, 1, "(IconTransformType transform) -> None"}, {"SetDisclosureTriangleLastValue", (PyCFunction)CtlObj_SetDisclosureTriangleLastValue, 1, "(SInt16 inValue) -> None"}, {"GetTabContentRect", (PyCFunction)CtlObj_GetTabContentRect, 1, "() -> (Rect outContentRect)"}, {"SetTabEnabled", (PyCFunction)CtlObj_SetTabEnabled, 1, "(SInt16 inTabToHilite, Boolean inEnabled) -> None"}, {"SetImageWellTransform", (PyCFunction)CtlObj_SetImageWellTransform, 1, "(IconTransformType inTransform) -> None"}, {"as_Resource", (PyCFunction)CtlObj_as_Resource, 1, "() -> (Handle _rv)"}, {"GetControlRect", (PyCFunction)CtlObj_GetControlRect, 1, "() -> (Rect rect)"}, {"DisposeControl", (PyCFunction)CtlObj_DisposeControl, 1, "() -> None"}, {"TrackControl", (PyCFunction)CtlObj_TrackControl, 1, "(Point startPoint [,trackercallback]) -> (ControlPartCode _rv)"}, {"HandleControlClick", (PyCFunction)CtlObj_HandleControlClick, 1, "(Point startPoint, Integer modifiers, [,trackercallback]) -> (ControlPartCode _rv)"}, {"SetControlData", (PyCFunction)CtlObj_SetControlData, 1, "(stuff) -> None"}, {"GetControlData", (PyCFunction)CtlObj_GetControlData, 1, "(part, type) -> String"}, {"SetControlData_Handle", (PyCFunction)CtlObj_SetControlData_Handle, 1, "(ResObj) -> None"}, {"GetControlData_Handle", (PyCFunction)CtlObj_GetControlData_Handle, 1, "(part, type) -> ResObj"}, {"SetControlData_Callback", (PyCFunction)CtlObj_SetControlData_Callback, 1, "(callbackfunc) -> None"}, #if !TARGET_API_MAC_CARBON {"GetPopupData", (PyCFunction)CtlObj_GetPopupData, 1, NULL}, #endif #if !TARGET_API_MAC_CARBON {"SetPopupData", (PyCFunction)CtlObj_SetPopupData, 1, NULL}, #endif {NULL, NULL, 0} }; PyMethodChain CtlObj_chain = { CtlObj_methods, NULL }; static PyObject *CtlObj_getattr(ControlObject *self, char *name) { return Py_FindMethodInChain(&CtlObj_chain, (PyObject *)self, name); } #define CtlObj_setattr 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; } PyTypeObject Control_Type = { PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ "_Ctl.Control", /*tp_name*/ sizeof(ControlObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor) CtlObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ (getattrfunc) CtlObj_getattr, /*tp_getattr*/ (setattrfunc) CtlObj_setattr, /*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*/ }; /* -------------------- 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 theWindow; RgnHandle updateRegion; #ifndef UpdateControls PyMac_PRECHECK(UpdateControls); #endif if (!PyArg_ParseTuple(_args, "O&O&", WinObj_Convert, &theWindow, ResObj_Convert, &updateRegion)) return NULL; UpdateControls(theWindow, updateRegion); 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_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_New, _rv, outPart); 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; } #if TARGET_API_MAC_CARBON 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; } #endif 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_WhichControl, 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; } #if TARGET_API_MAC_CARBON static PyObject *Ctl_SetAutomaticControlDragTrackingEnabledForWindow(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; OSStatus _err; WindowPtr theWindow; Boolean tracks; #ifndef SetAutomaticControlDragTrackingEnabledForWindow PyMac_PRECHECK(SetAutomaticControlDragTrackingEnabledForWindow); #endif if (!PyArg_ParseTuple(_args, "O&b", WinObj_Convert, &theWindow, &tracks)) return NULL; _err = SetAutomaticControlDragTrackingEnabledForWindow(theWindow, tracks); if (_err != noErr) return PyMac_Error(_err); Py_INCREF(Py_None); _res = Py_None; return _res; } #endif #if TARGET_API_MAC_CARBON static PyObject *Ctl_IsAutomaticControlDragTrackingEnabledForWindow(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; OSStatus _err; WindowPtr theWindow; Boolean tracks; #ifndef IsAutomaticControlDragTrackingEnabledForWindow PyMac_PRECHECK(IsAutomaticControlDragTrackingEnabledForWindow); #endif if (!PyArg_ParseTuple(_args, "O&", WinObj_Convert, &theWindow)) return NULL; _err = IsAutomaticControlDragTrackingEnabledForWindow(theWindow, &tracks); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("b", tracks); return _res; } #endif 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 PyMethodDef Ctl_methods[] = { {"NewControl", (PyCFunction)Ctl_NewControl, 1, "(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, "(SInt16 resourceID, WindowPtr owningWindow) -> (ControlHandle _rv)"}, {"DrawControls", (PyCFunction)Ctl_DrawControls, 1, "(WindowPtr theWindow) -> None"}, {"UpdateControls", (PyCFunction)Ctl_UpdateControls, 1, "(WindowPtr theWindow, RgnHandle updateRegion) -> None"}, {"FindControl", (PyCFunction)Ctl_FindControl, 1, "(Point testPoint, WindowPtr theWindow) -> (ControlPartCode _rv, ControlHandle theControl)"}, {"FindControlUnderMouse", (PyCFunction)Ctl_FindControlUnderMouse, 1, "(Point inWhere, WindowPtr inWindow) -> (ControlHandle _rv, SInt16 outPart)"}, {"IdleControls", (PyCFunction)Ctl_IdleControls, 1, "(WindowPtr inWindow) -> None"}, #if TARGET_API_MAC_CARBON {"GetControlByID", (PyCFunction)Ctl_GetControlByID, 1, "(WindowPtr inWindow, ControlID inID) -> (ControlHandle outControl)"}, #endif {"DumpControlHierarchy", (PyCFunction)Ctl_DumpControlHierarchy, 1, "(WindowPtr inWindow, FSSpec inDumpFile) -> None"}, {"CreateRootControl", (PyCFunction)Ctl_CreateRootControl, 1, "(WindowPtr inWindow) -> (ControlHandle outControl)"}, {"GetRootControl", (PyCFunction)Ctl_GetRootControl, 1, "(WindowPtr inWindow) -> (ControlHandle outControl)"}, {"GetKeyboardFocus", (PyCFunction)Ctl_GetKeyboardFocus, 1, "(WindowPtr inWindow) -> (ControlHandle outControl)"}, {"SetKeyboardFocus", (PyCFunction)Ctl_SetKeyboardFocus, 1, "(WindowPtr inWindow, ControlHandle inControl, ControlFocusPart inPart) -> None"}, {"AdvanceKeyboardFocus", (PyCFunction)Ctl_AdvanceKeyboardFocus, 1, "(WindowPtr inWindow) -> None"}, {"ReverseKeyboardFocus", (PyCFunction)Ctl_ReverseKeyboardFocus, 1, "(WindowPtr inWindow) -> None"}, {"ClearKeyboardFocus", (PyCFunction)Ctl_ClearKeyboardFocus, 1, "(WindowPtr inWindow) -> None"}, #if TARGET_API_MAC_CARBON {"SetAutomaticControlDragTrackingEnabledForWindow", (PyCFunction)Ctl_SetAutomaticControlDragTrackingEnabledForWindow, 1, "(WindowPtr theWindow, Boolean tracks) -> None"}, #endif #if TARGET_API_MAC_CARBON {"IsAutomaticControlDragTrackingEnabledForWindow", (PyCFunction)Ctl_IsAutomaticControlDragTrackingEnabledForWindow, 1, "(WindowPtr theWindow) -> (Boolean tracks)"}, #endif {"as_Control", (PyCFunction)Ctl_as_Control, 1, "(Handle h) -> (ControlHandle _rv)"}, {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"); } static int setcallback(PyObject *myself, OSType which, PyObject *callback, UniversalProcPtr *uppp) { ControlObject *self = (ControlObject *)myself; char keybuf[9]; 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", which); return NULL; } rv = PyEval_CallObject(func, arglist); if ( rv == NULL ) PySys_WriteStderr("Exception in control callback %x handler\n", which); return 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 ) PyArg_Parse(rv, "h", &c_rv); 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 ) PyArg_Parse(rv, "h", &c_rv); Py_XDECREF(rv); return (ControlPartCode)c_rv; } void init_Ctl(void) { PyObject *m; PyObject *d; mytracker_upp = NewControlActionUPP(mytracker); 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; Control_Type.ob_type = &PyType_Type; Py_INCREF(&Control_Type); if (PyDict_SetItemString(d, "ControlType", (PyObject *)&Control_Type) != 0) Py_FatalError("can't initialize ControlType"); } /* ======================== End module _Ctl ========================= */