diff options
28 files changed, 3034 insertions, 546 deletions
diff --git a/Mac/Modules/ae/AEmodule.c b/Mac/Modules/ae/AEmodule.c index ab07544..d15c1d8 100644 --- a/Mac/Modules/ae/AEmodule.c +++ b/Mac/Modules/ae/AEmodule.c @@ -9,6 +9,7 @@ #include "pymactoolbox.h" #include <AppleEvents.h> +#include <AEObjects.h> static pascal OSErr GenericEventHandler(); /* Forward */ @@ -69,34 +70,6 @@ static void AEDesc_dealloc(self) PyMem_DEL(self); } -static PyObject *AEDesc_AESend(_self, _args) - AEDescObject *_self; - PyObject *_args; -{ - PyObject *_res = NULL; - OSErr _err; - AppleEvent reply; - AESendMode sendMode; - AESendPriority sendPriority; - long timeOutInTicks; - if (!PyArg_ParseTuple(_args, "lhl", - &sendMode, - &sendPriority, - &timeOutInTicks)) - return NULL; - _err = AESend(&_self->ob_itself, - &reply, - sendMode, - sendPriority, - timeOutInTicks, - upp_AEIdleProc, - (AEFilterUPP)0); - if (_err != noErr) return PyMac_Error(_err); - _res = Py_BuildValue("O&", - AEDesc_New, &reply); - return _res; -} - static PyObject *AEDesc_AEResetTimer(_self, _args) AEDescObject *_self; PyObject *_args; @@ -672,9 +645,24 @@ static PyObject *AEDesc_AEPutAttributeDesc(_self, _args) return _res; } +#if TARGET_API_MAC_CARBON + +static PyObject *AEDesc_AEGetDescDataSize(_self, _args) + AEDescObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Size _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = AEGetDescDataSize(&_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} +#endif + static PyMethodDef AEDesc_methods[] = { - {"AESend", (PyCFunction)AEDesc_AESend, 1, - "(AESendMode sendMode, AESendPriority sendPriority, long timeOutInTicks) -> (AppleEvent reply)"}, {"AEResetTimer", (PyCFunction)AEDesc_AEResetTimer, 1, "() -> None"}, {"AESuspendTheCurrentEvent", (PyCFunction)AEDesc_AESuspendTheCurrentEvent, 1, @@ -725,6 +713,11 @@ static PyMethodDef AEDesc_methods[] = { "(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None"}, {"AEPutAttributeDesc", (PyCFunction)AEDesc_AEPutAttributeDesc, 1, "(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None"}, + +#if TARGET_API_MAC_CARBON + {"AEGetDescDataSize", (PyCFunction)AEDesc_AEGetDescDataSize, 1, + "() -> (Size _rv)"}, +#endif {NULL, NULL, 0} }; @@ -941,6 +934,44 @@ static PyObject *AE_AEGetEventHandler(_self, _args) return _res; } +static PyObject *AE_AEInstallSpecialHandler(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + AEKeyword functionClass; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetOSType, &functionClass)) + return NULL; + _err = AEInstallSpecialHandler(functionClass, + upp_GenericEventHandler, + 0); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *AE_AERemoveSpecialHandler(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + AEKeyword functionClass; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetOSType, &functionClass)) + return NULL; + _err = AERemoveSpecialHandler(functionClass, + upp_GenericEventHandler, + 0); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + static PyObject *AE_AEManagerInfo(_self, _args) PyObject *_self; PyObject *_args; @@ -1072,6 +1103,35 @@ static PyObject *AE_AECreateAppleEvent(_self, _args) return _res; } +#if TARGET_API_MAC_CARBON + +static PyObject *AE_AEReplaceDescData(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + DescType typeCode; + char *dataPtr__in__; + long dataPtr__len__; + int dataPtr__in_len__; + AEDesc theAEDesc; + if (!PyArg_ParseTuple(_args, "O&s#", + PyMac_GetOSType, &typeCode, + &dataPtr__in__, &dataPtr__in_len__)) + return NULL; + dataPtr__len__ = dataPtr__in_len__; + _err = AEReplaceDescData(typeCode, + dataPtr__in__, dataPtr__len__, + &theAEDesc); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + AEDesc_New, &theAEDesc); + dataPtr__error__: ; + return _res; +} +#endif + static PyMethodDef AE_methods[] = { {"AEProcessAppleEvent", (PyCFunction)AE_AEProcessAppleEvent, 1, "(EventRecord theEventRecord) -> None"}, @@ -1087,6 +1147,10 @@ static PyMethodDef AE_methods[] = { "(AEEventClass theAEEventClass, AEEventID theAEEventID) -> None"}, {"AEGetEventHandler", (PyCFunction)AE_AEGetEventHandler, 1, "(AEEventClass theAEEventClass, AEEventID theAEEventID) -> (EventHandler handler)"}, + {"AEInstallSpecialHandler", (PyCFunction)AE_AEInstallSpecialHandler, 1, + "(AEKeyword functionClass) -> None"}, + {"AERemoveSpecialHandler", (PyCFunction)AE_AERemoveSpecialHandler, 1, + "(AEKeyword functionClass) -> None"}, {"AEManagerInfo", (PyCFunction)AE_AEManagerInfo, 1, "(AEKeyword keyWord) -> (long result)"}, {"AECoercePtr", (PyCFunction)AE_AECoercePtr, 1, @@ -1097,6 +1161,11 @@ static PyMethodDef AE_methods[] = { "(Buffer factoringPtr, Boolean isRecord) -> (AEDescList resultList)"}, {"AECreateAppleEvent", (PyCFunction)AE_AECreateAppleEvent, 1, "(AEEventClass theAEEventClass, AEEventID theAEEventID, AEAddressDesc target, AEReturnID returnID, AETransactionID transactionID) -> (AppleEvent result)"}, + +#if TARGET_API_MAC_CARBON + {"AEReplaceDescData", (PyCFunction)AE_AEReplaceDescData, 1, + "(DescType typeCode, Buffer dataPtr) -> (AEDesc theAEDesc)"}, +#endif {NULL, NULL, 0} }; @@ -1149,7 +1218,7 @@ void initAE() AE_Error = PyMac_GetOSErrException(); if (AE_Error == NULL || PyDict_SetItemString(d, "Error", AE_Error) != 0) - Py_FatalError("can't initialize AE.Error"); + return; AEDesc_Type.ob_type = &PyType_Type; Py_INCREF(&AEDesc_Type); if (PyDict_SetItemString(d, "AEDescType", (PyObject *)&AEDesc_Type) != 0) diff --git a/Mac/Modules/ae/aescan.py b/Mac/Modules/ae/aescan.py index b2174a8..b744489 100644 --- a/Mac/Modules/ae/aescan.py +++ b/Mac/Modules/ae/aescan.py @@ -70,11 +70,19 @@ class AppleEventsScanner(Scanner): return [ "AEDisposeDesc", # "AEGetEventHandler", + "AEGetDescData", # Use object.data + "AEGetSpecialHandler", # Constants with funny definitions "kAEDontDisposeOnResume", "kAEUseStandardDispatch", ] + def makegreylist(self): + return [ + ('#if TARGET_API_MAC_CARBON', [ + 'AEGetDescDataSize', + 'AEReplaceDescData', + ])] def makeblacklisttypes(self): return [ "ProcPtr", diff --git a/Mac/Modules/ae/aesupport.py b/Mac/Modules/ae/aesupport.py index 9931f9d..1a13537 100644 --- a/Mac/Modules/ae/aesupport.py +++ b/Mac/Modules/ae/aesupport.py @@ -83,6 +83,7 @@ AEMethod = OSErrMethodGenerator includestuff = includestuff + """ #include <AppleEvents.h> +#include <AEObjects.h> static pascal OSErr GenericEventHandler(); /* Forward */ diff --git a/Mac/Modules/app/Appmodule.c b/Mac/Modules/app/Appmodule.c index fd12135..929c34f 100644 --- a/Mac/Modules/app/Appmodule.c +++ b/Mac/Modules/app/Appmodule.c @@ -1111,6 +1111,28 @@ static PyObject *App_GetThemeTextColor(_self, _args) return _res; } +#if TARGET_API_MAC_CARBON + +static PyObject *App_GetThemeMetric(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + ThemeMetric inMetric; + SInt32 outMetric; + if (!PyArg_ParseTuple(_args, "l", + &inMetric)) + return NULL; + _err = GetThemeMetric(inMetric, + &outMetric); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + outMetric); + return _res; +} +#endif + static PyMethodDef App_methods[] = { {"RegisterAppearanceClient", (PyCFunction)App_RegisterAppearanceClient, 1, "() -> None"}, @@ -1218,6 +1240,11 @@ static PyMethodDef App_methods[] = { "(ThemeBrush inBrush, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)"}, {"GetThemeTextColor", (PyCFunction)App_GetThemeTextColor, 1, "(ThemeTextColor inColor, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)"}, + +#if TARGET_API_MAC_CARBON + {"GetThemeMetric", (PyCFunction)App_GetThemeMetric, 1, + "(ThemeMetric inMetric) -> (SInt32 outMetric)"}, +#endif {NULL, NULL, 0} }; @@ -1237,7 +1264,7 @@ void initApp() App_Error = PyMac_GetOSErrException(); if (App_Error == NULL || PyDict_SetItemString(d, "Error", App_Error) != 0) - Py_FatalError("can't initialize App.Error"); + return; } /* ========================= End module App ========================= */ diff --git a/Mac/Modules/app/appscan.py b/Mac/Modules/app/appscan.py index 82bdd1b..9cfc598 100644 --- a/Mac/Modules/app/appscan.py +++ b/Mac/Modules/app/appscan.py @@ -43,6 +43,12 @@ class MyScanner(Scanner): "GetThemeFont", # Funny stringbuffer in/out parameter, I think... ] + def makegreylist(self): + return [ + ('#if TARGET_API_MAC_CARBON', [ + 'GetThemeMetric', + ])] + def makeblacklisttypes(self): return [ "MenuTitleDrawingUPP", diff --git a/Mac/Modules/app/appsupport.py b/Mac/Modules/app/appsupport.py index 11b6d2f..bd314dd 100644 --- a/Mac/Modules/app/appsupport.py +++ b/Mac/Modules/app/appsupport.py @@ -65,6 +65,7 @@ ThemeGrowDirection = Type("ThemeGrowDirection", "H") ThemeSoundKind = OSTypeType("ThemeSoundKind") ThemeDragSoundKind = OSTypeType("ThemeDragSoundKind") ThemeBackgroundKind = Type("ThemeBackgroundKind", "l") +ThemeMetric = Type("ThemeMetric", "l") RGBColor = OpaqueType("RGBColor", "QdRGB") includestuff = includestuff + """ diff --git a/Mac/Modules/cm/Cmmodule.c b/Mac/Modules/cm/Cmmodule.c index 79a1b7c..93a3e09 100644 --- a/Mac/Modules/cm/Cmmodule.c +++ b/Mac/Modules/cm/Cmmodule.c @@ -831,7 +831,7 @@ void initCm() Cm_Error = PyMac_GetOSErrException(); if (Cm_Error == NULL || PyDict_SetItemString(d, "Error", Cm_Error) != 0) - Py_FatalError("can't initialize Cm.Error"); + return; ComponentInstance_Type.ob_type = &PyType_Type; Py_INCREF(&ComponentInstance_Type); if (PyDict_SetItemString(d, "ComponentInstanceType", (PyObject *)&ComponentInstance_Type) != 0) diff --git a/Mac/Modules/cm/cmscan.py b/Mac/Modules/cm/cmscan.py index 1c36eaa..1136fe5 100644 --- a/Mac/Modules/cm/cmscan.py +++ b/Mac/Modules/cm/cmscan.py @@ -56,6 +56,8 @@ class MyScanner(Scanner): "CallComponentClose", "CallComponentOpen", "OpenAComponent", + "GetComponentPublicResource", # Missing in CW Pro 6 + "CallComponentGetPublicResource", # Missing in CW Pro 6 ] def makegreylist(self): @@ -77,6 +79,8 @@ class MyScanner(Scanner): "ComponentRoutineUPP", "ComponentMPWorkFunctionUPP", + "ComponentFunctionUPP", + "GetMissingComponentResourceUPP", ] def makerepairinstructions(self): diff --git a/Mac/Modules/ctl/Ctlmodule.c b/Mac/Modules/ctl/Ctlmodule.c index 6007220..cd45260 100644 --- a/Mac/Modules/ctl/Ctlmodule.c +++ b/Mac/Modules/ctl/Ctlmodule.c @@ -9,6 +9,9 @@ #include "pymactoolbox.h" #include <Controls.h> +#ifndef kControlCheckBoxUncheckedValue +#include <ControlDefinitions.h> +#endif staticforward PyObject *CtlObj_WhichControl(ControlHandle); @@ -46,6 +49,26 @@ ControlFontStyle_Convert(v, itself) QdRGB_Convert, &itself->backColor); } +/* +** Parse/generate ControlID records +*/ +static PyObject * +PyControlID_New(itself) + ControlID *itself; +{ + + return Py_BuildValue("O&l", PyMac_BuildOSType, itself->signature, itself->id); +} + +static int +PyControlID_Convert(v, itself) + 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; @@ -378,6 +401,55 @@ static PyObject *CtlObj_TestControl(_self, _args) return _res; } +#if TARGET_API_MAC_CARBON + +static PyObject *CtlObj_HandleControlContextualMenuClick(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + Point inWhere; + Boolean menuDisplayed; + 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(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + Point inWhere; + EventModifiers inModifiers; + ClickActivationResult outResult; + 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(_self, _args) ControlObject *_self; PyObject *_args; @@ -386,8 +458,8 @@ static PyObject *CtlObj_HandleControlKey(_self, _args) SInt16 _rv; SInt16 inKeyCode; SInt16 inCharCode; - SInt16 inModifiers; - if (!PyArg_ParseTuple(_args, "hhh", + EventModifiers inModifiers; + if (!PyArg_ParseTuple(_args, "hhH", &inKeyCode, &inCharCode, &inModifiers)) @@ -401,6 +473,32 @@ static PyObject *CtlObj_HandleControlKey(_self, _args) return _res; } +#if TARGET_API_MAC_CARBON + +static PyObject *CtlObj_HandleControlSetCursor(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + Point localPoint; + EventModifiers modifiers; + Boolean cursorWasSet; + 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(_self, _args) ControlObject *_self; PyObject *_args; @@ -694,6 +792,47 @@ static PyObject *CtlObj_IsValidControlHandle(_self, _args) return _res; } +#if TARGET_API_MAC_CARBON + +static PyObject *CtlObj_SetControlID(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + ControlID inID; + 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(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + ControlID outID; + 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(_self, _args) ControlObject *_self; PyObject *_args; @@ -715,6 +854,62 @@ static PyObject *CtlObj_RemoveControlProperty(_self, _args) return _res; } +#if TARGET_API_MAC_CARBON + +static PyObject *CtlObj_GetControlPropertyAttributes(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + OSType propertyCreator; + OSType propertyTag; + UInt32 attributes; + 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(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + OSType propertyCreator; + OSType propertyTag; + UInt32 attributesToSet; + UInt32 attributesToClear; + 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(_self, _args) ControlObject *_self; PyObject *_args; @@ -819,102 +1014,188 @@ static PyObject *CtlObj_SetControlColor(_self, _args) } #endif -#if !TARGET_API_MAC_CARBON +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_GetBevelButtonMenuValue(_self, _args) +static PyObject *CtlObj_EmbedControl(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; - SInt16 outValue; - if (!PyArg_ParseTuple(_args, "")) + ControlHandle inContainer; + if (!PyArg_ParseTuple(_args, "O&", + CtlObj_Convert, &inContainer)) return NULL; - _err = GetBevelButtonMenuValue(_self->ob_itself, - &outValue); + _err = EmbedControl(_self->ob_itself, + inContainer); if (_err != noErr) return PyMac_Error(_err); - _res = Py_BuildValue("h", - outValue); + Py_INCREF(Py_None); + _res = Py_None; return _res; } -#endif - -#if !TARGET_API_MAC_CARBON -static PyObject *CtlObj_SetBevelButtonMenuValue(_self, _args) +static PyObject *CtlObj_AutoEmbedControl(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; - SInt16 inValue; - if (!PyArg_ParseTuple(_args, "h", - &inValue)) + WindowPtr inWindow; + if (!PyArg_ParseTuple(_args, "O&", + WinObj_Convert, &inWindow)) return NULL; - _err = SetBevelButtonMenuValue(_self->ob_itself, - inValue); + _err = AutoEmbedControl(_self->ob_itself, + inWindow); 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_GetBevelButtonMenuHandle(_self, _args) +static PyObject *CtlObj_GetSuperControl(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; - MenuHandle outHandle; + ControlHandle outParent; if (!PyArg_ParseTuple(_args, "")) return NULL; - _err = GetBevelButtonMenuHandle(_self->ob_itself, - &outHandle); + _err = GetSuperControl(_self->ob_itself, + &outParent); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("O&", - MenuObj_New, outHandle); + CtlObj_WhichControl, outParent); return _res; } -#endif -#if !TARGET_API_MAC_CARBON +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_SetBevelButtonTransform(_self, _args) +static PyObject *CtlObj_GetIndexedSubControl(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; - IconTransformType transform; - if (!PyArg_ParseTuple(_args, "h", - &transform)) + UInt16 inIndex; + ControlHandle outSubControl; + if (!PyArg_ParseTuple(_args, "H", + &inIndex)) return NULL; - _err = SetBevelButtonTransform(_self->ob_itself, - transform); + _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; } -#endif -#if !TARGET_API_MAC_CARBON +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_SetImageWellTransform(_self, _args) +static PyObject *CtlObj_GetControlDataSize(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; - IconTransformType inTransform; - if (!PyArg_ParseTuple(_args, "h", - &inTransform)) + ControlPartCode inPart; + ResType inTagName; + Size outMaxSize; + if (!PyArg_ParseTuple(_args, "hO&", + &inPart, + PyMac_GetOSType, &inTagName)) return NULL; - _err = SetImageWellTransform(_self->ob_itself, - inTransform); + _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_SetControlDragTrackingEnabled(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + Boolean tracks; + 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; @@ -922,236 +1203,365 @@ static PyObject *CtlObj_SetImageWellTransform(_self, _args) } #endif -#if !TARGET_API_MAC_CARBON +#if TARGET_API_MAC_CARBON -static PyObject *CtlObj_GetTabContentRect(_self, _args) +static PyObject *CtlObj_IsControlDragTrackingEnabled(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; - OSErr _err; - Rect outContentRect; + OSStatus _err; + Boolean tracks; if (!PyArg_ParseTuple(_args, "")) return NULL; - _err = GetTabContentRect(_self->ob_itself, - &outContentRect); + _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(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Rect _rv; + Rect bounds; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetControlBounds(_self->ob_itself, + &bounds); + _res = Py_BuildValue("O&O&", + PyMac_BuildRect, &_rv, + PyMac_BuildRect, &bounds); + return _res; +} +#endif + +#if ACCESSOR_CALLS_ARE_FUNCTIONS + +static PyObject *CtlObj_IsControlHilited(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Boolean _rv; + 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(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + UInt16 _rv; + 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(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + WindowPtr _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetControlOwner(_self->ob_itself); _res = Py_BuildValue("O&", - PyMac_BuildRect, &outContentRect); + WinObj_New, _rv); return _res; } #endif -#if !TARGET_API_MAC_CARBON +#if ACCESSOR_CALLS_ARE_FUNCTIONS -static PyObject *CtlObj_SetTabEnabled(_self, _args) +static PyObject *CtlObj_GetControlDataHandle(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; - OSErr _err; - SInt16 inTabToHilite; - Boolean inEnabled; - if (!PyArg_ParseTuple(_args, "hb", - &inTabToHilite, - &inEnabled)) + Handle _rv; + if (!PyArg_ParseTuple(_args, "")) return NULL; - _err = SetTabEnabled(_self->ob_itself, - inTabToHilite, - inEnabled); - if (_err != noErr) return PyMac_Error(_err); - Py_INCREF(Py_None); - _res = Py_None; + _rv = GetControlDataHandle(_self->ob_itself); + _res = Py_BuildValue("O&", + ResObj_New, _rv); return _res; } #endif -#if !TARGET_API_MAC_CARBON +#if ACCESSOR_CALLS_ARE_FUNCTIONS -static PyObject *CtlObj_SetDisclosureTriangleLastValue(_self, _args) +static PyObject *CtlObj_GetControlPopupMenuHandle(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; - OSErr _err; - SInt16 inValue; - if (!PyArg_ParseTuple(_args, "h", - &inValue)) + MenuHandle _rv; + if (!PyArg_ParseTuple(_args, "")) return NULL; - _err = SetDisclosureTriangleLastValue(_self->ob_itself, - inValue); - if (_err != noErr) return PyMac_Error(_err); - Py_INCREF(Py_None); - _res = Py_None; + _rv = GetControlPopupMenuHandle(_self->ob_itself); + _res = Py_BuildValue("O&", + MenuObj_New, _rv); return _res; } #endif -static PyObject *CtlObj_SendControlMessage(_self, _args) +#if ACCESSOR_CALLS_ARE_FUNCTIONS + +static PyObject *CtlObj_GetControlPopupMenuID(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; - SInt32 _rv; - SInt16 inMessage; - SInt32 inParam; - if (!PyArg_ParseTuple(_args, "hl", - &inMessage, - &inParam)) + short _rv; + if (!PyArg_ParseTuple(_args, "")) return NULL; - _rv = SendControlMessage(_self->ob_itself, - inMessage, - inParam); - _res = Py_BuildValue("l", + _rv = GetControlPopupMenuID(_self->ob_itself); + _res = Py_BuildValue("h", _rv); return _res; } +#endif -static PyObject *CtlObj_EmbedControl(_self, _args) +#if ACCESSOR_CALLS_ARE_FUNCTIONS + +static PyObject *CtlObj_SetControlDataHandle(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; - OSErr _err; - ControlHandle inContainer; + Handle dataHandle; if (!PyArg_ParseTuple(_args, "O&", - CtlObj_Convert, &inContainer)) + ResObj_Convert, &dataHandle)) return NULL; - _err = EmbedControl(_self->ob_itself, - inContainer); - if (_err != noErr) return PyMac_Error(_err); + SetControlDataHandle(_self->ob_itself, + dataHandle); Py_INCREF(Py_None); _res = Py_None; return _res; } +#endif -static PyObject *CtlObj_AutoEmbedControl(_self, _args) +#if ACCESSOR_CALLS_ARE_FUNCTIONS + +static PyObject *CtlObj_SetControlBounds(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; - OSErr _err; - WindowPtr inWindow; + Rect bounds; if (!PyArg_ParseTuple(_args, "O&", - WinObj_Convert, &inWindow)) + PyMac_GetRect, &bounds)) return NULL; - _err = AutoEmbedControl(_self->ob_itself, - inWindow); - if (_err != noErr) return PyMac_Error(_err); + SetControlBounds(_self->ob_itself, + &bounds); Py_INCREF(Py_None); _res = Py_None; return _res; } +#endif -static PyObject *CtlObj_GetSuperControl(_self, _args) +#if ACCESSOR_CALLS_ARE_FUNCTIONS + +static PyObject *CtlObj_SetControlPopupMenuHandle(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + MenuHandle popupMenu; + 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(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + short menuID; + 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(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; - ControlHandle outParent; + SInt16 outValue; if (!PyArg_ParseTuple(_args, "")) return NULL; - _err = GetSuperControl(_self->ob_itself, - &outParent); + _err = GetBevelButtonMenuValue(_self->ob_itself, + &outValue); if (_err != noErr) return PyMac_Error(_err); - _res = Py_BuildValue("O&", - CtlObj_WhichControl, outParent); + _res = Py_BuildValue("h", + outValue); return _res; } -static PyObject *CtlObj_CountSubControls(_self, _args) +static PyObject *CtlObj_SetBevelButtonMenuValue(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; - UInt16 outNumChildren; - if (!PyArg_ParseTuple(_args, "")) + SInt16 inValue; + if (!PyArg_ParseTuple(_args, "h", + &inValue)) return NULL; - _err = CountSubControls(_self->ob_itself, - &outNumChildren); + _err = SetBevelButtonMenuValue(_self->ob_itself, + inValue); if (_err != noErr) return PyMac_Error(_err); - _res = Py_BuildValue("H", - outNumChildren); + Py_INCREF(Py_None); + _res = Py_None; return _res; } -static PyObject *CtlObj_GetIndexedSubControl(_self, _args) +static PyObject *CtlObj_GetBevelButtonMenuHandle(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; - UInt16 inIndex; - ControlHandle outSubControl; - if (!PyArg_ParseTuple(_args, "H", - &inIndex)) + MenuHandle outHandle; + if (!PyArg_ParseTuple(_args, "")) return NULL; - _err = GetIndexedSubControl(_self->ob_itself, - inIndex, - &outSubControl); + _err = GetBevelButtonMenuHandle(_self->ob_itself, + &outHandle); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("O&", - CtlObj_WhichControl, outSubControl); + MenuObj_New, outHandle); return _res; } -static PyObject *CtlObj_SetControlSupervisor(_self, _args) +static PyObject *CtlObj_SetBevelButtonTransform(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; - ControlHandle inBoss; - if (!PyArg_ParseTuple(_args, "O&", - CtlObj_Convert, &inBoss)) + IconTransformType transform; + if (!PyArg_ParseTuple(_args, "h", + &transform)) return NULL; - _err = SetControlSupervisor(_self->ob_itself, - inBoss); + _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_GetControlFeatures(_self, _args) +static PyObject *CtlObj_SetDisclosureTriangleLastValue(_self, _args) ControlObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; - UInt32 outFeatures; + SInt16 inValue; + 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(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + Rect outContentRect; if (!PyArg_ParseTuple(_args, "")) return NULL; - _err = GetControlFeatures(_self->ob_itself, - &outFeatures); + _err = GetTabContentRect(_self->ob_itself, + &outContentRect); if (_err != noErr) return PyMac_Error(_err); - _res = Py_BuildValue("l", - outFeatures); + _res = Py_BuildValue("O&", + PyMac_BuildRect, &outContentRect); return _res; } -static PyObject *CtlObj_GetControlDataSize(_self, _args) +static PyObject *CtlObj_SetTabEnabled(_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)) + SInt16 inTabToHilite; + Boolean inEnabled; + if (!PyArg_ParseTuple(_args, "hb", + &inTabToHilite, + &inEnabled)) return NULL; - _err = GetControlDataSize(_self->ob_itself, - inPart, - inTagName, - &outMaxSize); + _err = SetTabEnabled(_self->ob_itself, + inTabToHilite, + inEnabled); if (_err != noErr) return PyMac_Error(_err); - _res = Py_BuildValue("l", - outMaxSize); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CtlObj_SetImageWellTransform(_self, _args) + ControlObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + IconTransformType inTransform; + 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; } @@ -1540,8 +1950,23 @@ static PyMethodDef CtlObj_methods[] = { "(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, SInt16 inModifiers) -> (SInt16 _rv)"}, + "(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, @@ -1580,8 +2005,28 @@ static PyMethodDef CtlObj_methods[] = { "(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, @@ -1600,46 +2045,6 @@ static PyMethodDef CtlObj_methods[] = { {"SetControlColor", (PyCFunction)CtlObj_SetControlColor, 1, "(CCTabHandle newColorTable) -> None"}, #endif - -#if !TARGET_API_MAC_CARBON - {"GetBevelButtonMenuValue", (PyCFunction)CtlObj_GetBevelButtonMenuValue, 1, - "() -> (SInt16 outValue)"}, -#endif - -#if !TARGET_API_MAC_CARBON - {"SetBevelButtonMenuValue", (PyCFunction)CtlObj_SetBevelButtonMenuValue, 1, - "(SInt16 inValue) -> None"}, -#endif - -#if !TARGET_API_MAC_CARBON - {"GetBevelButtonMenuHandle", (PyCFunction)CtlObj_GetBevelButtonMenuHandle, 1, - "() -> (MenuHandle outHandle)"}, -#endif - -#if !TARGET_API_MAC_CARBON - {"SetBevelButtonTransform", (PyCFunction)CtlObj_SetBevelButtonTransform, 1, - "(IconTransformType transform) -> None"}, -#endif - -#if !TARGET_API_MAC_CARBON - {"SetImageWellTransform", (PyCFunction)CtlObj_SetImageWellTransform, 1, - "(IconTransformType inTransform) -> None"}, -#endif - -#if !TARGET_API_MAC_CARBON - {"GetTabContentRect", (PyCFunction)CtlObj_GetTabContentRect, 1, - "() -> (Rect outContentRect)"}, -#endif - -#if !TARGET_API_MAC_CARBON - {"SetTabEnabled", (PyCFunction)CtlObj_SetTabEnabled, 1, - "(SInt16 inTabToHilite, Boolean inEnabled) -> None"}, -#endif - -#if !TARGET_API_MAC_CARBON - {"SetDisclosureTriangleLastValue", (PyCFunction)CtlObj_SetDisclosureTriangleLastValue, 1, - "(SInt16 inValue) -> None"}, -#endif {"SendControlMessage", (PyCFunction)CtlObj_SendControlMessage, 1, "(SInt16 inMessage, SInt32 inParam) -> (SInt32 _rv)"}, {"EmbedControl", (PyCFunction)CtlObj_EmbedControl, 1, @@ -1658,6 +2063,87 @@ static PyMethodDef CtlObj_methods[] = { "() -> (UInt32 outFeatures)"}, {"GetControlDataSize", (PyCFunction)CtlObj_GetControlDataSize, 1, "(ControlPartCode inPart, ResType inTagName) -> (Size outMaxSize)"}, + +#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 _rv, 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, @@ -1906,6 +2392,31 @@ static PyObject *Ctl_IdleControls(_self, _args) return _res; } +#if TARGET_API_MAC_CARBON + +static PyObject *Ctl_GetControlByID(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + WindowPtr inWindow; + ControlID inID; + ControlHandle outControl; + 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(_self, _args) PyObject *_self; PyObject *_args; @@ -2057,6 +2568,51 @@ static PyObject *Ctl_ClearKeyboardFocus(_self, _args) return _res; } +#if TARGET_API_MAC_CARBON + +static PyObject *Ctl_SetAutomaticControlDragTrackingEnabledForWindow(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + WindowPtr theWindow; + Boolean tracks; + 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(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + WindowPtr theWindow; + Boolean tracks; + 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(_self, _args) PyObject *_self; PyObject *_args; @@ -2088,6 +2644,11 @@ static PyMethodDef Ctl_methods[] = { "(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, @@ -2104,6 +2665,16 @@ static PyMethodDef Ctl_methods[] = { "(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} @@ -2320,7 +2891,7 @@ void initCtl() Ctl_Error = PyMac_GetOSErrException(); if (Ctl_Error == NULL || PyDict_SetItemString(d, "Error", Ctl_Error) != 0) - Py_FatalError("can't initialize Ctl.Error"); + return; Control_Type.ob_type = &PyType_Type; Py_INCREF(&Control_Type); if (PyDict_SetItemString(d, "ControlType", (PyObject *)&Control_Type) != 0) diff --git a/Mac/Modules/ctl/ctlscan.py b/Mac/Modules/ctl/ctlscan.py index 9f9b20b..709fa10 100644 --- a/Mac/Modules/ctl/ctlscan.py +++ b/Mac/Modules/ctl/ctlscan.py @@ -8,7 +8,8 @@ from scantools import Scanner from bgenlocations import TOOLBOXDIR def main(): - input = "Controls.h" +# input = "Controls.h" # Universal Headers < 3.3 + input = ["Controls.h", "ControlDefinitions.h"] # Universal Headers >= 3.3 output = "ctlgen.py" defsoutput = TOOLBOXDIR + "Controls.py" scanner = MyScanner(input, output, defsoutput) @@ -85,14 +86,43 @@ class MyScanner(Scanner): 'GetAuxiliaryControlRecord', 'SetControlColor', # These have suddenly disappeared in UH 3.3.2... - 'GetBevelButtonMenuValue', - 'SetBevelButtonMenuValue', - 'GetBevelButtonMenuHandle', - 'SetBevelButtonTransform', - 'SetImageWellTransform', - 'GetTabContentRect', - 'SetTabEnabled', - 'SetDisclosureTriangleLastValue', +## 'GetBevelButtonMenuValue', +## 'SetBevelButtonMenuValue', +## 'GetBevelButtonMenuHandle', +## 'SetBevelButtonTransform', +## 'SetImageWellTransform', +## 'GetTabContentRect', +## 'SetTabEnabled', +## 'SetDisclosureTriangleLastValue', + ]), + ('#if TARGET_API_MAC_CARBON', [ + 'IsAutomaticControlDragTrackingEnabledForWindow', + 'SetAutomaticControlDragTrackingEnabledForWindow', + 'GetControlByID', + 'IsControlDragTrackingEnabled', + 'SetControlDragTrackingEnabled', + 'GetControlPropertyAttributes', + 'ChangeControlPropertyAttributes', + 'GetControlID', + 'SetControlID', + 'HandleControlSetCursor', + 'GetControlClickActivation', + 'HandleControlContextualMenuClick', + ]), + ('#if ACCESSOR_CALLS_ARE_FUNCTIONS', [ + # XXX These are silly, they should be #defined to access the fields + # directly. Later... + 'GetControlBounds', + 'IsControlHilited', + 'GetControlHilite', + 'GetControlOwner', + 'GetControlDataHandle', + 'GetControlPopupMenuHandle', + 'GetControlPopupMenuID', + 'SetControlDataHandle', + 'SetControlBounds', + 'SetControlPopupMenuHandle', + 'SetControlPopupMenuID', ])] def makeblacklisttypes(self): @@ -101,6 +131,11 @@ class MyScanner(Scanner): 'ControlActionUPP', 'ControlButtonContentInfoPtr', 'Ptr', + 'ControlDefSpec', # Don't know how to do this yet + 'ControlDefSpec_ptr', # ditto + 'Collection', # Ditto + 'DragTrackingMessage', # Needs Drag module, must implement later + 'DragReference', # ditto ] def makerepairinstructions(self): diff --git a/Mac/Modules/ctl/ctlsupport.py b/Mac/Modules/ctl/ctlsupport.py index 064e1c5..ab2a999 100644 --- a/Mac/Modules/ctl/ctlsupport.py +++ b/Mac/Modules/ctl/ctlsupport.py @@ -32,6 +32,8 @@ ControlPartCode = Type("ControlPartCode", "h") DragConstraint = Type("DragConstraint", "H") ControlVariant = Type("ControlVariant", "h") IconTransformType = Type("IconTransformType", "h") +EventModifiers = Type("EventModifiers", "H") +ClickActivationResult = Type("ClickActivationResult", "l") ControlButtonGraphicAlignment = Type("ControlButtonGraphicAlignment", "h") ControlButtonTextAlignment = Type("ControlButtonTextAlignment", "h") ControlButtonTextPlacement = Type("ControlButtonTextPlacement", "h") @@ -40,9 +42,14 @@ ControlFocusPart = Type("ControlFocusPart", "h") ControlFontStyleRec = OpaqueType('ControlFontStyleRec', 'ControlFontStyle') ControlFontStyleRec_ptr = ControlFontStyleRec +ControlID = OpaqueType('ControlID', 'PyControlID') +ControlID_ptr = ControlID includestuff = includestuff + """ #include <%s>""" % MACHEADERFILE + """ +#ifndef kControlCheckBoxUncheckedValue +#include <ControlDefinitions.h> +#endif staticforward PyObject *CtlObj_WhichControl(ControlHandle); @@ -80,6 +87,26 @@ ControlFontStyle_Convert(v, itself) QdRGB_Convert, &itself->backColor); } +/* +** Parse/generate ControlID records +*/ +static PyObject * +PyControlID_New(itself) + ControlID *itself; +{ + + return Py_BuildValue("O&l", PyMac_BuildOSType, itself->signature, itself->id); +} + +static int +PyControlID_Convert(v, itself) + 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; diff --git a/Mac/Modules/dlg/Dlgmodule.c b/Mac/Modules/dlg/Dlgmodule.c index b686839..3ab14a0 100644 --- a/Mac/Modules/dlg/Dlgmodule.c +++ b/Mac/Modules/dlg/Dlgmodule.c @@ -10,6 +10,13 @@ #include <Dialogs.h> +#if !ACCESSOR_CALLS_ARE_FUNCTIONS +#define GetDialogTextEditHandle(dlg) (((DialogPeek)(dlg))->textH) +#define SetPortDialogPort(dlg) SetPort(dlg) +#define GetDialogPort(dlg) ((CGrafPtr)(dlg)) +#define GetDialogFromWindow(win) ((DialogRef)(win)) +#endif + /* XXX Shouldn't this be a stack? */ static PyObject *Dlg_FilterProc_callback = NULL; @@ -399,6 +406,63 @@ static PyObject *DlgObj_ShortenDITL(_self, _args) return _res; } +#if TARGET_API_MAC_CARBON + +static PyObject *DlgObj_InsertDialogItem(_self, _args) + DialogObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + DialogItemIndex afterItem; + DialogItemType itemType; + Handle itemHandle; + Rect box; + if (!PyArg_ParseTuple(_args, "hhO&O&", + &afterItem, + &itemType, + ResObj_Convert, &itemHandle, + PyMac_GetRect, &box)) + return NULL; + _err = InsertDialogItem(_self->ob_itself, + afterItem, + itemType, + itemHandle, + &box); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *DlgObj_RemoveDialogItems(_self, _args) + DialogObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + DialogItemIndex itemNo; + DialogItemIndex amountToRemove; + Boolean disposeItemData; + if (!PyArg_ParseTuple(_args, "hhb", + &itemNo, + &amountToRemove, + &disposeItemData)) + return NULL; + _err = RemoveDialogItems(_self->ob_itself, + itemNo, + amountToRemove, + disposeItemData); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} +#endif + static PyObject *DlgObj_StdFilterProc(_self, _args) DialogObject *_self; PyObject *_args; @@ -666,7 +730,21 @@ static PyObject *DlgObj_GetDialogWindow(_self, _args) return NULL; _rv = GetDialogWindow(_self->ob_itself); _res = Py_BuildValue("O&", - WinObj_WhichWindow, _rv); + WinObj_New, _rv); + return _res; +} + +static PyObject *DlgObj_GetDialogTextEditHandle(_self, _args) + DialogObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TEHandle _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetDialogTextEditHandle(_self->ob_itself); + _res = Py_BuildValue("O&", + ResObj_New, _rv); return _res; } @@ -712,6 +790,33 @@ static PyObject *DlgObj_GetDialogKeyboardFocusItem(_self, _args) return _res; } +static PyObject *DlgObj_SetPortDialogPort(_self, _args) + DialogObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + SetPortDialogPort(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *DlgObj_GetDialogPort(_self, _args) + DialogObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + CGrafPtr _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetDialogPort(_self->ob_itself); + _res = Py_BuildValue("O&", + GrafObj_New, _rv); + return _res; +} + #if !TARGET_API_MAC_CARBON static PyObject *DlgObj_SetGrafPortOfDialog(_self, _args) @@ -759,6 +864,16 @@ static PyMethodDef DlgObj_methods[] = { "() -> (DialogItemIndex _rv)"}, {"ShortenDITL", (PyCFunction)DlgObj_ShortenDITL, 1, "(DialogItemIndex numberItems) -> None"}, + +#if TARGET_API_MAC_CARBON + {"InsertDialogItem", (PyCFunction)DlgObj_InsertDialogItem, 1, + "(DialogItemIndex afterItem, DialogItemType itemType, Handle itemHandle, Rect box) -> None"}, +#endif + +#if TARGET_API_MAC_CARBON + {"RemoveDialogItems", (PyCFunction)DlgObj_RemoveDialogItems, 1, + "(DialogItemIndex itemNo, DialogItemIndex amountToRemove, Boolean disposeItemData) -> None"}, +#endif {"StdFilterProc", (PyCFunction)DlgObj_StdFilterProc, 1, "() -> (Boolean _rv, EventRecord event, DialogItemIndex itemHit)"}, {"SetDialogDefaultItem", (PyCFunction)DlgObj_SetDialogDefaultItem, 1, @@ -787,12 +902,18 @@ static PyMethodDef DlgObj_methods[] = { "() -> (EventMask outMask)"}, {"GetDialogWindow", (PyCFunction)DlgObj_GetDialogWindow, 1, "() -> (WindowPtr _rv)"}, + {"GetDialogTextEditHandle", (PyCFunction)DlgObj_GetDialogTextEditHandle, 1, + "() -> (TEHandle _rv)"}, {"GetDialogDefaultItem", (PyCFunction)DlgObj_GetDialogDefaultItem, 1, "() -> (SInt16 _rv)"}, {"GetDialogCancelItem", (PyCFunction)DlgObj_GetDialogCancelItem, 1, "() -> (SInt16 _rv)"}, {"GetDialogKeyboardFocusItem", (PyCFunction)DlgObj_GetDialogKeyboardFocusItem, 1, "() -> (SInt16 _rv)"}, + {"SetPortDialogPort", (PyCFunction)DlgObj_SetPortDialogPort, 1, + "() -> None"}, + {"GetDialogPort", (PyCFunction)DlgObj_GetDialogPort, 1, + "() -> (CGrafPtr _rv)"}, #if !TARGET_API_MAC_CARBON {"SetGrafPortOfDialog", (PyCFunction)DlgObj_SetGrafPortOfDialog, 1, @@ -1168,6 +1289,33 @@ static PyObject *Dlg_ResetAlertStage(_self, _args) return _res; } +#if TARGET_API_MAC_CARBON + +static PyObject *Dlg_GetParamText(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Str255 param0; + Str255 param1; + Str255 param2; + Str255 param3; + if (!PyArg_ParseTuple(_args, "O&O&O&O&", + PyMac_GetStr255, param0, + PyMac_GetStr255, param1, + PyMac_GetStr255, param2, + PyMac_GetStr255, param3)) + return NULL; + GetParamText(param0, + param1, + param2, + param3); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} +#endif + static PyObject *Dlg_NewFeaturesDialog(_self, _args) PyObject *_self; PyObject *_args; @@ -1209,6 +1357,22 @@ static PyObject *Dlg_NewFeaturesDialog(_self, _args) return _res; } +static PyObject *Dlg_GetDialogFromWindow(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + DialogPtr _rv; + WindowPtr window; + if (!PyArg_ParseTuple(_args, "O&", + WinObj_Convert, &window)) + return NULL; + _rv = GetDialogFromWindow(window); + _res = Py_BuildValue("O&", + DlgObj_New, _rv); + return _res; +} + static PyObject *Dlg_SetUserItemHandler(_self, _args) PyObject *_self; PyObject *_args; @@ -1273,8 +1437,15 @@ static PyMethodDef Dlg_methods[] = { "(SInt16 fontNum) -> None"}, {"ResetAlertStage", (PyCFunction)Dlg_ResetAlertStage, 1, "() -> None"}, + +#if TARGET_API_MAC_CARBON + {"GetParamText", (PyCFunction)Dlg_GetParamText, 1, + "(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None"}, +#endif {"NewFeaturesDialog", (PyCFunction)Dlg_NewFeaturesDialog, 1, "(Rect inBoundsRect, Str255 inTitle, Boolean inIsVisible, SInt16 inProcID, WindowPtr inBehind, Boolean inGoAwayFlag, SInt32 inRefCon, Handle inItemListHandle, UInt32 inFlags) -> (DialogPtr _rv)"}, + {"GetDialogFromWindow", (PyCFunction)Dlg_GetDialogFromWindow, 1, + "(WindowPtr window) -> (DialogPtr _rv)"}, {"SetUserItemHandler", (PyCFunction)Dlg_SetUserItemHandler, 1, NULL}, {NULL, NULL, 0} @@ -1282,6 +1453,17 @@ static PyMethodDef Dlg_methods[] = { +/* Return the WindowPtr corresponding to a DialogObject */ + +WindowPtr +DlgObj_ConvertToWindow(self) + PyObject *self; +{ + if ( DlgObj_Check(self) ) + return GetDialogWindow(((DialogObject *)self)->ob_itself); + return NULL; +} + void initDlg() { @@ -1296,7 +1478,7 @@ void initDlg() Dlg_Error = PyMac_GetOSErrException(); if (Dlg_Error == NULL || PyDict_SetItemString(d, "Error", Dlg_Error) != 0) - Py_FatalError("can't initialize Dlg.Error"); + return; Dialog_Type.ob_type = &PyType_Type; Py_INCREF(&Dialog_Type); if (PyDict_SetItemString(d, "DialogType", (PyObject *)&Dialog_Type) != 0) diff --git a/Mac/Modules/dlg/dlgscan.py b/Mac/Modules/dlg/dlgscan.py index 3092dec..549d0b3 100644 --- a/Mac/Modules/dlg/dlgscan.py +++ b/Mac/Modules/dlg/dlgscan.py @@ -59,11 +59,18 @@ class MyScanner(Scanner): return [ ('#if !TARGET_API_MAC_CARBON', [ 'SetGrafPortOfDialog', + ]), + ('#if TARGET_API_MAC_CARBON', [ + 'InsertDialogItem', + 'RemoveDialogItems', + 'GetParamText', ])] def makeblacklisttypes(self): return [ "AlertStdAlertParamPtr", # Too much work, for now + "AlertStdAlertParamRec", # ditto + "AlertStdAlertParamRec_ptr", # ditto "QTModelessCallbackProcPtr", ] diff --git a/Mac/Modules/dlg/dlgsupport.py b/Mac/Modules/dlg/dlgsupport.py index f243cc1..e537c66 100644 --- a/Mac/Modules/dlg/dlgsupport.py +++ b/Mac/Modules/dlg/dlgsupport.py @@ -19,6 +19,8 @@ ModalFilterProcPtr.passInput = lambda name: "NewModalFilterProc(Dlg_PassFilterPr ModalFilterUPP = ModalFilterProcPtr RgnHandle = OpaqueByValueType("RgnHandle", "ResObj") +TEHandle = OpaqueByValueType("TEHandle", "ResObj") +CGrafPtr = OpaqueByValueType("CGrafPtr", "GrafObj") DITLMethod = Type("DITLMethod", "h") DialogItemIndex = Type("DialogItemIndex", "h") @@ -31,6 +33,13 @@ EventMask = Type("EventMask", "H") includestuff = includestuff + """ #include <Dialogs.h> +#if !ACCESSOR_CALLS_ARE_FUNCTIONS +#define GetDialogTextEditHandle(dlg) (((DialogPeek)(dlg))->textH) +#define SetPortDialogPort(dlg) SetPort(dlg) +#define GetDialogPort(dlg) ((CGrafPtr)(dlg)) +#define GetDialogFromWindow(win) ((DialogRef)(win)) +#endif + /* XXX Shouldn't this be a stack? */ static PyObject *Dlg_FilterProc_callback = NULL; @@ -178,14 +187,14 @@ for f in methods: object.add(f) # Some methods that are currently macro's in C, but will be real routines # in MacOS 8. -f = Method(ExistingWindowPtr, 'GetDialogWindow', (DialogRef, 'dialog', InMode)) -object.add(f) -f = Method(SInt16, 'GetDialogDefaultItem', (DialogRef, 'dialog', InMode)) -object.add(f) -f = Method(SInt16, 'GetDialogCancelItem', (DialogRef, 'dialog', InMode)) -object.add(f) -f = Method(SInt16, 'GetDialogKeyboardFocusItem', (DialogRef, 'dialog', InMode)) -object.add(f) +##f = Method(ExistingWindowPtr, 'GetDialogWindow', (DialogRef, 'dialog', InMode)) +##object.add(f) +##f = Method(SInt16, 'GetDialogDefaultItem', (DialogRef, 'dialog', InMode)) +##object.add(f) +##f = Method(SInt16, 'GetDialogCancelItem', (DialogRef, 'dialog', InMode)) +##object.add(f) +##f = Method(SInt16, 'GetDialogKeyboardFocusItem', (DialogRef, 'dialog', InMode)) +##object.add(f) f = Method(void, 'SetGrafPortOfDialog', (DialogRef, 'dialog', InMode), condition='#if !TARGET_API_MAC_CARBON') object.add(f) diff --git a/Mac/Modules/drag/Dragmodule.c b/Mac/Modules/drag/Dragmodule.c index 716d2d5..e3801b6 100644 --- a/Mac/Modules/drag/Dragmodule.c +++ b/Mac/Modules/drag/Dragmodule.c @@ -29,12 +29,12 @@ PyTypeObject DragObj_Type; typedef struct DragObjObject { PyObject_HEAD - DragReference ob_itself; + DragRef ob_itself; PyObject *sendproc; } DragObjObject; PyObject *DragObj_New(itself) - DragReference itself; + DragRef itself; { DragObjObject *it; if (itself == NULL) { @@ -49,7 +49,7 @@ PyObject *DragObj_New(itself) } DragObj_Convert(v, p_itself) PyObject *v; - DragReference *p_itself; + DragRef *p_itself; { if (!DragObj_Check(v)) { @@ -67,41 +67,104 @@ static void DragObj_dealloc(self) PyMem_DEL(self); } -static PyObject *DragObj_DisposeDrag(_self, _args) - DragObjObject *_self; +static PyMethodDef DragObj_methods[] = { + {NULL, NULL, 0} +}; + +PyMethodChain DragObj_chain = { DragObj_methods, NULL }; + +static PyObject *DragObj_getattr(self, name) + DragObjObject *self; + char *name; +{ + return Py_FindMethodInChain(&DragObj_chain, (PyObject *)self, name); +} + +#define DragObj_setattr NULL + +#define DragObj_compare NULL + +#define DragObj_repr NULL + +#define DragObj_hash NULL + +PyTypeObject DragObj_Type = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "DragObj", /*tp_name*/ + sizeof(DragObjObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) DragObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc) DragObj_getattr, /*tp_getattr*/ + (setattrfunc) DragObj_setattr, /*tp_setattr*/ + (cmpfunc) DragObj_compare, /*tp_compare*/ + (reprfunc) DragObj_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) DragObj_hash, /*tp_hash*/ +}; + +/* -------------------- End object type DragObj --------------------- */ + + +static PyObject *Drag_NewDrag(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; if (!PyArg_ParseTuple(_args, "")) return NULL; - _err = DisposeDrag(_self->ob_itself); + _err = NewDrag(&theDrag); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + DragObj_New, theDrag); + return _res; +} + +static PyObject *Drag_DisposeDrag(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + DragRef theDrag; + if (!PyArg_ParseTuple(_args, "O&", + DragObj_Convert, &theDrag)) + return NULL; + _err = DisposeDrag(theDrag); if (_err != noErr) return PyMac_Error(_err); Py_INCREF(Py_None); _res = Py_None; return _res; } -static PyObject *DragObj_AddDragItemFlavor(_self, _args) - DragObjObject *_self; +static PyObject *Drag_AddDragItemFlavor(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; ItemReference theItemRef; FlavorType theType; char *dataPtr__in__; long dataPtr__len__; int dataPtr__in_len__; FlavorFlags theFlags; - if (!PyArg_ParseTuple(_args, "lO&z#l", + if (!PyArg_ParseTuple(_args, "O&lO&z#l", + DragObj_Convert, &theDrag, &theItemRef, PyMac_GetOSType, &theType, &dataPtr__in__, &dataPtr__in_len__, &theFlags)) return NULL; dataPtr__len__ = dataPtr__in_len__; - _err = AddDragItemFlavor(_self->ob_itself, + _err = AddDragItemFlavor(theDrag, theItemRef, theType, dataPtr__in__, dataPtr__len__, @@ -113,26 +176,28 @@ static PyObject *DragObj_AddDragItemFlavor(_self, _args) return _res; } -static PyObject *DragObj_SetDragItemFlavorData(_self, _args) - DragObjObject *_self; +static PyObject *Drag_SetDragItemFlavorData(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; ItemReference theItemRef; FlavorType theType; char *dataPtr__in__; long dataPtr__len__; int dataPtr__in_len__; UInt32 dataOffset; - if (!PyArg_ParseTuple(_args, "lO&z#l", + if (!PyArg_ParseTuple(_args, "O&lO&z#l", + DragObj_Convert, &theDrag, &theItemRef, PyMac_GetOSType, &theType, &dataPtr__in__, &dataPtr__in_len__, &dataOffset)) return NULL; dataPtr__len__ = dataPtr__in_len__; - _err = SetDragItemFlavorData(_self->ob_itself, + _err = SetDragItemFlavorData(theDrag, theItemRef, theType, dataPtr__in__, dataPtr__len__, @@ -144,23 +209,25 @@ static PyObject *DragObj_SetDragItemFlavorData(_self, _args) return _res; } -static PyObject *DragObj_SetDragImage(_self, _args) - DragObjObject *_self; +static PyObject *Drag_SetDragImage(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; PixMapHandle imagePixMap; RgnHandle imageRgn; Point imageOffsetPt; DragImageFlags theImageFlags; - if (!PyArg_ParseTuple(_args, "O&O&O&l", + if (!PyArg_ParseTuple(_args, "O&O&O&O&l", + DragObj_Convert, &theDrag, ResObj_Convert, &imagePixMap, ResObj_Convert, &imageRgn, PyMac_GetPoint, &imageOffsetPt, &theImageFlags)) return NULL; - _err = SetDragImage(_self->ob_itself, + _err = SetDragImage(theDrag, imagePixMap, imageRgn, imageOffsetPt, @@ -171,19 +238,44 @@ static PyObject *DragObj_SetDragImage(_self, _args) return _res; } -static PyObject *DragObj_TrackDrag(_self, _args) - DragObjObject *_self; +static PyObject *Drag_ChangeDragBehaviors(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + DragRef theDrag; + DragBehaviors inBehaviorsToSet; + DragBehaviors inBehaviorsToClear; + if (!PyArg_ParseTuple(_args, "O&ll", + DragObj_Convert, &theDrag, + &inBehaviorsToSet, + &inBehaviorsToClear)) + return NULL; + _err = ChangeDragBehaviors(theDrag, + inBehaviorsToSet, + inBehaviorsToClear); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Drag_TrackDrag(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; EventRecord theEvent; RgnHandle theRegion; - if (!PyArg_ParseTuple(_args, "O&O&", + if (!PyArg_ParseTuple(_args, "O&O&O&", + DragObj_Convert, &theDrag, PyMac_GetEventRecord, &theEvent, ResObj_Convert, &theRegion)) return NULL; - _err = TrackDrag(_self->ob_itself, + _err = TrackDrag(theDrag, &theEvent, theRegion); if (_err != noErr) return PyMac_Error(_err); @@ -192,16 +284,18 @@ static PyObject *DragObj_TrackDrag(_self, _args) return _res; } -static PyObject *DragObj_CountDragItems(_self, _args) - DragObjObject *_self; +static PyObject *Drag_CountDragItems(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; UInt16 numItems; - if (!PyArg_ParseTuple(_args, "")) + if (!PyArg_ParseTuple(_args, "O&", + DragObj_Convert, &theDrag)) return NULL; - _err = CountDragItems(_self->ob_itself, + _err = CountDragItems(theDrag, &numItems); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("H", @@ -209,18 +303,20 @@ static PyObject *DragObj_CountDragItems(_self, _args) return _res; } -static PyObject *DragObj_GetDragItemReferenceNumber(_self, _args) - DragObjObject *_self; +static PyObject *Drag_GetDragItemReferenceNumber(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; UInt16 index; ItemReference theItemRef; - if (!PyArg_ParseTuple(_args, "H", + if (!PyArg_ParseTuple(_args, "O&H", + DragObj_Convert, &theDrag, &index)) return NULL; - _err = GetDragItemReferenceNumber(_self->ob_itself, + _err = GetDragItemReferenceNumber(theDrag, index, &theItemRef); if (_err != noErr) return PyMac_Error(_err); @@ -229,18 +325,20 @@ static PyObject *DragObj_GetDragItemReferenceNumber(_self, _args) return _res; } -static PyObject *DragObj_CountDragItemFlavors(_self, _args) - DragObjObject *_self; +static PyObject *Drag_CountDragItemFlavors(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; ItemReference theItemRef; UInt16 numFlavors; - if (!PyArg_ParseTuple(_args, "l", + if (!PyArg_ParseTuple(_args, "O&l", + DragObj_Convert, &theDrag, &theItemRef)) return NULL; - _err = CountDragItemFlavors(_self->ob_itself, + _err = CountDragItemFlavors(theDrag, theItemRef, &numFlavors); if (_err != noErr) return PyMac_Error(_err); @@ -249,20 +347,22 @@ static PyObject *DragObj_CountDragItemFlavors(_self, _args) return _res; } -static PyObject *DragObj_GetFlavorType(_self, _args) - DragObjObject *_self; +static PyObject *Drag_GetFlavorType(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; ItemReference theItemRef; UInt16 index; FlavorType theType; - if (!PyArg_ParseTuple(_args, "lH", + if (!PyArg_ParseTuple(_args, "O&lH", + DragObj_Convert, &theDrag, &theItemRef, &index)) return NULL; - _err = GetFlavorType(_self->ob_itself, + _err = GetFlavorType(theDrag, theItemRef, index, &theType); @@ -272,20 +372,22 @@ static PyObject *DragObj_GetFlavorType(_self, _args) return _res; } -static PyObject *DragObj_GetFlavorFlags(_self, _args) - DragObjObject *_self; +static PyObject *Drag_GetFlavorFlags(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; ItemReference theItemRef; FlavorType theType; FlavorFlags theFlags; - if (!PyArg_ParseTuple(_args, "lO&", + if (!PyArg_ParseTuple(_args, "O&lO&", + DragObj_Convert, &theDrag, &theItemRef, PyMac_GetOSType, &theType)) return NULL; - _err = GetFlavorFlags(_self->ob_itself, + _err = GetFlavorFlags(theDrag, theItemRef, theType, &theFlags); @@ -295,20 +397,22 @@ static PyObject *DragObj_GetFlavorFlags(_self, _args) return _res; } -static PyObject *DragObj_GetFlavorDataSize(_self, _args) - DragObjObject *_self; +static PyObject *Drag_GetFlavorDataSize(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; ItemReference theItemRef; FlavorType theType; Size dataSize; - if (!PyArg_ParseTuple(_args, "lO&", + if (!PyArg_ParseTuple(_args, "O&lO&", + DragObj_Convert, &theDrag, &theItemRef, PyMac_GetOSType, &theType)) return NULL; - _err = GetFlavorDataSize(_self->ob_itself, + _err = GetFlavorDataSize(theDrag, theItemRef, theType, &dataSize); @@ -318,19 +422,21 @@ static PyObject *DragObj_GetFlavorDataSize(_self, _args) return _res; } -static PyObject *DragObj_GetFlavorData(_self, _args) - DragObjObject *_self; +static PyObject *Drag_GetFlavorData(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; ItemReference theItemRef; FlavorType theType; char *dataPtr__out__; long dataPtr__len__; int dataPtr__in_len__; UInt32 dataOffset; - if (!PyArg_ParseTuple(_args, "lO&il", + if (!PyArg_ParseTuple(_args, "O&lO&il", + DragObj_Convert, &theDrag, &theItemRef, PyMac_GetOSType, &theType, &dataPtr__in_len__, @@ -342,7 +448,7 @@ static PyObject *DragObj_GetFlavorData(_self, _args) goto dataPtr__error__; } dataPtr__len__ = dataPtr__in_len__; - _err = GetFlavorData(_self->ob_itself, + _err = GetFlavorData(theDrag, theItemRef, theType, dataPtr__out__, &dataPtr__len__, @@ -355,18 +461,20 @@ static PyObject *DragObj_GetFlavorData(_self, _args) return _res; } -static PyObject *DragObj_GetDragItemBounds(_self, _args) - DragObjObject *_self; +static PyObject *Drag_GetDragItemBounds(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; ItemReference theItemRef; Rect itemBounds; - if (!PyArg_ParseTuple(_args, "l", + if (!PyArg_ParseTuple(_args, "O&l", + DragObj_Convert, &theDrag, &theItemRef)) return NULL; - _err = GetDragItemBounds(_self->ob_itself, + _err = GetDragItemBounds(theDrag, theItemRef, &itemBounds); if (_err != noErr) return PyMac_Error(_err); @@ -375,19 +483,21 @@ static PyObject *DragObj_GetDragItemBounds(_self, _args) return _res; } -static PyObject *DragObj_SetDragItemBounds(_self, _args) - DragObjObject *_self; +static PyObject *Drag_SetDragItemBounds(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; ItemReference theItemRef; Rect itemBounds; - if (!PyArg_ParseTuple(_args, "lO&", + if (!PyArg_ParseTuple(_args, "O&lO&", + DragObj_Convert, &theDrag, &theItemRef, PyMac_GetRect, &itemBounds)) return NULL; - _err = SetDragItemBounds(_self->ob_itself, + _err = SetDragItemBounds(theDrag, theItemRef, &itemBounds); if (_err != noErr) return PyMac_Error(_err); @@ -396,16 +506,18 @@ static PyObject *DragObj_SetDragItemBounds(_self, _args) return _res; } -static PyObject *DragObj_GetDropLocation(_self, _args) - DragObjObject *_self; +static PyObject *Drag_GetDropLocation(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; AEDesc dropLocation; - if (!PyArg_ParseTuple(_args, "")) + if (!PyArg_ParseTuple(_args, "O&", + DragObj_Convert, &theDrag)) return NULL; - _err = GetDropLocation(_self->ob_itself, + _err = GetDropLocation(theDrag, &dropLocation); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("O&", @@ -413,17 +525,19 @@ static PyObject *DragObj_GetDropLocation(_self, _args) return _res; } -static PyObject *DragObj_SetDropLocation(_self, _args) - DragObjObject *_self; +static PyObject *Drag_SetDropLocation(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; AEDesc dropLocation; - if (!PyArg_ParseTuple(_args, "O&", + if (!PyArg_ParseTuple(_args, "O&O&", + DragObj_Convert, &theDrag, AEDesc_Convert, &dropLocation)) return NULL; - _err = SetDropLocation(_self->ob_itself, + _err = SetDropLocation(theDrag, &dropLocation); if (_err != noErr) return PyMac_Error(_err); Py_INCREF(Py_None); @@ -431,16 +545,18 @@ static PyObject *DragObj_SetDropLocation(_self, _args) return _res; } -static PyObject *DragObj_GetDragAttributes(_self, _args) - DragObjObject *_self; +static PyObject *Drag_GetDragAttributes(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; DragAttributes flags; - if (!PyArg_ParseTuple(_args, "")) + if (!PyArg_ParseTuple(_args, "O&", + DragObj_Convert, &theDrag)) return NULL; - _err = GetDragAttributes(_self->ob_itself, + _err = GetDragAttributes(theDrag, &flags); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("l", @@ -448,17 +564,19 @@ static PyObject *DragObj_GetDragAttributes(_self, _args) return _res; } -static PyObject *DragObj_GetDragMouse(_self, _args) - DragObjObject *_self; +static PyObject *Drag_GetDragMouse(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; Point mouse; Point globalPinnedMouse; - if (!PyArg_ParseTuple(_args, "")) + if (!PyArg_ParseTuple(_args, "O&", + DragObj_Convert, &theDrag)) return NULL; - _err = GetDragMouse(_self->ob_itself, + _err = GetDragMouse(theDrag, &mouse, &globalPinnedMouse); if (_err != noErr) return PyMac_Error(_err); @@ -468,17 +586,19 @@ static PyObject *DragObj_GetDragMouse(_self, _args) return _res; } -static PyObject *DragObj_SetDragMouse(_self, _args) - DragObjObject *_self; +static PyObject *Drag_SetDragMouse(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; Point globalPinnedMouse; - if (!PyArg_ParseTuple(_args, "O&", + if (!PyArg_ParseTuple(_args, "O&O&", + DragObj_Convert, &theDrag, PyMac_GetPoint, &globalPinnedMouse)) return NULL; - _err = SetDragMouse(_self->ob_itself, + _err = SetDragMouse(theDrag, globalPinnedMouse); if (_err != noErr) return PyMac_Error(_err); Py_INCREF(Py_None); @@ -486,16 +606,18 @@ static PyObject *DragObj_SetDragMouse(_self, _args) return _res; } -static PyObject *DragObj_GetDragOrigin(_self, _args) - DragObjObject *_self; +static PyObject *Drag_GetDragOrigin(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; Point globalInitialMouse; - if (!PyArg_ParseTuple(_args, "")) + if (!PyArg_ParseTuple(_args, "O&", + DragObj_Convert, &theDrag)) return NULL; - _err = GetDragOrigin(_self->ob_itself, + _err = GetDragOrigin(theDrag, &globalInitialMouse); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("O&", @@ -503,18 +625,20 @@ static PyObject *DragObj_GetDragOrigin(_self, _args) return _res; } -static PyObject *DragObj_GetDragModifiers(_self, _args) - DragObjObject *_self; +static PyObject *Drag_GetDragModifiers(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; SInt16 modifiers; SInt16 mouseDownModifiers; SInt16 mouseUpModifiers; - if (!PyArg_ParseTuple(_args, "")) + if (!PyArg_ParseTuple(_args, "O&", + DragObj_Convert, &theDrag)) return NULL; - _err = GetDragModifiers(_self->ob_itself, + _err = GetDragModifiers(theDrag, &modifiers, &mouseDownModifiers, &mouseUpModifiers); @@ -526,19 +650,21 @@ static PyObject *DragObj_GetDragModifiers(_self, _args) return _res; } -static PyObject *DragObj_ShowDragHilite(_self, _args) - DragObjObject *_self; +static PyObject *Drag_ShowDragHilite(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; RgnHandle hiliteFrame; Boolean inside; - if (!PyArg_ParseTuple(_args, "O&b", + if (!PyArg_ParseTuple(_args, "O&O&b", + DragObj_Convert, &theDrag, ResObj_Convert, &hiliteFrame, &inside)) return NULL; - _err = ShowDragHilite(_self->ob_itself, + _err = ShowDragHilite(theDrag, hiliteFrame, inside); if (_err != noErr) return PyMac_Error(_err); @@ -547,34 +673,38 @@ static PyObject *DragObj_ShowDragHilite(_self, _args) return _res; } -static PyObject *DragObj_HideDragHilite(_self, _args) - DragObjObject *_self; +static PyObject *Drag_HideDragHilite(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; - if (!PyArg_ParseTuple(_args, "")) + DragRef theDrag; + if (!PyArg_ParseTuple(_args, "O&", + DragObj_Convert, &theDrag)) return NULL; - _err = HideDragHilite(_self->ob_itself); + _err = HideDragHilite(theDrag); if (_err != noErr) return PyMac_Error(_err); Py_INCREF(Py_None); _res = Py_None; return _res; } -static PyObject *DragObj_DragPreScroll(_self, _args) - DragObjObject *_self; +static PyObject *Drag_DragPreScroll(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; SInt16 dH; SInt16 dV; - if (!PyArg_ParseTuple(_args, "hh", + if (!PyArg_ParseTuple(_args, "O&hh", + DragObj_Convert, &theDrag, &dH, &dV)) return NULL; - _err = DragPreScroll(_self->ob_itself, + _err = DragPreScroll(theDrag, dH, dV); if (_err != noErr) return PyMac_Error(_err); @@ -583,32 +713,36 @@ static PyObject *DragObj_DragPreScroll(_self, _args) return _res; } -static PyObject *DragObj_DragPostScroll(_self, _args) - DragObjObject *_self; +static PyObject *Drag_DragPostScroll(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; - if (!PyArg_ParseTuple(_args, "")) + DragRef theDrag; + if (!PyArg_ParseTuple(_args, "O&", + DragObj_Convert, &theDrag)) return NULL; - _err = DragPostScroll(_self->ob_itself); + _err = DragPostScroll(theDrag); if (_err != noErr) return PyMac_Error(_err); Py_INCREF(Py_None); _res = Py_None; return _res; } -static PyObject *DragObj_UpdateDragHilite(_self, _args) - DragObjObject *_self; +static PyObject *Drag_UpdateDragHilite(_self, _args) + PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; + DragRef theDrag; RgnHandle updateRgn; - if (!PyArg_ParseTuple(_args, "O&", + if (!PyArg_ParseTuple(_args, "O&O&", + DragObj_Convert, &theDrag, ResObj_Convert, &updateRgn)) return NULL; - _err = UpdateDragHilite(_self->ob_itself, + _err = UpdateDragHilite(theDrag, updateRgn); if (_err != noErr) return PyMac_Error(_err); Py_INCREF(Py_None); @@ -616,117 +750,6 @@ static PyObject *DragObj_UpdateDragHilite(_self, _args) return _res; } -static PyMethodDef DragObj_methods[] = { - {"DisposeDrag", (PyCFunction)DragObj_DisposeDrag, 1, - "() -> None"}, - {"AddDragItemFlavor", (PyCFunction)DragObj_AddDragItemFlavor, 1, - "(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, FlavorFlags theFlags) -> None"}, - {"SetDragItemFlavorData", (PyCFunction)DragObj_SetDragItemFlavorData, 1, - "(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> None"}, - {"SetDragImage", (PyCFunction)DragObj_SetDragImage, 1, - "(PixMapHandle imagePixMap, RgnHandle imageRgn, Point imageOffsetPt, DragImageFlags theImageFlags) -> None"}, - {"TrackDrag", (PyCFunction)DragObj_TrackDrag, 1, - "(EventRecord theEvent, RgnHandle theRegion) -> None"}, - {"CountDragItems", (PyCFunction)DragObj_CountDragItems, 1, - "() -> (UInt16 numItems)"}, - {"GetDragItemReferenceNumber", (PyCFunction)DragObj_GetDragItemReferenceNumber, 1, - "(UInt16 index) -> (ItemReference theItemRef)"}, - {"CountDragItemFlavors", (PyCFunction)DragObj_CountDragItemFlavors, 1, - "(ItemReference theItemRef) -> (UInt16 numFlavors)"}, - {"GetFlavorType", (PyCFunction)DragObj_GetFlavorType, 1, - "(ItemReference theItemRef, UInt16 index) -> (FlavorType theType)"}, - {"GetFlavorFlags", (PyCFunction)DragObj_GetFlavorFlags, 1, - "(ItemReference theItemRef, FlavorType theType) -> (FlavorFlags theFlags)"}, - {"GetFlavorDataSize", (PyCFunction)DragObj_GetFlavorDataSize, 1, - "(ItemReference theItemRef, FlavorType theType) -> (Size dataSize)"}, - {"GetFlavorData", (PyCFunction)DragObj_GetFlavorData, 1, - "(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> (Buffer dataPtr)"}, - {"GetDragItemBounds", (PyCFunction)DragObj_GetDragItemBounds, 1, - "(ItemReference theItemRef) -> (Rect itemBounds)"}, - {"SetDragItemBounds", (PyCFunction)DragObj_SetDragItemBounds, 1, - "(ItemReference theItemRef, Rect itemBounds) -> None"}, - {"GetDropLocation", (PyCFunction)DragObj_GetDropLocation, 1, - "() -> (AEDesc dropLocation)"}, - {"SetDropLocation", (PyCFunction)DragObj_SetDropLocation, 1, - "(AEDesc dropLocation) -> None"}, - {"GetDragAttributes", (PyCFunction)DragObj_GetDragAttributes, 1, - "() -> (DragAttributes flags)"}, - {"GetDragMouse", (PyCFunction)DragObj_GetDragMouse, 1, - "() -> (Point mouse, Point globalPinnedMouse)"}, - {"SetDragMouse", (PyCFunction)DragObj_SetDragMouse, 1, - "(Point globalPinnedMouse) -> None"}, - {"GetDragOrigin", (PyCFunction)DragObj_GetDragOrigin, 1, - "() -> (Point globalInitialMouse)"}, - {"GetDragModifiers", (PyCFunction)DragObj_GetDragModifiers, 1, - "() -> (SInt16 modifiers, SInt16 mouseDownModifiers, SInt16 mouseUpModifiers)"}, - {"ShowDragHilite", (PyCFunction)DragObj_ShowDragHilite, 1, - "(RgnHandle hiliteFrame, Boolean inside) -> None"}, - {"HideDragHilite", (PyCFunction)DragObj_HideDragHilite, 1, - "() -> None"}, - {"DragPreScroll", (PyCFunction)DragObj_DragPreScroll, 1, - "(SInt16 dH, SInt16 dV) -> None"}, - {"DragPostScroll", (PyCFunction)DragObj_DragPostScroll, 1, - "() -> None"}, - {"UpdateDragHilite", (PyCFunction)DragObj_UpdateDragHilite, 1, - "(RgnHandle updateRgn) -> None"}, - {NULL, NULL, 0} -}; - -PyMethodChain DragObj_chain = { DragObj_methods, NULL }; - -static PyObject *DragObj_getattr(self, name) - DragObjObject *self; - char *name; -{ - return Py_FindMethodInChain(&DragObj_chain, (PyObject *)self, name); -} - -#define DragObj_setattr NULL - -#define DragObj_compare NULL - -#define DragObj_repr NULL - -#define DragObj_hash NULL - -PyTypeObject DragObj_Type = { - PyObject_HEAD_INIT(&PyType_Type) - 0, /*ob_size*/ - "DragObj", /*tp_name*/ - sizeof(DragObjObject), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor) DragObj_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - (getattrfunc) DragObj_getattr, /*tp_getattr*/ - (setattrfunc) DragObj_setattr, /*tp_setattr*/ - (cmpfunc) DragObj_compare, /*tp_compare*/ - (reprfunc) DragObj_repr, /*tp_repr*/ - (PyNumberMethods *)0, /* tp_as_number */ - (PySequenceMethods *)0, /* tp_as_sequence */ - (PyMappingMethods *)0, /* tp_as_mapping */ - (hashfunc) DragObj_hash, /*tp_hash*/ -}; - -/* -------------------- End object type DragObj --------------------- */ - - -static PyObject *Drag_NewDrag(_self, _args) - PyObject *_self; - PyObject *_args; -{ - PyObject *_res = NULL; - OSErr _err; - DragReference theDrag; - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _err = NewDrag(&theDrag); - if (_err != noErr) return PyMac_Error(_err); - _res = Py_BuildValue("O&", - DragObj_New, theDrag); - return _res; -} - static PyObject *Drag_GetDragHiliteColor(_self, _args) PyObject *_self; PyObject *_args; @@ -892,7 +915,61 @@ static PyObject *Drag_RemoveReceiveHandler(_self, _args) static PyMethodDef Drag_methods[] = { {"NewDrag", (PyCFunction)Drag_NewDrag, 1, - "() -> (DragReference theDrag)"}, + "() -> (DragRef theDrag)"}, + {"DisposeDrag", (PyCFunction)Drag_DisposeDrag, 1, + "(DragRef theDrag) -> None"}, + {"AddDragItemFlavor", (PyCFunction)Drag_AddDragItemFlavor, 1, + "(DragRef theDrag, ItemReference theItemRef, FlavorType theType, Buffer dataPtr, FlavorFlags theFlags) -> None"}, + {"SetDragItemFlavorData", (PyCFunction)Drag_SetDragItemFlavorData, 1, + "(DragRef theDrag, ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> None"}, + {"SetDragImage", (PyCFunction)Drag_SetDragImage, 1, + "(DragRef theDrag, PixMapHandle imagePixMap, RgnHandle imageRgn, Point imageOffsetPt, DragImageFlags theImageFlags) -> None"}, + {"ChangeDragBehaviors", (PyCFunction)Drag_ChangeDragBehaviors, 1, + "(DragRef theDrag, DragBehaviors inBehaviorsToSet, DragBehaviors inBehaviorsToClear) -> None"}, + {"TrackDrag", (PyCFunction)Drag_TrackDrag, 1, + "(DragRef theDrag, EventRecord theEvent, RgnHandle theRegion) -> None"}, + {"CountDragItems", (PyCFunction)Drag_CountDragItems, 1, + "(DragRef theDrag) -> (UInt16 numItems)"}, + {"GetDragItemReferenceNumber", (PyCFunction)Drag_GetDragItemReferenceNumber, 1, + "(DragRef theDrag, UInt16 index) -> (ItemReference theItemRef)"}, + {"CountDragItemFlavors", (PyCFunction)Drag_CountDragItemFlavors, 1, + "(DragRef theDrag, ItemReference theItemRef) -> (UInt16 numFlavors)"}, + {"GetFlavorType", (PyCFunction)Drag_GetFlavorType, 1, + "(DragRef theDrag, ItemReference theItemRef, UInt16 index) -> (FlavorType theType)"}, + {"GetFlavorFlags", (PyCFunction)Drag_GetFlavorFlags, 1, + "(DragRef theDrag, ItemReference theItemRef, FlavorType theType) -> (FlavorFlags theFlags)"}, + {"GetFlavorDataSize", (PyCFunction)Drag_GetFlavorDataSize, 1, + "(DragRef theDrag, ItemReference theItemRef, FlavorType theType) -> (Size dataSize)"}, + {"GetFlavorData", (PyCFunction)Drag_GetFlavorData, 1, + "(DragRef theDrag, ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> (Buffer dataPtr)"}, + {"GetDragItemBounds", (PyCFunction)Drag_GetDragItemBounds, 1, + "(DragRef theDrag, ItemReference theItemRef) -> (Rect itemBounds)"}, + {"SetDragItemBounds", (PyCFunction)Drag_SetDragItemBounds, 1, + "(DragRef theDrag, ItemReference theItemRef, Rect itemBounds) -> None"}, + {"GetDropLocation", (PyCFunction)Drag_GetDropLocation, 1, + "(DragRef theDrag) -> (AEDesc dropLocation)"}, + {"SetDropLocation", (PyCFunction)Drag_SetDropLocation, 1, + "(DragRef theDrag, AEDesc dropLocation) -> None"}, + {"GetDragAttributes", (PyCFunction)Drag_GetDragAttributes, 1, + "(DragRef theDrag) -> (DragAttributes flags)"}, + {"GetDragMouse", (PyCFunction)Drag_GetDragMouse, 1, + "(DragRef theDrag) -> (Point mouse, Point globalPinnedMouse)"}, + {"SetDragMouse", (PyCFunction)Drag_SetDragMouse, 1, + "(DragRef theDrag, Point globalPinnedMouse) -> None"}, + {"GetDragOrigin", (PyCFunction)Drag_GetDragOrigin, 1, + "(DragRef theDrag) -> (Point globalInitialMouse)"}, + {"GetDragModifiers", (PyCFunction)Drag_GetDragModifiers, 1, + "(DragRef theDrag) -> (SInt16 modifiers, SInt16 mouseDownModifiers, SInt16 mouseUpModifiers)"}, + {"ShowDragHilite", (PyCFunction)Drag_ShowDragHilite, 1, + "(DragRef theDrag, RgnHandle hiliteFrame, Boolean inside) -> None"}, + {"HideDragHilite", (PyCFunction)Drag_HideDragHilite, 1, + "(DragRef theDrag) -> None"}, + {"DragPreScroll", (PyCFunction)Drag_DragPreScroll, 1, + "(DragRef theDrag, SInt16 dH, SInt16 dV) -> None"}, + {"DragPostScroll", (PyCFunction)Drag_DragPostScroll, 1, + "(DragRef theDrag) -> None"}, + {"UpdateDragHilite", (PyCFunction)Drag_UpdateDragHilite, 1, + "(DragRef theDrag, RgnHandle updateRgn) -> None"}, {"GetDragHiliteColor", (PyCFunction)Drag_GetDragHiliteColor, 1, "(WindowPtr window) -> (RGBColor color)"}, {"WaitMouseMoved", (PyCFunction)Drag_WaitMouseMoved, 1, @@ -1023,7 +1100,7 @@ void initDrag() Drag_Error = PyMac_GetOSErrException(); if (Drag_Error == NULL || PyDict_SetItemString(d, "Error", Drag_Error) != 0) - Py_FatalError("can't initialize Drag.Error"); + return; DragObj_Type.ob_type = &PyType_Type; Py_INCREF(&DragObj_Type); if (PyDict_SetItemString(d, "DragObjType", (PyObject *)&DragObj_Type) != 0) diff --git a/Mac/Modules/drag/dragsupport.py b/Mac/Modules/drag/dragsupport.py index af8a255..d90acc9 100644 --- a/Mac/Modules/drag/dragsupport.py +++ b/Mac/Modules/drag/dragsupport.py @@ -12,7 +12,7 @@ OBJECTNAME = 'DragObj' # The basic name of the objects used here # The following is *usually* unchanged but may still require tuning MODPREFIX = MODNAME # The prefix for module-wide routines -OBJECTTYPE = 'DragReference' # The C type used to represent them +OBJECTTYPE = 'DragRef' # The C type used to represent them OBJECTPREFIX = MODPREFIX + 'Obj' # The prefix for object methods INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner OUTPUTFILE = MODNAME + "module.c" # The file generated by this program @@ -21,31 +21,21 @@ from macsupport import * # Create the type objects -DragReference = OpaqueByValueType(OBJECTTYPE, OBJECTPREFIX) +DragRef = OpaqueByValueType(OBJECTTYPE, OBJECTPREFIX) +DragItemRef = Type("ItemReference", "l") +# Old names +DragReference = DragRef +ItemReference = DragItemRef -##CCTabHandle = OpaqueByValueType("CCTabHandle", "ResObj") -##AuxCtlHandle = OpaqueByValueType("AuxCtlHandle", "ResObj") -##ControlPartCode = Type("ControlPartCode", "h") -##DragConstraint = Type("DragConstraint", "h") -##ControlVariant = Type("ControlVariant", "h") -##IconTransformType = Type("IconTransformType", "h") -##ControlButtonGraphicAlignment = Type("ControlButtonGraphicAlignment", "h") -##ControlButtonTextAlignment = Type("ControlButtonTextAlignment", "h") -##ControlButtonTextPlacement = Type("ControlButtonTextPlacement", "h") -##ControlContentType = Type("ControlContentType", "h") -##ControlFocusPart = Type("ControlFocusPart", "h") -## -##ControlFontStyleRec = OpaqueType('ControlFontStyleRec', 'ControlFontStyle') -##ControlFontStyleRec_ptr = ControlFontStyleRec PixMapHandle = OpaqueByValueType("PixMapHandle", "ResObj") RgnHandle = OpaqueByValueType("RgnHandle", "ResObj") AEDesc = OpaqueType('AEDesc') AEDesc_ptr = AEDesc RGBColor = OpaqueType("RGBColor", "QdRGB") -ItemReference = Type("ItemReference", "l") FlavorType = OSTypeType("FlavorType") DragAttributes = Type("DragAttributes", "l") +DragBehaviors = Type("DragBehaviors", "l") DragImageFlags = Type("DragImageFlags", "l") DragImageTranslucency = Type("DragImageTranslucency", "l") DragRegionMessage = Type("DragRegionMessage", "h") diff --git a/Mac/Modules/evt/Evtmodule.c b/Mac/Modules/evt/Evtmodule.c index c161c75..ed18f9c 100644 --- a/Mac/Modules/evt/Evtmodule.c +++ b/Mac/Modules/evt/Evtmodule.c @@ -316,6 +316,57 @@ static PyObject *Evt_SystemEvent(_self, _args) } #endif +#if TARGET_API_MAC_CARBON + +static PyObject *Evt_GetGlobalMouse(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Point globalMouse; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + GetGlobalMouse(&globalMouse); + _res = Py_BuildValue("O&", + PyMac_BuildPoint, globalMouse); + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *Evt_GetCurrentKeyModifiers(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + UInt32 _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetCurrentKeyModifiers(); + _res = Py_BuildValue("l", + _rv); + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *Evt_CheckEventQueueForUserCancel(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Boolean _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CheckEventQueueForUserCancel(); + _res = Py_BuildValue("b", + _rv); + return _res; +} +#endif + static PyObject *Evt_WaitNextEvent(_self, _args) PyObject *_self; PyObject *_args; @@ -396,6 +447,21 @@ static PyMethodDef Evt_methods[] = { {"SystemEvent", (PyCFunction)Evt_SystemEvent, 1, "(EventRecord theEvent) -> (Boolean _rv)"}, #endif + +#if TARGET_API_MAC_CARBON + {"GetGlobalMouse", (PyCFunction)Evt_GetGlobalMouse, 1, + "() -> (Point globalMouse)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"GetCurrentKeyModifiers", (PyCFunction)Evt_GetCurrentKeyModifiers, 1, + "() -> (UInt32 _rv)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"CheckEventQueueForUserCancel", (PyCFunction)Evt_CheckEventQueueForUserCancel, 1, + "() -> (Boolean _rv)"}, +#endif {"WaitNextEvent", (PyCFunction)Evt_WaitNextEvent, 1, "(EventMask eventMask, UInt32 sleep [,RegionHandle]) -> (Boolean _rv, EventRecord theEvent)"}, {NULL, NULL, 0} @@ -417,7 +483,7 @@ void initEvt() Evt_Error = PyMac_GetOSErrException(); if (Evt_Error == NULL || PyDict_SetItemString(d, "Error", Evt_Error) != 0) - Py_FatalError("can't initialize Evt.Error"); + return; } /* ========================= End module Evt ========================= */ diff --git a/Mac/Modules/evt/evtscan.py b/Mac/Modules/evt/evtscan.py index 3695440..82b9260 100644 --- a/Mac/Modules/evt/evtscan.py +++ b/Mac/Modules/evt/evtscan.py @@ -43,6 +43,11 @@ class MyScanner(Scanner): 'SystemClick', 'GetOSEvent', 'OSEventAvail', + ]), + ('#if TARGET_API_MAC_CARBON', [ + 'CheckEventQueueForUserCancel', + 'GetCurrentKeyModifiers', + 'GetGlobalMouse', ])] def makeblacklistnames(self): diff --git a/Mac/Modules/fm/Fmmodule.c b/Mac/Modules/fm/Fmmodule.c index 6d1c507..0d66d16 100644 --- a/Mac/Modules/fm/Fmmodule.c +++ b/Mac/Modules/fm/Fmmodule.c @@ -319,14 +319,14 @@ static PyObject *Fm_SetAntiAliasedTextEnabled(_self, _args) { PyObject *_res = NULL; OSStatus _err; - Boolean inEnable; - SInt16 inMinFontSize; + Boolean iEnable; + SInt16 iMinFontSize; if (!PyArg_ParseTuple(_args, "bh", - &inEnable, - &inMinFontSize)) + &iEnable, + &iMinFontSize)) return NULL; - _err = SetAntiAliasedTextEnabled(inEnable, - inMinFontSize); + _err = SetAntiAliasedTextEnabled(iEnable, + iMinFontSize); if (_err != noErr) return PyMac_Error(_err); Py_INCREF(Py_None); _res = Py_None; @@ -339,13 +339,13 @@ static PyObject *Fm_IsAntiAliasedTextEnabled(_self, _args) { PyObject *_res = NULL; Boolean _rv; - SInt16 outMinFontSize; + SInt16 oMinFontSize; if (!PyArg_ParseTuple(_args, "")) return NULL; - _rv = IsAntiAliasedTextEnabled(&outMinFontSize); + _rv = IsAntiAliasedTextEnabled(&oMinFontSize); _res = Py_BuildValue("bh", _rv, - outMinFontSize); + oMinFontSize); return _res; } @@ -394,9 +394,9 @@ static PyMethodDef Fm_methods[] = { {"GetAppFont", (PyCFunction)Fm_GetAppFont, 1, "() -> (short _rv)"}, {"SetAntiAliasedTextEnabled", (PyCFunction)Fm_SetAntiAliasedTextEnabled, 1, - "(Boolean inEnable, SInt16 inMinFontSize) -> None"}, + "(Boolean iEnable, SInt16 iMinFontSize) -> None"}, {"IsAntiAliasedTextEnabled", (PyCFunction)Fm_IsAntiAliasedTextEnabled, 1, - "() -> (Boolean _rv, SInt16 outMinFontSize)"}, + "() -> (Boolean _rv, SInt16 oMinFontSize)"}, {NULL, NULL, 0} }; @@ -416,7 +416,7 @@ void initFm() Fm_Error = PyMac_GetOSErrException(); if (Fm_Error == NULL || PyDict_SetItemString(d, "Error", Fm_Error) != 0) - Py_FatalError("can't initialize Fm.Error"); + return; } /* ========================= End module Fm ========================== */ diff --git a/Mac/Modules/help/Helpmodule.c b/Mac/Modules/help/Helpmodule.c index ffd2090..3a44632 100644 --- a/Mac/Modules/help/Helpmodule.c +++ b/Mac/Modules/help/Helpmodule.c @@ -315,7 +315,7 @@ void initHelp() Help_Error = PyMac_GetOSErrException(); if (Help_Error == NULL || PyDict_SetItemString(d, "Error", Help_Error) != 0) - Py_FatalError("can't initialize Help.Error"); + return; } /* ======================== End module Help ========================= */ diff --git a/Mac/Modules/icn/Icnmodule.c b/Mac/Modules/icn/Icnmodule.c index 6cbb936..4a5eda0 100644 --- a/Mac/Modules/icn/Icnmodule.c +++ b/Mac/Modules/icn/Icnmodule.c @@ -1248,6 +1248,120 @@ static PyObject *Icn_GetCustomIconsEnabled(_self, _args) return _res; } +static PyObject *Icn_IsIconRefMaskEmpty(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Boolean _rv; + IconRef iconRef; + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &iconRef)) + return NULL; + _rv = IsIconRefMaskEmpty(iconRef); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +#if TARGET_API_MAC_CARBON + +static PyObject *Icn_GetIconRefVariant(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + IconRef _rv; + IconRef inIconRef; + OSType inVariant; + IconTransformType outTransform; + if (!PyArg_ParseTuple(_args, "O&O&", + ResObj_Convert, &inIconRef, + PyMac_GetOSType, &inVariant)) + return NULL; + _rv = GetIconRefVariant(inIconRef, + inVariant, + &outTransform); + _res = Py_BuildValue("O&h", + ResObj_New, _rv, + outTransform); + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *Icn_RegisterIconRefFromIconFile(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + OSType creator; + OSType iconType; + FSSpec iconFile; + IconRef theIconRef; + if (!PyArg_ParseTuple(_args, "O&O&O&", + PyMac_GetOSType, &creator, + PyMac_GetOSType, &iconType, + PyMac_GetFSSpec, &iconFile)) + return NULL; + _err = RegisterIconRefFromIconFile(creator, + iconType, + &iconFile, + &theIconRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, theIconRef); + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *Icn_ReadIconFile(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec iconFile; + IconFamilyHandle iconFamily; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSSpec, &iconFile)) + return NULL; + _err = ReadIconFile(&iconFile, + &iconFamily); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, iconFamily); + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *Icn_WriteIconFile(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + IconFamilyHandle iconFamily; + FSSpec iconFile; + if (!PyArg_ParseTuple(_args, "O&O&", + ResObj_Convert, &iconFamily, + PyMac_GetFSSpec, &iconFile)) + return NULL; + _err = WriteIconFile(iconFamily, + &iconFile); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} +#endif + static PyMethodDef Icn_methods[] = { {"GetCIcon", (PyCFunction)Icn_GetCIcon, 1, "(SInt16 iconID) -> (CIconHandle _rv)"}, @@ -1364,6 +1478,28 @@ static PyMethodDef Icn_methods[] = { "(SInt16 vRefNum, Boolean enableCustomIcons) -> None"}, {"GetCustomIconsEnabled", (PyCFunction)Icn_GetCustomIconsEnabled, 1, "(SInt16 vRefNum) -> (Boolean customIconsEnabled)"}, + {"IsIconRefMaskEmpty", (PyCFunction)Icn_IsIconRefMaskEmpty, 1, + "(IconRef iconRef) -> (Boolean _rv)"}, + +#if TARGET_API_MAC_CARBON + {"GetIconRefVariant", (PyCFunction)Icn_GetIconRefVariant, 1, + "(IconRef inIconRef, OSType inVariant) -> (IconRef _rv, IconTransformType outTransform)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"RegisterIconRefFromIconFile", (PyCFunction)Icn_RegisterIconRefFromIconFile, 1, + "(OSType creator, OSType iconType, FSSpec iconFile) -> (IconRef theIconRef)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"ReadIconFile", (PyCFunction)Icn_ReadIconFile, 1, + "(FSSpec iconFile) -> (IconFamilyHandle iconFamily)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"WriteIconFile", (PyCFunction)Icn_WriteIconFile, 1, + "(IconFamilyHandle iconFamily, FSSpec iconFile) -> None"}, +#endif {NULL, NULL, 0} }; @@ -1383,7 +1519,7 @@ void initIcn() Icn_Error = PyMac_GetOSErrException(); if (Icn_Error == NULL || PyDict_SetItemString(d, "Error", Icn_Error) != 0) - Py_FatalError("can't initialize Icn.Error"); + return; } /* ========================= End module Icn ========================= */ diff --git a/Mac/Modules/icn/icnscan.py b/Mac/Modules/icn/icnscan.py index 93d27d0..4dbccfe 100644 --- a/Mac/Modules/icn/icnscan.py +++ b/Mac/Modules/icn/icnscan.py @@ -49,6 +49,12 @@ class MyScanner(Scanner): return [ ('#if !TARGET_API_MAC_CARBON', [ 'IconServicesTerminate', + ]), + ('#if TARGET_API_MAC_CARBON', [ + 'WriteIconFile', + 'ReadIconFile', + 'RegisterIconRefFromIconFile', + 'GetIconRefVariant', ])] def makeblacklisttypes(self): diff --git a/Mac/Modules/list/Listmodule.c b/Mac/Modules/list/Listmodule.c index f5360f2..338b611 100644 --- a/Mac/Modules/list/Listmodule.c +++ b/Mac/Modules/list/Listmodule.c @@ -10,6 +10,31 @@ #include <Lists.h> +#if !ACCESSOR_CALLS_ARE_FUNCTIONS +#define GetListPort(list) ((CGrafPtr)(*(list))->port) +#define GetListVerticalScrollBar(list) ((*(list))->vScroll) +#define GetListHorizontalScrollBar(list) ((*(list))->hScroll) +#define GetListActive(list) ((*(list))->lActive) +#define GetListClickTime(list) ((*(list))->clikTime) +#define GetListRefCon(list) ((*(list))->refCon) +#define GetListDefinition(list) ((*(list))->listDefProc) /* XXX Is this indeed the same? */ +#define GetListUserHandle(list) ((*(list))->userHandle) +#define GetListDataHandle(list) ((*(list))->cells) +#define GetListFlags(list) ((*(list))->listFlags) +#define GetListSelectionFlags(list) ((*(list))->selFlags) +#define SetListViewBounds(list, bounds) (((*(list))->rView) = *(bounds)) + +#define SetListPort(list, port) (((*(list))->port) = (GrafPtr)(port)) +#define SetListCellIndent(list, ind) (((*(list))->indent) = *(ind)) +#define SetListClickTime(list, time) (((*(list))->clikTime) = (time)) +#define SetListLastClick(list, click) (((*(list)->lastClick) = *(click)) +#define SetListRefCon(list, refcon) (((*(list))->refCon) = (refcon)) +#define SetListUserHandle(list, handle) (((*(list))->userHandle) = (handle)) +#define SetListFlags(list, flags) (((*(list))->listFlags) = (flags)) +#define SetListSelectionFlags(list, flags) (((*(list))->selFlags) = (flags)) + +#endif + #define as_List(x) ((ListHandle)x) #define as_Resource(lh) ((Handle)lh) @@ -649,6 +674,325 @@ static PyObject *List_LNew(_self, _args) return _res; } +static PyObject *List_GetListPort(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + CGrafPtr _rv; + ListHandle list; + if (!PyArg_ParseTuple(_args, "O&", + ListObj_Convert, &list)) + return NULL; + _rv = GetListPort(list); + _res = Py_BuildValue("O&", + GrafObj_New, _rv); + return _res; +} + +static PyObject *List_GetListVerticalScrollBar(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ControlHandle _rv; + ListHandle list; + if (!PyArg_ParseTuple(_args, "O&", + ListObj_Convert, &list)) + return NULL; + _rv = GetListVerticalScrollBar(list); + _res = Py_BuildValue("O&", + CtlObj_New, _rv); + return _res; +} + +static PyObject *List_GetListHorizontalScrollBar(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ControlHandle _rv; + ListHandle list; + if (!PyArg_ParseTuple(_args, "O&", + ListObj_Convert, &list)) + return NULL; + _rv = GetListHorizontalScrollBar(list); + _res = Py_BuildValue("O&", + CtlObj_New, _rv); + return _res; +} + +static PyObject *List_GetListActive(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Boolean _rv; + ListHandle list; + if (!PyArg_ParseTuple(_args, "O&", + ListObj_Convert, &list)) + return NULL; + _rv = GetListActive(list); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *List_GetListClickTime(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + SInt32 _rv; + ListHandle list; + if (!PyArg_ParseTuple(_args, "O&", + ListObj_Convert, &list)) + return NULL; + _rv = GetListClickTime(list); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *List_GetListRefCon(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + SInt32 _rv; + ListHandle list; + if (!PyArg_ParseTuple(_args, "O&", + ListObj_Convert, &list)) + return NULL; + _rv = GetListRefCon(list); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *List_GetListDefinition(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Handle _rv; + ListHandle list; + if (!PyArg_ParseTuple(_args, "O&", + ListObj_Convert, &list)) + return NULL; + _rv = GetListDefinition(list); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *List_GetListUserHandle(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Handle _rv; + ListHandle list; + if (!PyArg_ParseTuple(_args, "O&", + ListObj_Convert, &list)) + return NULL; + _rv = GetListUserHandle(list); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *List_GetListDataHandle(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + DataHandle _rv; + ListHandle list; + if (!PyArg_ParseTuple(_args, "O&", + ListObj_Convert, &list)) + return NULL; + _rv = GetListDataHandle(list); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *List_GetListFlags(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OptionBits _rv; + ListHandle list; + if (!PyArg_ParseTuple(_args, "O&", + ListObj_Convert, &list)) + return NULL; + _rv = GetListFlags(list); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *List_GetListSelectionFlags(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OptionBits _rv; + ListHandle list; + if (!PyArg_ParseTuple(_args, "O&", + ListObj_Convert, &list)) + return NULL; + _rv = GetListSelectionFlags(list); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *List_SetListViewBounds(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ListHandle list; + Rect view; + if (!PyArg_ParseTuple(_args, "O&O&", + ListObj_Convert, &list, + PyMac_GetRect, &view)) + return NULL; + SetListViewBounds(list, + &view); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *List_SetListPort(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ListHandle list; + CGrafPtr port; + if (!PyArg_ParseTuple(_args, "O&O&", + ListObj_Convert, &list, + GrafObj_Convert, &port)) + return NULL; + SetListPort(list, + port); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *List_SetListCellIndent(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ListHandle list; + Point indent; + if (!PyArg_ParseTuple(_args, "O&", + ListObj_Convert, &list)) + return NULL; + SetListCellIndent(list, + &indent); + _res = Py_BuildValue("O&", + PyMac_BuildPoint, indent); + return _res; +} + +static PyObject *List_SetListClickTime(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ListHandle list; + SInt32 time; + if (!PyArg_ParseTuple(_args, "O&l", + ListObj_Convert, &list, + &time)) + return NULL; + SetListClickTime(list, + time); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *List_SetListRefCon(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ListHandle list; + SInt32 refCon; + if (!PyArg_ParseTuple(_args, "O&l", + ListObj_Convert, &list, + &refCon)) + return NULL; + SetListRefCon(list, + refCon); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *List_SetListUserHandle(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ListHandle list; + Handle userHandle; + if (!PyArg_ParseTuple(_args, "O&O&", + ListObj_Convert, &list, + ResObj_Convert, &userHandle)) + return NULL; + SetListUserHandle(list, + userHandle); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *List_SetListFlags(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ListHandle list; + OptionBits listFlags; + if (!PyArg_ParseTuple(_args, "O&l", + ListObj_Convert, &list, + &listFlags)) + return NULL; + SetListFlags(list, + listFlags); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *List_SetListSelectionFlags(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ListHandle list; + OptionBits selectionFlags; + if (!PyArg_ParseTuple(_args, "O&l", + ListObj_Convert, &list, + &selectionFlags)) + return NULL; + SetListSelectionFlags(list, + selectionFlags); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + static PyObject *List_as_List(_self, _args) PyObject *_self; PyObject *_args; @@ -668,6 +1012,44 @@ static PyObject *List_as_List(_self, _args) static PyMethodDef List_methods[] = { {"LNew", (PyCFunction)List_LNew, 1, "(Rect rView, Rect dataBounds, Point cSize, short theProc, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListHandle _rv)"}, + {"GetListPort", (PyCFunction)List_GetListPort, 1, + "(ListHandle list) -> (CGrafPtr _rv)"}, + {"GetListVerticalScrollBar", (PyCFunction)List_GetListVerticalScrollBar, 1, + "(ListHandle list) -> (ControlHandle _rv)"}, + {"GetListHorizontalScrollBar", (PyCFunction)List_GetListHorizontalScrollBar, 1, + "(ListHandle list) -> (ControlHandle _rv)"}, + {"GetListActive", (PyCFunction)List_GetListActive, 1, + "(ListHandle list) -> (Boolean _rv)"}, + {"GetListClickTime", (PyCFunction)List_GetListClickTime, 1, + "(ListHandle list) -> (SInt32 _rv)"}, + {"GetListRefCon", (PyCFunction)List_GetListRefCon, 1, + "(ListHandle list) -> (SInt32 _rv)"}, + {"GetListDefinition", (PyCFunction)List_GetListDefinition, 1, + "(ListHandle list) -> (Handle _rv)"}, + {"GetListUserHandle", (PyCFunction)List_GetListUserHandle, 1, + "(ListHandle list) -> (Handle _rv)"}, + {"GetListDataHandle", (PyCFunction)List_GetListDataHandle, 1, + "(ListHandle list) -> (DataHandle _rv)"}, + {"GetListFlags", (PyCFunction)List_GetListFlags, 1, + "(ListHandle list) -> (OptionBits _rv)"}, + {"GetListSelectionFlags", (PyCFunction)List_GetListSelectionFlags, 1, + "(ListHandle list) -> (OptionBits _rv)"}, + {"SetListViewBounds", (PyCFunction)List_SetListViewBounds, 1, + "(ListHandle list, Rect view) -> None"}, + {"SetListPort", (PyCFunction)List_SetListPort, 1, + "(ListHandle list, CGrafPtr port) -> None"}, + {"SetListCellIndent", (PyCFunction)List_SetListCellIndent, 1, + "(ListHandle list) -> (Point indent)"}, + {"SetListClickTime", (PyCFunction)List_SetListClickTime, 1, + "(ListHandle list, SInt32 time) -> None"}, + {"SetListRefCon", (PyCFunction)List_SetListRefCon, 1, + "(ListHandle list, SInt32 refCon) -> None"}, + {"SetListUserHandle", (PyCFunction)List_SetListUserHandle, 1, + "(ListHandle list, Handle userHandle) -> None"}, + {"SetListFlags", (PyCFunction)List_SetListFlags, 1, + "(ListHandle list, OptionBits listFlags) -> None"}, + {"SetListSelectionFlags", (PyCFunction)List_SetListSelectionFlags, 1, + "(ListHandle list, OptionBits selectionFlags) -> None"}, {"as_List", (PyCFunction)List_as_List, 1, "(Resource)->List.\nReturns List object (which is not auto-freed!)"}, {NULL, NULL, 0} @@ -689,7 +1071,7 @@ void initList() List_Error = PyMac_GetOSErrException(); if (List_Error == NULL || PyDict_SetItemString(d, "Error", List_Error) != 0) - Py_FatalError("can't initialize List.Error"); + return; List_Type.ob_type = &PyType_Type; Py_INCREF(&List_Type); if (PyDict_SetItemString(d, "ListType", (PyObject *)&List_Type) != 0) diff --git a/Mac/Modules/list/listscan.py b/Mac/Modules/list/listscan.py index a5dd9eb..b8bd549 100644 --- a/Mac/Modules/list/listscan.py +++ b/Mac/Modules/list/listscan.py @@ -40,10 +40,24 @@ class MyScanner(Scanner): "LDispose", # Done by removing the object "LSearch", # We don't want to handle procs just yet "LGetCellDataLocation", # What does this do?? + + # These have funny argument/return values + "GetListViewBounds", + "GetListCellIndent", + "GetListCellSize", + "GetListVisibleCells", + "GetListClickLocation", + "GetListMouseLocation", + "GetListDataBounds", + "SetListLastClick", ] def makeblacklisttypes(self): return [ + 'ListDefSpec', # Too difficult for now + 'ListDefSpec_ptr', # ditto + "ListDefUPP", + "ListClickLoopUPP", ] def makerepairinstructions(self): diff --git a/Mac/Modules/list/listsupport.py b/Mac/Modules/list/listsupport.py index eca08cb..ecf8392 100644 --- a/Mac/Modules/list/listsupport.py +++ b/Mac/Modules/list/listsupport.py @@ -22,16 +22,46 @@ from macsupport import * # Create the type objects ListHandle = OpaqueByValueType("ListHandle", "ListObj") +ListRef = ListHandle # Obsolete, but used in Lists.h Cell = Point +ListBounds = Rect +ListBounds_ptr = Rect_ptr VarOutBufferShortsize = VarHeapOutputBufferType('char', 'short', 's') # (buf, &len) InBufferShortsize = VarInputBufferType('char', 'short', 's') # (buf, len) RgnHandle = OpaqueByValueType("RgnHandle", "ResObj") +DataHandle = OpaqueByValueType("DataHandle", "ResObj") Handle = OpaqueByValueType("Handle", "ResObj") +CGrafPtr = OpaqueByValueType("CGrafPtr", "GrafObj") includestuff = includestuff + """ #include <%s>""" % MACHEADERFILE + """ +#if !ACCESSOR_CALLS_ARE_FUNCTIONS +#define GetListPort(list) ((CGrafPtr)(*(list))->port) +#define GetListVerticalScrollBar(list) ((*(list))->vScroll) +#define GetListHorizontalScrollBar(list) ((*(list))->hScroll) +#define GetListActive(list) ((*(list))->lActive) +#define GetListClickTime(list) ((*(list))->clikTime) +#define GetListRefCon(list) ((*(list))->refCon) +#define GetListDefinition(list) ((*(list))->listDefProc) /* XXX Is this indeed the same? */ +#define GetListUserHandle(list) ((*(list))->userHandle) +#define GetListDataHandle(list) ((*(list))->cells) +#define GetListFlags(list) ((*(list))->listFlags) +#define GetListSelectionFlags(list) ((*(list))->selFlags) +#define SetListViewBounds(list, bounds) (((*(list))->rView) = *(bounds)) + +#define SetListPort(list, port) (((*(list))->port) = (GrafPtr)(port)) +#define SetListCellIndent(list, ind) (((*(list))->indent) = *(ind)) +#define SetListClickTime(list, time) (((*(list))->clikTime) = (time)) +#define SetListLastClick(list, click) (((*(list)->lastClick) = *(click)) +#define SetListRefCon(list, refcon) (((*(list))->refCon) = (refcon)) +#define SetListUserHandle(list, handle) (((*(list))->userHandle) = (handle)) +#define SetListFlags(list, flags) (((*(list))->listFlags) = (flags)) +#define SetListSelectionFlags(list, flags) (((*(list))->selFlags) = (flags)) + +#endif + #define as_List(x) ((ListHandle)x) #define as_Resource(lh) ((Handle)lh) """ diff --git a/Mac/Modules/menu/Menumodule.c b/Mac/Modules/menu/Menumodule.c index a47c88a..7f15330 100644 --- a/Mac/Modules/menu/Menumodule.c +++ b/Mac/Modules/menu/Menumodule.c @@ -11,6 +11,16 @@ #include <Devices.h> /* Defines OpenDeskAcc in universal headers */ #include <Menus.h> +#if !ACCESSOR_CALLS_ARE_FUNCTIONS +#define GetMenuID(menu) ((*(menu))->menuID) +#define GetMenuWidth(menu) ((*(menu))->menuWidth) +#define GetMenuHeight(menu) ((*(menu))->menuHeight) + +#define SetMenuID(menu, id) ((*(menu))->menuID = (id)) +#define SetMenuWidth(menu, width) ((*(menu))->menuWidth = (width)) +#define SetMenuHeight(menu, height) ((*(menu))->menuHeight = (height)) +#endif + #define as_Menu(h) ((MenuHandle)h) #define as_Resource(h) ((Handle)h) @@ -82,6 +92,20 @@ static PyObject *MenuObj_CalcMenuSize(_self, _args) return _res; } +static PyObject *MenuObj_CountMenuItems(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + short _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CountMenuItems(_self->ob_itself); + _res = Py_BuildValue("h", + _rv); + return _res; +} + #if !TARGET_API_MAC_CARBON static PyObject *MenuObj_CountMItems(_self, _args) @@ -324,8 +348,8 @@ static PyObject *MenuObj_InsertMenuItemText(_self, _args) PyObject *_res = NULL; OSStatus _err; Str255 inString; - UInt16 afterItem; - if (!PyArg_ParseTuple(_args, "O&H", + MenuItemIndex afterItem; + if (!PyArg_ParseTuple(_args, "O&h", PyMac_GetStr255, inString, &afterItem)) return NULL; @@ -366,7 +390,7 @@ static PyObject *MenuObj_MacInsertMenu(_self, _args) PyObject *_args; { PyObject *_res = NULL; - short beforeID; + MenuID beforeID; if (!PyArg_ParseTuple(_args, "h", &beforeID)) return NULL; @@ -377,6 +401,25 @@ static PyObject *MenuObj_MacInsertMenu(_self, _args) return _res; } +static PyObject *MenuObj_MacCheckMenuItem(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + short item; + Boolean checked; + if (!PyArg_ParseTuple(_args, "hb", + &item, + &checked)) + return NULL; + MacCheckMenuItem(_self->ob_itself, + item, + checked); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + #if !TARGET_API_MAC_CARBON static PyObject *MenuObj_CheckItem(_self, _args) @@ -629,7 +672,7 @@ static PyObject *MenuObj_SetMenuItemCommandID(_self, _args) PyObject *_res = NULL; OSErr _err; SInt16 inItem; - UInt32 inCommandID; + MenuCommand inCommandID; if (!PyArg_ParseTuple(_args, "hl", &inItem, &inCommandID)) @@ -650,7 +693,7 @@ static PyObject *MenuObj_GetMenuItemCommandID(_self, _args) PyObject *_res = NULL; OSErr _err; SInt16 inItem; - UInt32 outCommandID; + MenuCommand outCommandID; if (!PyArg_ParseTuple(_args, "h", &inItem)) return NULL; @@ -799,7 +842,7 @@ static PyObject *MenuObj_SetMenuItemHierarchicalID(_self, _args) PyObject *_res = NULL; OSErr _err; SInt16 inItem; - SInt16 inHierID; + MenuID inHierID; if (!PyArg_ParseTuple(_args, "hh", &inItem, &inHierID)) @@ -820,7 +863,7 @@ static PyObject *MenuObj_GetMenuItemHierarchicalID(_self, _args) PyObject *_res = NULL; OSErr _err; SInt16 inItem; - SInt16 outHierID; + MenuID outHierID; if (!PyArg_ParseTuple(_args, "h", &inItem)) return NULL; @@ -1008,8 +1051,8 @@ static PyObject *MenuObj_MacEnableMenuItem(_self, _args) PyObject *_args; { PyObject *_res = NULL; - UInt16 item; - if (!PyArg_ParseTuple(_args, "H", + MenuItemIndex item; + if (!PyArg_ParseTuple(_args, "h", &item)) return NULL; MacEnableMenuItem(_self->ob_itself, @@ -1024,8 +1067,8 @@ static PyObject *MenuObj_DisableMenuItem(_self, _args) PyObject *_args; { PyObject *_res = NULL; - UInt16 item; - if (!PyArg_ParseTuple(_args, "H", + MenuItemIndex item; + if (!PyArg_ParseTuple(_args, "h", &item)) return NULL; DisableMenuItem(_self->ob_itself, @@ -1041,8 +1084,8 @@ static PyObject *MenuObj_IsMenuItemEnabled(_self, _args) { PyObject *_res = NULL; Boolean _rv; - UInt16 item; - if (!PyArg_ParseTuple(_args, "H", + MenuItemIndex item; + if (!PyArg_ParseTuple(_args, "h", &item)) return NULL; _rv = IsMenuItemEnabled(_self->ob_itself, @@ -1057,8 +1100,8 @@ static PyObject *MenuObj_EnableMenuItemIcon(_self, _args) PyObject *_args; { PyObject *_res = NULL; - UInt16 item; - if (!PyArg_ParseTuple(_args, "H", + MenuItemIndex item; + if (!PyArg_ParseTuple(_args, "h", &item)) return NULL; EnableMenuItemIcon(_self->ob_itself, @@ -1073,8 +1116,8 @@ static PyObject *MenuObj_DisableMenuItemIcon(_self, _args) PyObject *_args; { PyObject *_res = NULL; - UInt16 item; - if (!PyArg_ParseTuple(_args, "H", + MenuItemIndex item; + if (!PyArg_ParseTuple(_args, "h", &item)) return NULL; DisableMenuItemIcon(_self->ob_itself, @@ -1090,8 +1133,8 @@ static PyObject *MenuObj_IsMenuItemIconEnabled(_self, _args) { PyObject *_res = NULL; Boolean _rv; - UInt16 item; - if (!PyArg_ParseTuple(_args, "H", + MenuItemIndex item; + if (!PyArg_ParseTuple(_args, "h", &item)) return NULL; _rv = IsMenuItemIconEnabled(_self->ob_itself, @@ -1101,6 +1144,539 @@ static PyObject *MenuObj_IsMenuItemIconEnabled(_self, _args) return _res; } +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_GetMenuItemPropertyAttributes(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + MenuItemIndex item; + OSType propertyCreator; + OSType propertyTag; + UInt32 attributes; + if (!PyArg_ParseTuple(_args, "hO&O&", + &item, + PyMac_GetOSType, &propertyCreator, + PyMac_GetOSType, &propertyTag)) + return NULL; + _err = GetMenuItemPropertyAttributes(_self->ob_itself, + item, + 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 *MenuObj_ChangeMenuItemPropertyAttributes(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + MenuItemIndex item; + OSType propertyCreator; + OSType propertyTag; + UInt32 attributesToSet; + UInt32 attributesToClear; + if (!PyArg_ParseTuple(_args, "hO&O&ll", + &item, + PyMac_GetOSType, &propertyCreator, + PyMac_GetOSType, &propertyTag, + &attributesToSet, + &attributesToClear)) + return NULL; + _err = ChangeMenuItemPropertyAttributes(_self->ob_itself, + item, + propertyCreator, + propertyTag, + attributesToSet, + attributesToClear); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_GetMenuAttributes(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + MenuAttributes outAttributes; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = GetMenuAttributes(_self->ob_itself, + &outAttributes); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + outAttributes); + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_ChangeMenuAttributes(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + MenuAttributes setTheseAttributes; + MenuAttributes clearTheseAttributes; + if (!PyArg_ParseTuple(_args, "ll", + &setTheseAttributes, + &clearTheseAttributes)) + return NULL; + _err = ChangeMenuAttributes(_self->ob_itself, + setTheseAttributes, + clearTheseAttributes); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_GetMenuItemAttributes(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + MenuItemIndex item; + MenuItemAttributes outAttributes; + if (!PyArg_ParseTuple(_args, "h", + &item)) + return NULL; + _err = GetMenuItemAttributes(_self->ob_itself, + item, + &outAttributes); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + outAttributes); + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_ChangeMenuItemAttributes(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + MenuItemIndex item; + MenuItemAttributes setTheseAttributes; + MenuItemAttributes clearTheseAttributes; + if (!PyArg_ParseTuple(_args, "hll", + &item, + &setTheseAttributes, + &clearTheseAttributes)) + return NULL; + _err = ChangeMenuItemAttributes(_self->ob_itself, + item, + setTheseAttributes, + clearTheseAttributes); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_DisableAllMenuItems(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + DisableAllMenuItems(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_EnableAllMenuItems(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + EnableAllMenuItems(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_MenuHasEnabledItems(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Boolean _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = MenuHasEnabledItems(_self->ob_itself); + _res = Py_BuildValue("b", + _rv); + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_CountMenuItemsWithCommandID(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ItemCount _rv; + MenuCommand commandID; + if (!PyArg_ParseTuple(_args, "l", + &commandID)) + return NULL; + _rv = CountMenuItemsWithCommandID(_self->ob_itself, + commandID); + _res = Py_BuildValue("l", + _rv); + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_GetIndMenuItemWithCommandID(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + MenuCommand commandID; + UInt32 itemIndex; + MenuHandle outMenu; + MenuItemIndex outIndex; + if (!PyArg_ParseTuple(_args, "ll", + &commandID, + &itemIndex)) + return NULL; + _err = GetIndMenuItemWithCommandID(_self->ob_itself, + commandID, + itemIndex, + &outMenu, + &outIndex); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&h", + MenuObj_New, outMenu, + outIndex); + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_EnableMenuCommand(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + MenuCommand commandID; + if (!PyArg_ParseTuple(_args, "l", + &commandID)) + return NULL; + EnableMenuCommand(_self->ob_itself, + commandID); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_DisableMenuCommand(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + MenuCommand commandID; + if (!PyArg_ParseTuple(_args, "l", + &commandID)) + return NULL; + DisableMenuCommand(_self->ob_itself, + commandID); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_IsMenuCommandEnabled(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Boolean _rv; + MenuCommand commandID; + if (!PyArg_ParseTuple(_args, "l", + &commandID)) + return NULL; + _rv = IsMenuCommandEnabled(_self->ob_itself, + commandID); + _res = Py_BuildValue("b", + _rv); + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_GetMenuCommandPropertySize(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + MenuCommand commandID; + OSType propertyCreator; + OSType propertyTag; + ByteCount size; + if (!PyArg_ParseTuple(_args, "lO&O&", + &commandID, + PyMac_GetOSType, &propertyCreator, + PyMac_GetOSType, &propertyTag)) + return NULL; + _err = GetMenuCommandPropertySize(_self->ob_itself, + commandID, + propertyCreator, + propertyTag, + &size); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + size); + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_RemoveMenuCommandProperty(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + MenuCommand commandID; + OSType propertyCreator; + OSType propertyTag; + if (!PyArg_ParseTuple(_args, "lO&O&", + &commandID, + PyMac_GetOSType, &propertyCreator, + PyMac_GetOSType, &propertyTag)) + return NULL; + _err = RemoveMenuCommandProperty(_self->ob_itself, + commandID, + propertyCreator, + propertyTag); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_CreateStandardFontMenu(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + MenuItemIndex afterItem; + MenuID firstHierMenuID; + OptionBits options; + ItemCount outHierMenuCount; + if (!PyArg_ParseTuple(_args, "hhl", + &afterItem, + &firstHierMenuID, + &options)) + return NULL; + _err = CreateStandardFontMenu(_self->ob_itself, + afterItem, + firstHierMenuID, + options, + &outHierMenuCount); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + outHierMenuCount); + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_UpdateStandardFontMenu(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + ItemCount outHierMenuCount; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = UpdateStandardFontMenu(_self->ob_itself, + &outHierMenuCount); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + outHierMenuCount); + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *MenuObj_GetFontFamilyFromMenuSelection(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + MenuItemIndex item; + FMFontFamily outFontFamily; + FMFontStyle outStyle; + if (!PyArg_ParseTuple(_args, "h", + &item)) + return NULL; + _err = GetFontFamilyFromMenuSelection(_self->ob_itself, + item, + &outFontFamily, + &outStyle); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("hh", + outFontFamily, + outStyle); + return _res; +} +#endif + +static PyObject *MenuObj_GetMenuID(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + MenuID _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMenuID(_self->ob_itself); + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *MenuObj_GetMenuWidth(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + SInt16 _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMenuWidth(_self->ob_itself); + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *MenuObj_GetMenuHeight(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + SInt16 _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMenuHeight(_self->ob_itself); + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *MenuObj_SetMenuID(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + MenuID menuID; + if (!PyArg_ParseTuple(_args, "h", + &menuID)) + return NULL; + SetMenuID(_self->ob_itself, + menuID); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MenuObj_SetMenuWidth(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + SInt16 width; + if (!PyArg_ParseTuple(_args, "h", + &width)) + return NULL; + SetMenuWidth(_self->ob_itself, + width); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MenuObj_SetMenuHeight(_self, _args) + MenuObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + SInt16 height; + if (!PyArg_ParseTuple(_args, "h", + &height)) + return NULL; + SetMenuHeight(_self->ob_itself, + height); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + static PyObject *MenuObj_as_Resource(_self, _args) MenuObject *_self; PyObject *_args; @@ -1171,6 +1747,8 @@ static PyMethodDef MenuObj_methods[] = { "() -> None"}, {"CalcMenuSize", (PyCFunction)MenuObj_CalcMenuSize, 1, "() -> None"}, + {"CountMenuItems", (PyCFunction)MenuObj_CountMenuItems, 1, + "() -> (short _rv)"}, #if !TARGET_API_MAC_CARBON {"CountMItems", (PyCFunction)MenuObj_CountMItems, 1, @@ -1201,11 +1779,13 @@ static PyMethodDef MenuObj_methods[] = { {"AppendMenuItemText", (PyCFunction)MenuObj_AppendMenuItemText, 1, "(Str255 inString) -> None"}, {"InsertMenuItemText", (PyCFunction)MenuObj_InsertMenuItemText, 1, - "(Str255 inString, UInt16 afterItem) -> None"}, + "(Str255 inString, MenuItemIndex afterItem) -> None"}, {"PopUpMenuSelect", (PyCFunction)MenuObj_PopUpMenuSelect, 1, "(short top, short left, short popUpItem) -> (long _rv)"}, {"MacInsertMenu", (PyCFunction)MenuObj_MacInsertMenu, 1, - "(short beforeID) -> None"}, + "(MenuID beforeID) -> None"}, + {"MacCheckMenuItem", (PyCFunction)MenuObj_MacCheckMenuItem, 1, + "(short item, Boolean checked) -> None"}, #if !TARGET_API_MAC_CARBON {"CheckItem", (PyCFunction)MenuObj_CheckItem, 1, @@ -1242,9 +1822,9 @@ static PyMethodDef MenuObj_methods[] = { "(short item) -> None"}, #endif {"SetMenuItemCommandID", (PyCFunction)MenuObj_SetMenuItemCommandID, 1, - "(SInt16 inItem, UInt32 inCommandID) -> None"}, + "(SInt16 inItem, MenuCommand inCommandID) -> None"}, {"GetMenuItemCommandID", (PyCFunction)MenuObj_GetMenuItemCommandID, 1, - "(SInt16 inItem) -> (UInt32 outCommandID)"}, + "(SInt16 inItem) -> (MenuCommand outCommandID)"}, {"SetMenuItemModifiers", (PyCFunction)MenuObj_SetMenuItemModifiers, 1, "(SInt16 inItem, UInt8 inModifiers) -> None"}, {"GetMenuItemModifiers", (PyCFunction)MenuObj_GetMenuItemModifiers, 1, @@ -1258,9 +1838,9 @@ static PyMethodDef MenuObj_methods[] = { {"GetMenuItemTextEncoding", (PyCFunction)MenuObj_GetMenuItemTextEncoding, 1, "(SInt16 inItem) -> (TextEncoding outScriptID)"}, {"SetMenuItemHierarchicalID", (PyCFunction)MenuObj_SetMenuItemHierarchicalID, 1, - "(SInt16 inItem, SInt16 inHierID) -> None"}, + "(SInt16 inItem, MenuID inHierID) -> None"}, {"GetMenuItemHierarchicalID", (PyCFunction)MenuObj_GetMenuItemHierarchicalID, 1, - "(SInt16 inItem) -> (SInt16 outHierID)"}, + "(SInt16 inItem) -> (MenuID outHierID)"}, {"SetMenuItemFontID", (PyCFunction)MenuObj_SetMenuItemFontID, 1, "(SInt16 inItem, SInt16 inFontID) -> None"}, {"GetMenuItemFontID", (PyCFunction)MenuObj_GetMenuItemFontID, 1, @@ -1284,17 +1864,124 @@ static PyMethodDef MenuObj_methods[] = { {"GetMenuItemKeyGlyph", (PyCFunction)MenuObj_GetMenuItemKeyGlyph, 1, "(SInt16 inItem) -> (SInt16 outGlyph)"}, {"MacEnableMenuItem", (PyCFunction)MenuObj_MacEnableMenuItem, 1, - "(UInt16 item) -> None"}, + "(MenuItemIndex item) -> None"}, {"DisableMenuItem", (PyCFunction)MenuObj_DisableMenuItem, 1, - "(UInt16 item) -> None"}, + "(MenuItemIndex item) -> None"}, {"IsMenuItemEnabled", (PyCFunction)MenuObj_IsMenuItemEnabled, 1, - "(UInt16 item) -> (Boolean _rv)"}, + "(MenuItemIndex item) -> (Boolean _rv)"}, {"EnableMenuItemIcon", (PyCFunction)MenuObj_EnableMenuItemIcon, 1, - "(UInt16 item) -> None"}, + "(MenuItemIndex item) -> None"}, {"DisableMenuItemIcon", (PyCFunction)MenuObj_DisableMenuItemIcon, 1, - "(UInt16 item) -> None"}, + "(MenuItemIndex item) -> None"}, {"IsMenuItemIconEnabled", (PyCFunction)MenuObj_IsMenuItemIconEnabled, 1, - "(UInt16 item) -> (Boolean _rv)"}, + "(MenuItemIndex item) -> (Boolean _rv)"}, + +#if TARGET_API_MAC_CARBON + {"GetMenuItemPropertyAttributes", (PyCFunction)MenuObj_GetMenuItemPropertyAttributes, 1, + "(MenuItemIndex item, OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"ChangeMenuItemPropertyAttributes", (PyCFunction)MenuObj_ChangeMenuItemPropertyAttributes, 1, + "(MenuItemIndex item, OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"}, +#endif + +#if TARGET_API_MAC_CARBON + {"GetMenuAttributes", (PyCFunction)MenuObj_GetMenuAttributes, 1, + "() -> (MenuAttributes outAttributes)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"ChangeMenuAttributes", (PyCFunction)MenuObj_ChangeMenuAttributes, 1, + "(MenuAttributes setTheseAttributes, MenuAttributes clearTheseAttributes) -> None"}, +#endif + +#if TARGET_API_MAC_CARBON + {"GetMenuItemAttributes", (PyCFunction)MenuObj_GetMenuItemAttributes, 1, + "(MenuItemIndex item) -> (MenuItemAttributes outAttributes)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"ChangeMenuItemAttributes", (PyCFunction)MenuObj_ChangeMenuItemAttributes, 1, + "(MenuItemIndex item, MenuItemAttributes setTheseAttributes, MenuItemAttributes clearTheseAttributes) -> None"}, +#endif + +#if TARGET_API_MAC_CARBON + {"DisableAllMenuItems", (PyCFunction)MenuObj_DisableAllMenuItems, 1, + "() -> None"}, +#endif + +#if TARGET_API_MAC_CARBON + {"EnableAllMenuItems", (PyCFunction)MenuObj_EnableAllMenuItems, 1, + "() -> None"}, +#endif + +#if TARGET_API_MAC_CARBON + {"MenuHasEnabledItems", (PyCFunction)MenuObj_MenuHasEnabledItems, 1, + "() -> (Boolean _rv)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"CountMenuItemsWithCommandID", (PyCFunction)MenuObj_CountMenuItemsWithCommandID, 1, + "(MenuCommand commandID) -> (ItemCount _rv)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"GetIndMenuItemWithCommandID", (PyCFunction)MenuObj_GetIndMenuItemWithCommandID, 1, + "(MenuCommand commandID, UInt32 itemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"EnableMenuCommand", (PyCFunction)MenuObj_EnableMenuCommand, 1, + "(MenuCommand commandID) -> None"}, +#endif + +#if TARGET_API_MAC_CARBON + {"DisableMenuCommand", (PyCFunction)MenuObj_DisableMenuCommand, 1, + "(MenuCommand commandID) -> None"}, +#endif + +#if TARGET_API_MAC_CARBON + {"IsMenuCommandEnabled", (PyCFunction)MenuObj_IsMenuCommandEnabled, 1, + "(MenuCommand commandID) -> (Boolean _rv)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"GetMenuCommandPropertySize", (PyCFunction)MenuObj_GetMenuCommandPropertySize, 1, + "(MenuCommand commandID, OSType propertyCreator, OSType propertyTag) -> (ByteCount size)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"RemoveMenuCommandProperty", (PyCFunction)MenuObj_RemoveMenuCommandProperty, 1, + "(MenuCommand commandID, OSType propertyCreator, OSType propertyTag) -> None"}, +#endif + +#if TARGET_API_MAC_CARBON + {"CreateStandardFontMenu", (PyCFunction)MenuObj_CreateStandardFontMenu, 1, + "(MenuItemIndex afterItem, MenuID firstHierMenuID, OptionBits options) -> (ItemCount outHierMenuCount)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"UpdateStandardFontMenu", (PyCFunction)MenuObj_UpdateStandardFontMenu, 1, + "() -> (ItemCount outHierMenuCount)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"GetFontFamilyFromMenuSelection", (PyCFunction)MenuObj_GetFontFamilyFromMenuSelection, 1, + "(MenuItemIndex item) -> (FMFontFamily outFontFamily, FMFontStyle outStyle)"}, +#endif + {"GetMenuID", (PyCFunction)MenuObj_GetMenuID, 1, + "() -> (MenuID _rv)"}, + {"GetMenuWidth", (PyCFunction)MenuObj_GetMenuWidth, 1, + "() -> (SInt16 _rv)"}, + {"GetMenuHeight", (PyCFunction)MenuObj_GetMenuHeight, 1, + "() -> (SInt16 _rv)"}, + {"SetMenuID", (PyCFunction)MenuObj_SetMenuID, 1, + "(MenuID menuID) -> None"}, + {"SetMenuWidth", (PyCFunction)MenuObj_SetMenuWidth, 1, + "(SInt16 width) -> None"}, + {"SetMenuHeight", (PyCFunction)MenuObj_SetMenuHeight, 1, + "(SInt16 height) -> None"}, {"as_Resource", (PyCFunction)MenuObj_as_Resource, 1, "() -> (Handle _rv)"}, {"AppendMenu", (PyCFunction)MenuObj_AppendMenu, 1, @@ -1385,7 +2072,7 @@ static PyObject *Menu_NewMenu(_self, _args) { PyObject *_res = NULL; MenuHandle _rv; - short menuID; + MenuID menuID; Str255 menuTitle; if (!PyArg_ParseTuple(_args, "hO&", &menuID, @@ -1414,6 +2101,31 @@ static PyObject *Menu_MacGetMenu(_self, _args) return _res; } +#if TARGET_API_MAC_CARBON + +static PyObject *Menu_CreateNewMenu(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + MenuID menuID; + MenuAttributes menuAttributes; + MenuHandle outMenuRef; + if (!PyArg_ParseTuple(_args, "hl", + &menuID, + &menuAttributes)) + return NULL; + _err = CreateNewMenu(menuID, + menuAttributes, + &outMenuRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + MenuObj_New, outMenuRef); + return _res; +} +#endif + static PyObject *Menu_MenuKey(_self, _args) PyObject *_self; PyObject *_args; @@ -1521,7 +2233,7 @@ static PyObject *Menu_HiliteMenu(_self, _args) PyObject *_args; { PyObject *_res = NULL; - short menuID; + MenuID menuID; if (!PyArg_ParseTuple(_args, "h", &menuID)) return NULL; @@ -1536,7 +2248,7 @@ static PyObject *Menu_GetNewMBar(_self, _args) PyObject *_args; { PyObject *_res = NULL; - Handle _rv; + MenuBarHandle _rv; short menuBarID; if (!PyArg_ParseTuple(_args, "h", &menuBarID)) @@ -1552,7 +2264,7 @@ static PyObject *Menu_GetMenuBar(_self, _args) PyObject *_args; { PyObject *_res = NULL; - Handle _rv; + MenuBarHandle _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetMenuBar(); @@ -1566,23 +2278,65 @@ static PyObject *Menu_SetMenuBar(_self, _args) PyObject *_args; { PyObject *_res = NULL; - Handle menuList; + MenuBarHandle mbar; if (!PyArg_ParseTuple(_args, "O&", - ResObj_Convert, &menuList)) + ResObj_Convert, &mbar)) return NULL; - SetMenuBar(menuList); + SetMenuBar(mbar); Py_INCREF(Py_None); _res = Py_None; return _res; } +#if TARGET_API_MAC_CARBON + +static PyObject *Menu_DuplicateMenuBar(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + MenuBarHandle mbar; + MenuBarHandle outBar; + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &mbar)) + return NULL; + _err = DuplicateMenuBar(mbar, + &outBar); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, outBar); + return _res; +} +#endif + +#if TARGET_API_MAC_CARBON + +static PyObject *Menu_DisposeMenuBar(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + MenuBarHandle mbar; + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &mbar)) + return NULL; + _err = DisposeMenuBar(mbar); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} +#endif + static PyObject *Menu_GetMenuHandle(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; MenuHandle _rv; - short menuID; + MenuID menuID; if (!PyArg_ParseTuple(_args, "h", &menuID)) return NULL; @@ -1597,7 +2351,7 @@ static PyObject *Menu_MacDeleteMenu(_self, _args) PyObject *_args; { PyObject *_res = NULL; - short menuID; + MenuID menuID; if (!PyArg_ParseTuple(_args, "h", &menuID)) return NULL; @@ -1620,6 +2374,21 @@ static PyObject *Menu_ClearMenuBar(_self, _args) return _res; } +static PyObject *Menu_SetMenuFlashCount(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + short count; + if (!PyArg_ParseTuple(_args, "h", + &count)) + return NULL; + SetMenuFlashCount(count); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + #if !TARGET_API_MAC_CARBON static PyObject *Menu_SetMenuFlash(_self, _args) @@ -1643,7 +2412,7 @@ static PyObject *Menu_FlashMenuBar(_self, _args) PyObject *_args; { PyObject *_res = NULL; - short menuID; + MenuID menuID; if (!PyArg_ParseTuple(_args, "h", &menuID)) return NULL; @@ -1735,7 +2504,7 @@ static PyObject *Menu_DeleteMCEntries(_self, _args) PyObject *_args; { PyObject *_res = NULL; - short menuID; + MenuID menuID; short menuItem; if (!PyArg_ParseTuple(_args, "hh", &menuID, @@ -1869,9 +2638,14 @@ static PyMethodDef Menu_methods[] = { "() -> None"}, #endif {"NewMenu", (PyCFunction)Menu_NewMenu, 1, - "(short menuID, Str255 menuTitle) -> (MenuHandle _rv)"}, + "(MenuID menuID, Str255 menuTitle) -> (MenuHandle _rv)"}, {"MacGetMenu", (PyCFunction)Menu_MacGetMenu, 1, "(short resourceID) -> (MenuHandle _rv)"}, + +#if TARGET_API_MAC_CARBON + {"CreateNewMenu", (PyCFunction)Menu_CreateNewMenu, 1, + "(MenuID menuID, MenuAttributes menuAttributes) -> (MenuHandle outMenuRef)"}, +#endif {"MenuKey", (PyCFunction)Menu_MenuKey, 1, "(CharParameter ch) -> (long _rv)"}, {"MenuSelect", (PyCFunction)Menu_MenuSelect, 1, @@ -1887,26 +2661,38 @@ static PyMethodDef Menu_methods[] = { {"InvalMenuBar", (PyCFunction)Menu_InvalMenuBar, 1, "() -> None"}, {"HiliteMenu", (PyCFunction)Menu_HiliteMenu, 1, - "(short menuID) -> None"}, + "(MenuID menuID) -> None"}, {"GetNewMBar", (PyCFunction)Menu_GetNewMBar, 1, - "(short menuBarID) -> (Handle _rv)"}, + "(short menuBarID) -> (MenuBarHandle _rv)"}, {"GetMenuBar", (PyCFunction)Menu_GetMenuBar, 1, - "() -> (Handle _rv)"}, + "() -> (MenuBarHandle _rv)"}, {"SetMenuBar", (PyCFunction)Menu_SetMenuBar, 1, - "(Handle menuList) -> None"}, + "(MenuBarHandle mbar) -> None"}, + +#if TARGET_API_MAC_CARBON + {"DuplicateMenuBar", (PyCFunction)Menu_DuplicateMenuBar, 1, + "(MenuBarHandle mbar) -> (MenuBarHandle outBar)"}, +#endif + +#if TARGET_API_MAC_CARBON + {"DisposeMenuBar", (PyCFunction)Menu_DisposeMenuBar, 1, + "(MenuBarHandle mbar) -> None"}, +#endif {"GetMenuHandle", (PyCFunction)Menu_GetMenuHandle, 1, - "(short menuID) -> (MenuHandle _rv)"}, + "(MenuID menuID) -> (MenuHandle _rv)"}, {"MacDeleteMenu", (PyCFunction)Menu_MacDeleteMenu, 1, - "(short menuID) -> None"}, + "(MenuID menuID) -> None"}, {"ClearMenuBar", (PyCFunction)Menu_ClearMenuBar, 1, "() -> None"}, + {"SetMenuFlashCount", (PyCFunction)Menu_SetMenuFlashCount, 1, + "(short count) -> None"}, #if !TARGET_API_MAC_CARBON {"SetMenuFlash", (PyCFunction)Menu_SetMenuFlash, 1, "(short count) -> None"}, #endif {"FlashMenuBar", (PyCFunction)Menu_FlashMenuBar, 1, - "(short menuID) -> None"}, + "(MenuID menuID) -> None"}, #if !TARGET_API_MAC_CARBON {"SystemEdit", (PyCFunction)Menu_SystemEdit, 1, @@ -1924,7 +2710,7 @@ static PyMethodDef Menu_methods[] = { {"HideMenuBar", (PyCFunction)Menu_HideMenuBar, 1, "() -> None"}, {"DeleteMCEntries", (PyCFunction)Menu_DeleteMCEntries, 1, - "(short menuID, short menuItem) -> None"}, + "(MenuID menuID, short menuItem) -> None"}, {"InitContextualMenus", (PyCFunction)Menu_InitContextualMenus, 1, "() -> None"}, {"IsShowContextualMenuClick", (PyCFunction)Menu_IsShowContextualMenuClick, 1, @@ -1961,7 +2747,7 @@ void initMenu() Menu_Error = PyMac_GetOSErrException(); if (Menu_Error == NULL || PyDict_SetItemString(d, "Error", Menu_Error) != 0) - Py_FatalError("can't initialize Menu.Error"); + return; Menu_Type.ob_type = &PyType_Type; Py_INCREF(&Menu_Type); if (PyDict_SetItemString(d, "MenuType", (PyObject *)&Menu_Type) != 0) diff --git a/Mac/Modules/menu/menuscan.py b/Mac/Modules/menu/menuscan.py index 965172a..c9b1b42 100644 --- a/Mac/Modules/menu/menuscan.py +++ b/Mac/Modules/menu/menuscan.py @@ -38,6 +38,10 @@ class MyScanner(Scanner): "GetMenuItemPropertySize", "SetMenuItemProperty", "RemoveMenuItemProperty", + "SetMenuCommandProperty", + "GetMenuCommandProperty", + "GetMenuTitle", # Funny arg/returnvalue + "SetMenuTitle", ] def makegreylist(self): @@ -55,6 +59,31 @@ class MyScanner(Scanner): 'SetMenuFlash', 'InitMenus', 'InitProcMenu', + ]), + ('#if TARGET_API_MAC_CARBON', [ + 'DisposeMenuBar', + 'DuplicateMenuBar', + 'CreateNewMenu', + 'GetFontFamilyFromMenuSelection', + 'UpdateStandardFontMenu', + 'CreateStandardFontMenu', + 'RemoveMenuCommandProperty', + 'GetMenuCommandPropertySize', + 'IsMenuCommandEnabled', + 'DisableMenuCommand', + 'EnableMenuCommand', + 'GetIndMenuItemWithCommandID', + 'CountMenuItemsWithCommandID', + 'MenuHasEnabledItems', + 'EnableAllMenuItems', + 'DisableAllMenuItems', + 'ChangeMenuItemAttributes', + 'GetMenuItemAttributes', + 'ChangeMenuAttributes', + 'GetMenuAttributes', + 'ChangeMenuItemPropertyAttributes', + 'GetMenuItemPropertyAttributes', + ])] def makeblacklisttypes(self): @@ -64,6 +93,9 @@ class MyScanner(Scanner): 'MCTablePtr', 'AEDesc_ptr', # For now: doable, but not easy 'ProcessSerialNumber', # ditto + "MenuDefSpecPtr", # Too difficult for now + "MenuDefSpec_ptr", # ditto + "MenuTrackingData", ] def makerepairinstructions(self): diff --git a/Mac/Modules/menu/menusupport.py b/Mac/Modules/menu/menusupport.py index 1325e10..20b4f36 100644 --- a/Mac/Modules/menu/menusupport.py +++ b/Mac/Modules/menu/menusupport.py @@ -25,13 +25,30 @@ from macsupport import * MenuHandle = OpaqueByValueType(OBJECTTYPE, OBJECTPREFIX) MenuRef = MenuHandle Handle = OpaqueByValueType("Handle", "ResObj") - +MenuBarHandle = OpaqueByValueType("MenuBarHandle", "ResObj") +MenuID = Type("MenuID", "h") +MenuItemIndex = Type("MenuItemIndex", "h") +MenuCommand = Type("MenuCommand", "l") +MenuAttributes = Type("MenuAttributes", "l") +MenuItemAttributes = Type("MenuItemAttributes", "l") unsigned_char = Type('unsigned char', 'b') +FMFontFamily = Type("FMFontFamily", "h") +FMFontStyle = Type("FMFontStyle", "h") includestuff = includestuff + """ #include <Devices.h> /* Defines OpenDeskAcc in universal headers */ #include <%s>""" % MACHEADERFILE + """ +#if !ACCESSOR_CALLS_ARE_FUNCTIONS +#define GetMenuID(menu) ((*(menu))->menuID) +#define GetMenuWidth(menu) ((*(menu))->menuWidth) +#define GetMenuHeight(menu) ((*(menu))->menuHeight) + +#define SetMenuID(menu, id) ((*(menu))->menuID = (id)) +#define SetMenuWidth(menu, width) ((*(menu))->menuWidth = (width)) +#define SetMenuHeight(menu, height) ((*(menu))->menuHeight = (height)) +#endif + #define as_Menu(h) ((MenuHandle)h) #define as_Resource(h) ((Handle)h) """ |