Import Upstream version 2.7.18
This commit is contained in:
geos_one
5814
Mac/Modules/ctl/_Ctlmodule.c
Normal file
5814
Mac/Modules/ctl/_Ctlmodule.c
Normal file
File diff suppressed because it is too large
Load Diff
45
Mac/Modules/ctl/ctledit.py
Normal file
45
Mac/Modules/ctl/ctledit.py
Normal file
@@ -0,0 +1,45 @@
|
||||
# FindControlUnderMouse() returns an existing control, not a new one,
|
||||
# so create this one by hand.
|
||||
f = Function(ExistingControlHandle, 'FindControlUnderMouse',
|
||||
(Point, 'inWhere', InMode),
|
||||
(WindowRef, 'inWindow', InMode),
|
||||
(SInt16, 'outPart', OutMode),
|
||||
)
|
||||
functions.append(f)
|
||||
|
||||
f = Function(ControlHandle, 'as_Control',
|
||||
(Handle, 'h', InMode))
|
||||
functions.append(f)
|
||||
|
||||
f = Method(Handle, 'as_Resource', (ControlHandle, 'ctl', InMode))
|
||||
methods.append(f)
|
||||
|
||||
f = Method(void, 'GetControlRect', (ControlHandle, 'ctl', InMode), (Rect, 'rect', OutMode))
|
||||
methods.append(f)
|
||||
|
||||
DisposeControl_body = """
|
||||
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;
|
||||
"""
|
||||
|
||||
f = ManualGenerator("DisposeControl", DisposeControl_body)
|
||||
f.docstring = lambda : "() -> None"
|
||||
|
||||
methods.append(f)
|
||||
|
||||
# All CreateXxxXxxControl() functions return a new object in an output
|
||||
# parameter; these should however be managed by us (we're creating them
|
||||
# after all), so set the type to ControlRef.
|
||||
for f in functions:
|
||||
if f.name.startswith("Create"):
|
||||
v = f.argumentList[-1]
|
||||
if v.type == ExistingControlHandle:
|
||||
v.type = ControlRef
|
||||
171
Mac/Modules/ctl/ctlscan.py
Normal file
171
Mac/Modules/ctl/ctlscan.py
Normal file
@@ -0,0 +1,171 @@
|
||||
# Scan <Controls.h>, generating ctlgen.py.
|
||||
import sys
|
||||
from bgenlocations import TOOLBOXDIR, BGENDIR
|
||||
sys.path.append(BGENDIR)
|
||||
|
||||
from scantools import Scanner
|
||||
|
||||
def main():
|
||||
# input = "Controls.h" # Universal Headers < 3.3
|
||||
input = ["Controls.h", "ControlDefinitions.h"] # Universal Headers >= 3.3
|
||||
output = "ctlgen.py"
|
||||
defsoutput = TOOLBOXDIR + "Controls.py"
|
||||
scanner = MyScanner(input, output, defsoutput)
|
||||
scanner.scan()
|
||||
scanner.close()
|
||||
print "=== Testing definitions output code ==="
|
||||
execfile(defsoutput, {}, {})
|
||||
print "=== Done scanning and generating, now doing 'import ctlsupport' ==="
|
||||
import ctlsupport
|
||||
print "=== Done. It's up to you to compile Ctlmodule.c ==="
|
||||
|
||||
class MyScanner(Scanner):
|
||||
|
||||
def destination(self, type, name, arglist):
|
||||
classname = "Function"
|
||||
listname = "functions"
|
||||
if arglist:
|
||||
t, n, m = arglist[0]
|
||||
if t in ("ControlHandle", "ControlRef") and m == "InMode":
|
||||
classname = "Method"
|
||||
listname = "methods"
|
||||
return classname, listname
|
||||
|
||||
def writeinitialdefs(self):
|
||||
self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
|
||||
self.defsfile.write("from Carbon.TextEdit import *\n")
|
||||
self.defsfile.write("from Carbon.QuickDraw import *\n")
|
||||
self.defsfile.write("from Carbon.Dragconst import *\n")
|
||||
self.defsfile.write("from Carbon.CarbonEvents import *\n")
|
||||
self.defsfile.write("from Carbon.Appearance import *\n")
|
||||
self.defsfile.write("kDataBrowserItemAnyState = -1\n")
|
||||
self.defsfile.write("kControlBevelButtonCenterPopupGlyphTag = -1\n")
|
||||
self.defsfile.write("kDataBrowserClientPropertyFlagsMask = 0xFF000000\n")
|
||||
self.defsfile.write("\n")
|
||||
|
||||
def makeblacklistnames(self):
|
||||
return [
|
||||
'FindControlUnderMouse', # Generated manually, returns an existing control, not a new one.
|
||||
'DisposeControl', # Generated manually
|
||||
'KillControls', # Implied by close of dialog
|
||||
'SetCtlAction',
|
||||
'TrackControl', # Generated manually
|
||||
'HandleControlClick', # Generated manually
|
||||
'SetControlData', # Generated manually
|
||||
'GetControlData', # Generated manually
|
||||
'kControlBevelButtonCenterPopupGlyphTag', # Constant with funny definition
|
||||
'kDataBrowserClientPropertyFlagsMask', # ditto
|
||||
'kDataBrowserItemAnyState', # and ditto
|
||||
# The following are unavailable for static 68k (appearance manager)
|
||||
## 'GetBevelButtonMenuValue',
|
||||
## 'SetBevelButtonMenuValue',
|
||||
## 'GetBevelButtonMenuHandle',
|
||||
## 'SetBevelButtonTransform',
|
||||
'SetBevelButtonGraphicAlignment',
|
||||
'SetBevelButtonTextAlignment',
|
||||
'SetBevelButtonTextPlacement',
|
||||
## 'SetImageWellTransform',
|
||||
## 'GetTabContentRect',
|
||||
## 'SetTabEnabled',
|
||||
## 'SetDisclosureTriangleLastValue',
|
||||
## # Unavailable in CW Pro 3 libraries
|
||||
## 'SetUpControlTextColor',
|
||||
## # Unavailable in Jack's CW Pro 5.1 libraries
|
||||
## 'GetControlRegion',
|
||||
## 'RemoveControlProperty',
|
||||
## 'IsValidControlHandle',
|
||||
## 'SetControl32BitMinimum',
|
||||
## 'GetControl32BitMinimum',
|
||||
## 'SetControl32BitMaximum',
|
||||
## 'GetControl32BitMaximum',
|
||||
## 'SetControl32BitValue',
|
||||
## 'GetControl32BitValue',
|
||||
## 'SetControlViewSize',
|
||||
## 'GetControlViewSize',
|
||||
# Generally Bad News
|
||||
'GetControlProperty',
|
||||
'SetControlProperty',
|
||||
'GetControlPropertySize',
|
||||
'SendControlMessage', # Parameter changed from long to void* from UH3.3 to UH3.4
|
||||
'CreateTabsControl', # wrote manually
|
||||
'GetControlAction', # too much effort for too little usefulness
|
||||
|
||||
# too lazy for now
|
||||
'GetImageWellContentInfo',
|
||||
'GetBevelButtonContentInfo',
|
||||
# OS8 only
|
||||
'GetAuxiliaryControlRecord',
|
||||
'SetControlColor',
|
||||
]
|
||||
|
||||
def makeblacklisttypes(self):
|
||||
return [
|
||||
'ProcPtr',
|
||||
# 'ControlActionUPP',
|
||||
'Ptr',
|
||||
'ControlDefSpec', # Don't know how to do this yet
|
||||
'ControlDefSpec_ptr', # ditto
|
||||
'Collection', # Ditto
|
||||
# not-yet-supported stuff in Universal Headers 3.4:
|
||||
'ControlColorUPP',
|
||||
'ControlKind', # XXX easy: 2-tuple containing 2 OSType's
|
||||
# 'ControlTabEntry_ptr', # XXX needed for tabs
|
||||
# 'ControlButtonContentInfoPtr',
|
||||
# 'ControlButtonContentInfo', # XXX ugh: a union
|
||||
# 'ControlButtonContentInfo_ptr', # XXX ugh: a union
|
||||
'ListDefSpec_ptr', # XXX see _Listmodule.c, tricky but possible
|
||||
'DataBrowserItemID_ptr', # XXX array of UInt32, for BrowserView
|
||||
'DataBrowserItemUPP',
|
||||
'DataBrowserItemDataRef', # XXX void *
|
||||
'DataBrowserCallbacks', # difficult struct
|
||||
'DataBrowserCallbacks_ptr',
|
||||
'DataBrowserCustomCallbacks',
|
||||
'DataBrowserCustomCallbacks_ptr',
|
||||
## 'DataBrowserTableViewColumnDesc',
|
||||
## 'DataBrowserListViewColumnDesc',
|
||||
'CFDataRef',
|
||||
'DataBrowserListViewHeaderDesc', # difficult struct
|
||||
]
|
||||
|
||||
def makerepairinstructions(self):
|
||||
return [
|
||||
([("void_ptr", "*", "InMode"), ("long", "*", "InMode")],
|
||||
[("InBuffer", "*", "*")]),
|
||||
|
||||
([("void", "*", "OutMode"), ("long", "*", "InMode"),
|
||||
("long", "*", "OutMode")],
|
||||
[("VarVarOutBuffer", "*", "InOutMode")]),
|
||||
|
||||
## # For TrackControl
|
||||
## ([("ProcPtr", "actionProc", "InMode")],
|
||||
## [("FakeType('(ControlActionUPP)0')", "*", "*")]),
|
||||
## ([("ControlActionUPP", "actionProc", "InMode")],
|
||||
## [("FakeType('(ControlActionUPP)0')", "*", "*")]),
|
||||
|
||||
# For GetControlTitle
|
||||
([('Str255', 'title', 'InMode')],
|
||||
[('Str255', 'title', 'OutMode')]),
|
||||
|
||||
([("ControlHandle", "*", "OutMode")],
|
||||
[("ExistingControlHandle", "*", "*")]),
|
||||
([("ControlRef", "*", "OutMode")], # Ditto, for Universal Headers
|
||||
[("ExistingControlHandle", "*", "*")]),
|
||||
|
||||
([("Rect_ptr", "*", "ReturnMode")], # GetControlBounds
|
||||
[("void", "*", "ReturnMode")]),
|
||||
|
||||
([("DataBrowserListViewColumnDesc", "*", "OutMode")],
|
||||
[("DataBrowserListViewColumnDesc", "*", "InMode")]),
|
||||
|
||||
([("ControlButtonContentInfoPtr", 'outContent', "InMode")],
|
||||
[("ControlButtonContentInfoPtr", '*', "OutMode")]),
|
||||
|
||||
([("ControlButtonContentInfo", '*', "OutMode")],
|
||||
[("ControlButtonContentInfo", '*', "InMode")]),
|
||||
|
||||
([("ControlActionUPP", 'liveTrackingProc', "InMode")],
|
||||
[("ControlActionUPPNewControl", 'liveTrackingProc', "InMode")]),
|
||||
]
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
826
Mac/Modules/ctl/ctlsupport.py
Normal file
826
Mac/Modules/ctl/ctlsupport.py
Normal file
@@ -0,0 +1,826 @@
|
||||
# This script generates a Python interface for an Apple Macintosh Manager.
|
||||
# It uses the "bgen" package to generate C code.
|
||||
# The function specifications are generated by scanning the mamager's header file,
|
||||
# using the "scantools" package (customized for this particular manager).
|
||||
|
||||
import string
|
||||
|
||||
# Declarations that change for each manager
|
||||
MACHEADERFILE = 'Controls.h' # The Apple header file
|
||||
MODNAME = '_Ctl' # The name of the module
|
||||
OBJECTNAME = 'Control' # The basic name of the objects used here
|
||||
|
||||
# The following is *usually* unchanged but may still require tuning
|
||||
MODPREFIX = 'Ctl' # The prefix for module-wide routines
|
||||
OBJECTTYPE = OBJECTNAME + 'Handle' # The C type used to represent them
|
||||
OBJECTPREFIX = MODPREFIX + 'Obj' # The prefix for object methods
|
||||
INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner
|
||||
OUTPUTFILE = MODNAME + "module.c" # The file generated by this program
|
||||
|
||||
from macsupport import *
|
||||
|
||||
# Create the type objects
|
||||
|
||||
ControlHandle = OpaqueByValueType(OBJECTTYPE, OBJECTPREFIX)
|
||||
ControlRef = ControlHandle
|
||||
ExistingControlHandle = OpaqueByValueType(OBJECTTYPE, "CtlObj_WhichControl", "BUG")
|
||||
|
||||
RgnHandle = OpaqueByValueType("RgnHandle", "ResObj")
|
||||
CCTabHandle = OpaqueByValueType("CCTabHandle", "ResObj")
|
||||
AuxCtlHandle = OpaqueByValueType("AuxCtlHandle", "ResObj")
|
||||
ControlPartCode = Type("ControlPartCode", "h")
|
||||
DragConstraint = Type("DragConstraint", "H")
|
||||
ControlVariant = Type("ControlVariant", "h")
|
||||
IconTransformType = Type("IconTransformType", "h")
|
||||
EventModifiers = Type("EventModifiers", "H")
|
||||
ClickActivationResult = Type("ClickActivationResult", "l")
|
||||
ControlButtonGraphicAlignment = Type("ControlButtonGraphicAlignment", "h")
|
||||
ControlButtonTextAlignment = Type("ControlButtonTextAlignment", "h")
|
||||
ControlButtonTextPlacement = Type("ControlButtonTextPlacement", "h")
|
||||
ControlContentType = Type("ControlContentType", "h")
|
||||
ControlFocusPart = Type("ControlFocusPart", "h")
|
||||
|
||||
ControlFontStyleRec = OpaqueType('ControlFontStyleRec', 'ControlFontStyle')
|
||||
ControlFontStyleRec_ptr = ControlFontStyleRec
|
||||
ControlID = OpaqueType('ControlID', 'PyControlID')
|
||||
ControlID_ptr = ControlID
|
||||
|
||||
DragTrackingMessage = Type("DragTrackingMessage", "h")
|
||||
DragReference = OpaqueByValueType("DragReference", "DragObj")
|
||||
|
||||
CFStringRef = OpaqueByValueType("CFStringRef", "CFStringRefObj")
|
||||
CFMutableStringRef = OpaqueByValueType("CFMutableStringRef", "CFMutableStringRefObj")
|
||||
CFDataRef = OpaqueByValueType("CFDataRef", "CFDataRefObj")
|
||||
|
||||
ControlTabSize = UInt16
|
||||
ControlTabDirection = UInt16
|
||||
ControlPopupArrowOrientation = UInt16
|
||||
ControlPopupArrowSize = UInt16
|
||||
ControlClockType = UInt16
|
||||
ControlClockFlags = UInt32
|
||||
ControlRoundButtonSize = SInt16
|
||||
DataBrowserViewStyle = OSType
|
||||
DataBrowserItemID = UInt32
|
||||
DataBrowserEditCommand = UInt32
|
||||
DataBrowserSelectionAnchorDirection = UInt32
|
||||
DataBrowserItemState = UInt32
|
||||
DataBrowserPropertyID = UInt32
|
||||
DataBrowserRevealOptions = UInt8
|
||||
DataBrowserSortOrder = UInt16
|
||||
DataBrowserSelectionFlags = UInt32
|
||||
DataBrowserPropertyFlags = UInt32
|
||||
DataBrowserPropertyPart = OSType
|
||||
DataBrowserTableViewColumnID = DataBrowserPropertyID
|
||||
#DataBrowserTableViewColumnDesc = DataBrowserPropertyDesc
|
||||
DataBrowserTableViewHiliteStyle = UInt32
|
||||
DataBrowserTableViewRowIndex = UInt32
|
||||
DataBrowserTableViewColumnIndex = UInt32
|
||||
DataBrowserPropertyType = OSType
|
||||
ControlDisclosureTriangleOrientation = UInt16
|
||||
|
||||
DataBrowserTableViewColumnDesc = OpaqueType("DataBrowserTableViewColumnDesc",
|
||||
"DataBrowserTableViewColumnDesc")
|
||||
DataBrowserListViewColumnDesc = OpaqueType("DataBrowserListViewColumnDesc",
|
||||
"DataBrowserListViewColumnDesc")
|
||||
ControlButtonContentInfo = OpaqueType("ControlButtonContentInfo",
|
||||
"ControlButtonContentInfo")
|
||||
ControlButtonContentInfoPtr = ControlButtonContentInfo_ptr = ControlButtonContentInfo
|
||||
|
||||
ControlTabEntry_ptr = OpaqueType("ControlTabEntry", "ControlTabEntry")
|
||||
|
||||
ControlBevelThickness = UInt16
|
||||
ControlBevelButtonBehavior = UInt16
|
||||
ControlBevelButtonMenuBehavior = UInt16
|
||||
ControlBevelButtonMenuPlacement = UInt16
|
||||
ControlPushButtonIconAlignment = UInt16
|
||||
|
||||
class ControlActionDefinition(Type):
|
||||
def declare(self, name):
|
||||
Output("%s %s;", self.typeName, name)
|
||||
Output("UniversalProcPtr c_callback;")
|
||||
def passInput(self, name):
|
||||
return "myactionproc_upp"
|
||||
def cleanup(self, name):
|
||||
Output("setcallback((PyObject*)_self, kMyControlActionProcTag, actionProc, &c_callback);")
|
||||
|
||||
class ControlActionDefinitionNewControl(ControlActionDefinition):
|
||||
def cleanup(self, name):
|
||||
Output("setcallback(_res, kMyControlActionProcTag, liveTrackingProc, &c_callback);")
|
||||
|
||||
ControlActionUPP = ControlActionDefinition("PyObject*", "O")
|
||||
ControlActionUPPNewControl = ControlActionDefinitionNewControl("PyObject*", "O")
|
||||
ControlSliderOrientation = UInt16
|
||||
|
||||
|
||||
includestuff = includestuff + """
|
||||
#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 *);
|
||||
"""
|
||||
|
||||
finalstuff = finalstuff + """
|
||||
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;
|
||||
}
|
||||
"""
|
||||
|
||||
initstuff = initstuff + """
|
||||
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);
|
||||
"""
|
||||
|
||||
class MyObjectDefinition(PEP253Mixin, ObjectIdentityMixin, GlobalObjectDefinition):
|
||||
def outputStructMembers(self):
|
||||
GlobalObjectDefinition.outputStructMembers(self)
|
||||
Output("PyObject *ob_callbackdict;")
|
||||
def outputCheckNewArg(self):
|
||||
Output("if (itself == NULL) return PyMac_Error(resNotFound);")
|
||||
def outputInitStructMembers(self):
|
||||
GlobalObjectDefinition.outputInitStructMembers(self)
|
||||
Output("SetControlReference(itself, (long)it);")
|
||||
Output("it->ob_callbackdict = NULL;")
|
||||
def outputCleanupStructMembers(self):
|
||||
Output("Py_XDECREF(self->ob_callbackdict);")
|
||||
Output("if (self->ob_itself)SetControlReference(self->ob_itself, (long)0); /* Make it forget about us */")
|
||||
|
||||
# Create the generator groups and link them
|
||||
module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff)
|
||||
object = MyObjectDefinition(OBJECTNAME, OBJECTPREFIX, OBJECTTYPE)
|
||||
module.addobject(object)
|
||||
|
||||
# Create the generator classes used to populate the lists
|
||||
Function = OSErrWeakLinkFunctionGenerator
|
||||
Method = OSErrWeakLinkMethodGenerator
|
||||
|
||||
# Create and populate the lists
|
||||
functions = []
|
||||
methods = []
|
||||
execfile(INPUTFILE)
|
||||
execfile('ctledit.py')
|
||||
|
||||
# add the populated lists to the generator groups
|
||||
for f in functions: module.add(f)
|
||||
for f in methods: object.add(f)
|
||||
|
||||
# Manual generator for TrackControl, due to callback ideosyncracies
|
||||
trackcontrol_body = """
|
||||
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;
|
||||
"""
|
||||
|
||||
f = ManualGenerator("TrackControl", trackcontrol_body);
|
||||
f.docstring = lambda: "(Point startPoint [,trackercallback]) -> (ControlPartCode _rv)"
|
||||
object.add(f)
|
||||
|
||||
# CJW - added 5/12/99
|
||||
# Manual generator for HandleControlClick, as for TrackControl
|
||||
handlecontrolclick_body = """
|
||||
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;
|
||||
"""
|
||||
|
||||
f = ManualGenerator("HandleControlClick", handlecontrolclick_body);
|
||||
f.docstring = lambda: "(Point startPoint, Integer modifiers, [,trackercallback]) -> (ControlPartCode _rv)"
|
||||
object.add(f)
|
||||
|
||||
# Manual Generator for SetControlData
|
||||
setcontroldata_body = """
|
||||
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;
|
||||
"""
|
||||
|
||||
f = ManualGenerator("SetControlData", setcontroldata_body);
|
||||
f.docstring = lambda: "(stuff) -> None"
|
||||
object.add(f)
|
||||
|
||||
# Manual Generator for GetControlData
|
||||
getcontroldata_body = """
|
||||
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;
|
||||
"""
|
||||
|
||||
f = ManualGenerator("GetControlData", getcontroldata_body);
|
||||
f.docstring = lambda: "(part, type) -> String"
|
||||
object.add(f)
|
||||
|
||||
# Manual Generator for SetControlData_Handle
|
||||
setcontroldata_handle_body = """
|
||||
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;
|
||||
"""
|
||||
|
||||
f = ManualGenerator("SetControlData_Handle", setcontroldata_handle_body);
|
||||
f.docstring = lambda: "(ResObj) -> None"
|
||||
object.add(f)
|
||||
|
||||
# Manual Generator for GetControlData_Handle
|
||||
getcontroldata_handle_body = """
|
||||
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;
|
||||
"""
|
||||
|
||||
f = ManualGenerator("GetControlData_Handle", getcontroldata_handle_body);
|
||||
f.docstring = lambda: "(part, type) -> ResObj"
|
||||
object.add(f)
|
||||
|
||||
# Manual Generator for SetControlData_Callback
|
||||
setcontroldata_callback_body = """
|
||||
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;
|
||||
"""
|
||||
|
||||
f = ManualGenerator("SetControlData_Callback", setcontroldata_callback_body);
|
||||
f.docstring = lambda: "(callbackfunc) -> None"
|
||||
object.add(f)
|
||||
|
||||
|
||||
|
||||
createtabscontrol_body = """\
|
||||
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;"""
|
||||
|
||||
f = ManualGenerator("CreateTabsControl", createtabscontrol_body)
|
||||
f.docstring = lambda: "(WindowPtr window, Rect boundsRect, UInt16 size, UInt16 direction, ControlTabEntry tabArray) -> (ControlHandle outControl)"
|
||||
module.add(f)
|
||||
|
||||
# generate output (open the output file as late as possible)
|
||||
SetOutputFileName(OUTPUTFILE)
|
||||
module.generate()
|
||||
Reference in New Issue
Block a user