From 52e9045da6d2a57cec6823a8dc5c64a5c410ef13 Mon Sep 17 00:00:00 2001 From: Jack Jansen Date: Mon, 5 Nov 2001 14:44:23 +0000 Subject: [PATCH] Carbon Event Manager module donated by Donovan Preston. Checked in as I received them (except for namechange), these will not work as-is, that'll be fixed in a later checkin. --- Mac/Modules/carbonevt/CarbonEvtscan.py | 91 ++++++++ Mac/Modules/carbonevt/CarbonEvtsupport.py | 241 ++++++++++++++++++++++ 2 files changed, 332 insertions(+) create mode 100644 Mac/Modules/carbonevt/CarbonEvtscan.py create mode 100644 Mac/Modules/carbonevt/CarbonEvtsupport.py diff --git a/Mac/Modules/carbonevt/CarbonEvtscan.py b/Mac/Modules/carbonevt/CarbonEvtscan.py new file mode 100644 index 00000000000..96f9b55b854 --- /dev/null +++ b/Mac/Modules/carbonevt/CarbonEvtscan.py @@ -0,0 +1,91 @@ +# IBCarbonscan.py + +import sys +import os +import string +import MacOS + +BGENDIR= '/Users/dsp/Documents/python/dist/src/Tools/bgen/bgen' +sys.path.append(BGENDIR) + +from bgenlocations import TOOLBOXDIR + +from scantools import Scanner, Scanner_OSX + +def main(): + print "---Scanning CarbonEvents.h---" + input = ["CarbonEvents.h"] + output = "CarbonEventsgen.py" + defsoutput = TOOLBOXDIR + "CarbonEvents.py" + scanner = CarbonEvents_Scanner(input, output, defsoutput) + scanner.scan() + scanner.close() + print "--done scanning, importing--" + import CarbonEventssupport + print "done" + +RefObjectTypes = ["EventRef", + "EventQueueRef", + "EventLoopRef", + "EventLoopTimerRef", + "EventHandlerRef", + "EventHandlerCallRef", + "EventTargetRef", + "EventHotKeyRef", + ] + +class CarbonEvents_Scanner(Scanner): + def destination(self, type, name, arglist): + classname = "CarbonEventsFunction" + listname = "functions" + if arglist: + t, n, m = arglist[0] + print "*********", t, + if t in RefObjectTypes and m == "InMode": + print "method" + classname = "CarbonEventsMethod" + listname = t + "methods" + else: + print "not method" + return classname, listname + + def makeblacklistnames(self): + return [ + "MacCreateEvent", + "TrackMouseLocationWithOptions", + "TrackMouseLocation", + "TrackMouseRegion", + "RegisterToolboxObjectClass", + "UnregisterToolboxObjectClass", + "ProcessHICommand", + "GetCFRunLoopFromEventLoop", + + "InvokeEventHandlerUPP", + "InvokeEventComparatorUPP", + "InvokeEventLoopTimerUPP", + + # Wrote by hand + "InstallEventHandler", + "RunApplicationEventLoop", + + # Write by hand? + "GetEventParameter", + "FlushSpecificEventsFromQueue", + "FindSpecificEventInQueue", + "InstallEventLoopTimer", + + # Don't do these because they require a CFRelease + "CreateTypeStringWithOSType", + "CopyEvent", + ] + +# def makeblacklisttypes(self): +# return ["EventComparatorUPP", +# "EventLoopTimerUPP", +# #"EventHandlerUPP", +# "EventComparatorProcPtr", +# "EventLoopTimerProcPtr", +# "EventHandlerProcPtr", +# ] +if __name__ == "__main__": + main() diff --git a/Mac/Modules/carbonevt/CarbonEvtsupport.py b/Mac/Modules/carbonevt/CarbonEvtsupport.py new file mode 100644 index 00000000000..b56d20c67f9 --- /dev/null +++ b/Mac/Modules/carbonevt/CarbonEvtsupport.py @@ -0,0 +1,241 @@ +# IBCarbonsupport.py + +from macsupport import * + +from CarbonEventsscan import RefObjectTypes + +# where should this go? macsupport.py? +CFStringRef = OpaqueByValueType('CFStringRef') + +for typ in RefObjectTypes: + execstr = "%(name)s = OpaqueByValueType('%(name)s')" % {"name": typ} + exec execstr + +# these types will have no methods and will merely be opaque blobs +# should write getattr and setattr for them? + +StructObjectTypes = ["EventTypeSpec", + "HIPoint", + "HICommand", + "EventHotKeyID", + ] + +for typ in StructObjectTypes: + execstr = "%(name)s = OpaqueType('%(name)s')" % {"name": typ} + exec execstr + +EventTypeSpec_ptr = OpaqueType("EventTypeSpec *", "EventTypeSpec") + +# is this the right type for the void * in GetEventParameter +#void_ptr = FixedInputBufferType(1024) +void_ptr = stringptr +# here are some types that are really other types + +EventTime = double +EventTimeout = EventTime +EventTimerInterval = EventTime +EventAttributes = UInt32 +EventParamName = OSType +EventParamType = OSType +EventPriority = SInt16 +EventMask = UInt16 + +EventComparatorUPP = FakeType("(EventComparatorUPP)0") +EventLoopTimerUPP = FakeType("(EventLoopTimerUPP)0") +EventHandlerUPP = FakeType("(EventHandlerUPP)0") +EventHandlerUPP = FakeType("(EventHandlerUPP)0") +EventComparatorProcPtr = FakeType("(EventComparatorProcPtr)0") +EventLoopTimerProcPtr = FakeType("(EventLoopTimerProcPtr)0") +EventHandlerProcPtr = FakeType("(EventHandlerProcPtr)0") + +CarbonEventsFunction = OSErrFunctionGenerator +CarbonEventsMethod = OSErrMethodGenerator + +includestuff = """ +#include +#include "macglue.h" + +#define USE_MAC_MP_MULTITHREADING 1 + +#if USE_MAC_MP_MULTITHREADING +static PyThreadState *_save; +static MPCriticalRegionID reentrantLock; +#endif /* USE_MAC_MP_MULTITHREADING */ + +extern int CFStringRef_New(CFStringRef *); + +extern int CFStringRef_Convert(PyObject *, CFStringRef *); +extern int CFBundleRef_Convert(PyObject *, CFBundleRef *); + +int EventTargetRef_Convert(PyObject *, EventTargetRef *); +PyObject *EventHandlerCallRef_New(EventHandlerCallRef itself); +PyObject *EventRef_New(EventRef itself); + +/********** EventTypeSpec *******/ +static PyObject* +EventTypeSpec_New(EventTypeSpec *in) +{ + return Py_BuildValue("ll", in->eventClass, in->eventKind); +} + +static int +EventTypeSpec_Convert(PyObject *v, EventTypeSpec *out) +{ + if (PyArg_ParseTuple(v, "ll", &(out->eventClass), &(out->eventKind))) + return 1; + return NULL; +} + +/********** end EventTypeSpec *******/ + +/********** HIPoint *******/ + +static PyObject* +HIPoint_New(HIPoint *in) +{ + return Py_BuildValue("ff", in->x, in->y); +} + +static int +HIPoint_Convert(PyObject *v, HIPoint *out) +{ + if (PyArg_ParseTuple(v, "ff", &(out->x), &(out->y))) + return 1; + return NULL; +} + +/********** end HIPoint *******/ + +/********** EventHotKeyID *******/ + +static PyObject* +EventHotKeyID_New(EventHotKeyID *in) +{ + return Py_BuildValue("ll", in->signature, in->id); +} + +static int +EventHotKeyID_Convert(PyObject *v, EventHotKeyID *out) +{ + if (PyArg_ParseTuple(v, "ll", &out->signature, &out->id)) + return 1; + return NULL; +} + +/********** end EventHotKeyID *******/ + +/******** handlecommand ***********/ + +pascal OSStatus CarbonEvents_HandleCommand(EventHandlerCallRef handlerRef, Even +tRef event, void *outPyObject) { + PyObject *retValue; + int status; + +#if USE_MAC_MP_MULTITHREADING + MPEnterCriticalRegion(reentrantLock, kDurationForever); + PyEval_RestoreThread(_save); +#endif /* USE_MAC_MP_MULTITHREADING */ + + retValue = PyObject_CallFunction((PyObject *)outPyObject, "O&O&", EventHand +lerCallRef_New, handlerRef, EventRef_New, event); + status = PyInt_AsLong(retValue); + +#if USE_MAC_MP_MULTITHREADING + _save = PyEval_SaveThread(); + MPExitCriticalRegion(reentrantLock); +#endif /* USE_MAC_MP_MULTITHREADING */ + + return status; +} + +/******** end handlecommand ***********/ + +""" + +module = MacModule('CarbonEvents', 'CarbonEvents', includestuff, finalstuff, in +itstuff) + +#class CFReleaserObj(GlobalObjectDefinition): +# def outputFreeIt(self, name): +# Output("CFRelease(%s);" % name) + +for typ in RefObjectTypes: + execstr = typ + 'object = GlobalObjectDefinition(typ)' + exec execstr + module.addobject(eval(typ + 'object')) + +functions = [] +for typ in RefObjectTypes: ## go thru all ObjectTypes as defined in CarbonEvent +sscan.py + # initialize the lists for carbongen to fill + execstr = typ + 'methods = []' + exec execstr + +execfile('CarbonEventsgen.py') + +for f in functions: module.add(f) # add all the functions carboneventsgen + put in the list + +for typ in RefObjectTypes: ## go thru all ObjectT +ypes as defined in CarbonEventsscan.py + methods = eval(typ + 'methods') ## get a reference to the method list +from the main namespace + obj = eval(typ + 'object') ## get a reference to the obj +ect + for m in methods: obj.add(m) ## add each method in the list to the o +bject + +installeventhandler = """ +EventTypeSpec inSpec; +PyObject *callback; +EventHandlerRef outRef; +OSStatus _err; +EventHandlerUPP event; + +if (!PyArg_ParseTuple(_args, "O&O", EventTypeSpec_Convert, &inSpec, &callback)) + return NULL; + +event = NewEventHandlerUPP(CarbonEvents_HandleCommand); +_err = InstallEventHandler(_self->ob_itself, event, 1, &inSpec, (void *)callbac +k, &outRef); +if (_err != noErr) return PyMac_Error(_err); + +return Py_BuildValue("l", outRef); +""" + +f = ManualGenerator("InstallEventHandler", installeventhandler); +f.docstring = lambda: "(EventTargetRef inTarget, EventTypeSpec inSpec, Method c +allback) -> (EventHandlerRef outRef)" +EventTargetRefobject.add(f) + +runappeventloop = """ +#if USE_MAC_MP_MULTITHREADING +if (MPCreateCriticalRegion(&reentrantLock) != noErr) { + printf("lock failure\n"); + return NULL; +} +_save = PyEval_SaveThread(); +#endif /* USE_MAC_MP_MULTITHREADING */ + +RunApplicationEventLoop(); + +#if USE_MAC_MP_MULTITHREADING +PyEval_RestoreThread(_save); + +MPDeleteCriticalRegion(reentrantLock); +#endif /* USE_MAC_MP_MULTITHREADING */ + +Py_INCREF(Py_None); + +return Py_None; +""" + +f = ManualGenerator("RunApplicationEventLoop", runappeventloop); +f.docstring = lambda: "() -> ()" +module.add(f) + +SetOutputFileName('_CarbonEvents.c') +module.generate() + +import os +os.system("python setup.py build")