/* =========================== Module Ctl =========================== */ #include "Python.h" #define SystemSevenOrLater 1 #include "macglue.h" #include #include #include #include extern PyObject *ResObj_New(Handle); extern int ResObj_Convert(PyObject *, Handle *); extern PyObject *OptResObj_New(Handle); extern int OptResObj_Convert(PyObject *, Handle *); extern PyObject *WinObj_New(WindowPtr); extern int WinObj_Convert(PyObject *, WindowPtr *); extern PyTypeObject Window_Type; #define WinObj_Check(x) ((x)->ob_type == &Window_Type) extern PyObject *DlgObj_New(DialogPtr); extern int DlgObj_Convert(PyObject *, DialogPtr *); extern PyTypeObject Dialog_Type; #define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type) extern PyObject *MenuObj_New(MenuHandle); extern int MenuObj_Convert(PyObject *, MenuHandle *); extern PyObject *CtlObj_New(ControlHandle); extern int CtlObj_Convert(PyObject *, ControlHandle *); extern PyObject *GrafObj_New(GrafPtr); extern int GrafObj_Convert(PyObject *, GrafPtr *); extern PyObject *BMObj_New(BitMapPtr); extern int BMObj_Convert(PyObject *, BitMapPtr *); extern PyObject *WinObj_WhichWindow(WindowPtr); #include #define as_Control(h) ((ControlHandle)h) #define resNotFound -192 /* Can't include because of Python's "errors.h" */ extern PyObject *CtlObj_WhichControl(ControlHandle); /* Forward */ extern PyObject *QdRGB_New(RGBColorPtr); extern QdRGB_Convert(PyObject *, RGBColorPtr); #ifdef THINK_C #define ControlActionUPP ProcPtr #endif /* ** Parse/generate ControlFontStyleRec records */ #if 0 /* Not needed */ PyObject *ControlFontStyle_New(itself) 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 ControlFontStyle_Convert(v, itself) 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); } /* TrackControl and HandleControlClick callback support */ static PyObject *tracker; static ControlActionUPP mytracker_upp; extern int settrackfunc(PyObject *); /* forward */ extern void clrtrackfunc(void); /* forward */ 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; } ControlObject; PyObject *CtlObj_New(itself) 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); return (PyObject *)it; } CtlObj_Convert(v, p_itself) 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(self) ControlObject *self; { if (self->ob_itself)SetControlReference(self->ob_itself, (long)0); /* Make it forget about us */ PyMem_DEL(self); } static PyObject *CtlObj_HiliteControl(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; ControlPartCode hiliteState; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; if (!PyArg_ParseTuple(_args, "")) return NULL; ShowControl(_self->ob_itself); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *CtlObj_HideControl(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; if (!PyArg_ParseTuple(_args, "")) return NULL; HideControl(_self->ob_itself); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *CtlObj_IsControlActive(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; Boolean _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = IsControlActive(_self->ob_itself); _res = Py_BuildValue("b", _rv); return _res; } static PyObject *CtlObj_IsControlVisible(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; Boolean _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = IsControlVisible(_self->ob_itself); _res = Py_BuildValue("b", _rv); return _res; } static PyObject *CtlObj_ActivateControl(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; Boolean inIsVisible; Boolean inDoDraw; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; if (!PyArg_ParseTuple(_args, "")) return NULL; Draw1Control(_self->ob_itself); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *CtlObj_GetBestControlRect(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; Rect outRect; SInt16 outBaseLineOffset; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; ControlFontStyleRec inStyle; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; if (!PyArg_ParseTuple(_args, "")) return NULL; DrawControlInCurrentPort(_self->ob_itself); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *CtlObj_SetUpControlBackground(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; SInt16 inDepth; Boolean inIsColorDevice; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; SInt16 inDepth; Boolean inIsColorDevice; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; Point startPoint; Rect limitRect; Rect slopRect; DragConstraint axis; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; ControlPartCode _rv; Point testPoint; 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_HandleControlKey(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt16 _rv; SInt16 inKeyCode; SInt16 inCharCode; SInt16 inModifiers; 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_MoveControl(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt16 h; SInt16 v; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt16 w; SInt16 h; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; Str255 title; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; Str255 title; if (!PyArg_ParseTuple(_args, "")) return NULL; GetControlTitle(_self->ob_itself, title); _res = Py_BuildValue("O&", PyMac_BuildStr255, title); return _res; } static PyObject *CtlObj_GetControlValue(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt16 _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetControlValue(_self->ob_itself); _res = Py_BuildValue("h", _rv); return _res; } static PyObject *CtlObj_SetControlValue(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt16 newValue; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt16 _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetControlMinimum(_self->ob_itself); _res = Py_BuildValue("h", _rv); return _res; } static PyObject *CtlObj_SetControlMinimum(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt16 newMinimum; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt16 _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetControlMaximum(_self->ob_itself); _res = Py_BuildValue("h", _rv); return _res; } static PyObject *CtlObj_SetControlMaximum(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt16 newMaximum; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt32 _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetControlViewSize(_self->ob_itself); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *CtlObj_SetControlViewSize(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt32 newViewSize; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt32 _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetControl32BitValue(_self->ob_itself); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *CtlObj_SetControl32BitValue(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt32 newValue; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt32 _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetControl32BitMaximum(_self->ob_itself); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *CtlObj_SetControl32BitMaximum(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt32 newMaximum; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt32 _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetControl32BitMinimum(_self->ob_itself); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *CtlObj_SetControl32BitMinimum(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt32 newMinimum; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; Boolean _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = IsValidControlHandle(_self->ob_itself); _res = Py_BuildValue("b", _rv); return _res; } static PyObject *CtlObj_RemoveControlProperty(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSStatus _err; OSType propertyCreator; OSType propertyTag; 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_GetControlRegion(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSStatus _err; ControlPartCode inPart; RgnHandle outRegion; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; ControlVariant _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetControlVariant(_self->ob_itself); _res = Py_BuildValue("h", _rv); return _res; } static PyObject *CtlObj_SetControlReference(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt32 data; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt32 _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetControlReference(_self->ob_itself); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *CtlObj_GetAuxiliaryControlRecord(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; Boolean _rv; AuxCtlHandle acHndl; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetAuxiliaryControlRecord(_self->ob_itself, &acHndl); _res = Py_BuildValue("bO&", _rv, ResObj_New, acHndl); return _res; } static PyObject *CtlObj_SetControlColor(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; CCTabHandle newColorTable; if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &newColorTable)) return NULL; SetControlColor(_self->ob_itself, newColorTable); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *CtlObj_SendControlMessage(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; SInt32 _rv; SInt16 inMessage; SInt32 inParam; if (!PyArg_ParseTuple(_args, "hl", &inMessage, &inParam)) return NULL; _rv = SendControlMessage(_self->ob_itself, inMessage, inParam); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *CtlObj_EmbedControl(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; ControlHandle inContainer; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; WindowPtr inWindow; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; ControlHandle outParent; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; UInt16 outNumChildren; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; UInt16 inIndex; ControlHandle outSubControl; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; ControlHandle inBoss; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; UInt32 outFeatures; 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; ControlPartCode inPart; ResType inTagName; Size outMaxSize; 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_as_Resource(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; return ResObj_New((Handle)_self->ob_itself); } static PyObject *CtlObj_DisposeControl(_self, _args) 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(_self, _args) 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(_self, _args) 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(_self, _args) 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(_self, _args) 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_SetControlDataHandle(_self, _args) 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_GetControlDataHandle(_self, _args) 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); } return Py_BuildValue("O&", OptResObj_New, hdl); } static PyObject *CtlObj_GetPopupData(_self, _args) 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; } static PyObject *CtlObj_SetPopupData(_self, _args) 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; } 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)"}, {"HandleControlKey", (PyCFunction)CtlObj_HandleControlKey, 1, "(SInt16 inKeyCode, SInt16 inCharCode, SInt16 inModifiers) -> (SInt16 _rv)"}, {"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)"}, {"RemoveControlProperty", (PyCFunction)CtlObj_RemoveControlProperty, 1, "(OSType propertyCreator, OSType propertyTag) -> None"}, {"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)"}, {"GetAuxiliaryControlRecord", (PyCFunction)CtlObj_GetAuxiliaryControlRecord, 1, "() -> (Boolean _rv, AuxCtlHandle acHndl)"}, {"SetControlColor", (PyCFunction)CtlObj_SetControlColor, 1, "(CCTabHandle newColorTable) -> None"}, {"SendControlMessage", (PyCFunction)CtlObj_SendControlMessage, 1, "(SInt16 inMessage, SInt32 inParam) -> (SInt32 _rv)"}, {"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)"}, {"as_Resource", (PyCFunction)CtlObj_as_Resource, 1, "Return this Control as a Resource"}, {"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"}, {"SetControlDataHandle", (PyCFunction)CtlObj_SetControlDataHandle, 1, "(ResObj) -> None"}, {"GetControlDataHandle", (PyCFunction)CtlObj_GetControlDataHandle, 1, "(part, type) -> ResObj"}, {"GetPopupData", (PyCFunction)CtlObj_GetPopupData, 1, NULL}, {"SetPopupData", (PyCFunction)CtlObj_SetPopupData, 1, NULL}, {NULL, NULL, 0} }; PyMethodChain CtlObj_chain = { CtlObj_methods, NULL }; static PyObject *CtlObj_getattr(self, name) ControlObject *self; char *name; { return Py_FindMethodInChain(&CtlObj_chain, (PyObject *)self, name); } #define CtlObj_setattr NULL static int CtlObj_compare(self, other) ControlObject *self, *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(self) ControlObject *self; { return (long)self->ob_itself; } PyTypeObject Control_Type = { PyObject_HEAD_INIT(&PyType_Type) 0, /*ob_size*/ "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(_self, _args) 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; 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(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ControlHandle _rv; SInt16 resourceID; WindowPtr owningWindow; 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(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; WindowPtr theWindow; 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(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; WindowPtr theWindow; RgnHandle updateRegion; 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(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ControlPartCode _rv; Point testPoint; WindowPtr theWindow; ControlHandle theControl; 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(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ControlHandle _rv; Point inWhere; WindowPtr inWindow; SInt16 outPart; 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(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; WindowPtr inWindow; if (!PyArg_ParseTuple(_args, "O&", WinObj_Convert, &inWindow)) return NULL; IdleControls(inWindow); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Ctl_DumpControlHierarchy(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; WindowPtr inWindow; FSSpec inDumpFile; 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(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; WindowPtr inWindow; ControlHandle outControl; 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(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; WindowPtr inWindow; ControlHandle outControl; 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(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; WindowPtr inWindow; ControlHandle outControl; 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(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; WindowPtr inWindow; ControlHandle inControl; ControlFocusPart inPart; 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(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; WindowPtr inWindow; 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(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; WindowPtr inWindow; 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(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; WindowPtr inWindow; 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_as_Control(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ControlHandle _rv; Handle h; 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"}, {"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"}, {"as_Control", (PyCFunction)Ctl_as_Control, 1, "(Handle h) -> (ControlHandle _rv)"}, {NULL, NULL, 0} }; PyObject *CtlObj_NewUnmanaged(itself) 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; return (PyObject *)it; } 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(obj) PyObject *obj; { if (tracker) { PyErr_SetString(Ctl_Error, "Tracker function in use"); return 0; } tracker = obj; Py_INCREF(tracker); } static void clrtrackfunc() { Py_XDECREF(tracker); tracker = 0; } static pascal void mytracker(ctl, part) 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"); } void initCtl() { PyObject *m; PyObject *d; mytracker_upp = NewControlActionProc(mytracker); 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) Py_FatalError("can't initialize Ctl.Error"); 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 ========================= */