Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity
cpython/Mac/Modules/ctl/_Ctlmodule.c

5816 lines
192 KiB
C
Raw Blame History

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