1 # IBCarbonsupport.py

     2 

     3 from macsupport import *

     4 

     5 from CarbonEvtscan import RefObjectTypes

     6 

     7 # where should this go? macsupport.py?

     8 CFStringRef = OpaqueByValueType('CFStringRef')

     9 

    10 for typ in RefObjectTypes:

    11     execstr = "%(name)s = OpaqueByValueType('%(name)s')" % {"name": typ}

    12     exec execstr

    13 

    14 

    15 if 0:

    16     # these types will have no methods and will merely be opaque blobs

    17     # should write getattr and setattr for them?

    18 

    19     StructObjectTypes = ["EventTypeSpec",

    20                                             "HIPoint",

    21                                             "HICommand",

    22                                             "EventHotKeyID",

    23                                             ]

    24 

    25     for typ in StructObjectTypes:

    26         execstr = "%(name)s = OpaqueType('%(name)s')" % {"name": typ}

    27         exec execstr

    28 

    29 EventHotKeyID = OpaqueByValueType("EventHotKeyID", "EventHotKeyID")

    30 EventTypeSpec_ptr = OpaqueType("EventTypeSpec", "EventTypeSpec")

    31 

    32 # is this the right type for the void * in GetEventParameter

    33 #void_ptr = FixedInputBufferType(1024)

    34 void_ptr = stringptr

    35 # here are some types that are really other types

    36 

    37 class MyVarInputBufferType(VarInputBufferType):

    38     def passInput(self, name):

    39         return "%s__len__, %s__in__" % (name, name)

    40 

    41 MyInBuffer = MyVarInputBufferType('char', 'long', 'l')          # (buf, len)

    42 

    43 EventTime = double

    44 EventTimeout = EventTime

    45 EventTimerInterval = EventTime

    46 EventAttributes = UInt32

    47 EventParamName = OSType

    48 EventParamType = OSType

    49 EventPriority = SInt16

    50 EventMask = UInt16

    51 

    52 EventComparatorUPP = FakeType("(EventComparatorUPP)0")

    53 EventLoopTimerUPP = FakeType("(EventLoopTimerUPP)0")

    54 EventHandlerUPP = FakeType("(EventHandlerUPP)0")

    55 EventHandlerUPP = FakeType("(EventHandlerUPP)0")

    56 EventComparatorProcPtr = FakeType("(EventComparatorProcPtr)0")

    57 EventLoopTimerProcPtr = FakeType("(EventLoopTimerProcPtr)0")

    58 EventHandlerProcPtr = FakeType("(EventHandlerProcPtr)0")

    59 

    60 CarbonEventsFunction = OSErrFunctionGenerator

    61 CarbonEventsMethod = OSErrMethodGenerator

    62 

    63 class EventHandlerRefMethod(OSErrMethodGenerator):

    64     def precheck(self):

    65         OutLbrace('if (_self->ob_itself == NULL)')

    66         Output('PyErr_SetString(CarbonEvents_Error, "Handler has been removed");')

    67         Output('return NULL;')

    68         OutRbrace()

    69 

    70 

    71 RgnHandle = OpaqueByValueType("RgnHandle", "ResObj")

    72 GrafPtr = OpaqueByValueType("GrafPtr", "GrafObj")

    73 MouseTrackingResult = UInt16

    74 

    75 

    76 includestuff = includestuff + r"""

    77 #include <Carbon/Carbon.h>

    78 

    79 extern int CFStringRef_New(CFStringRef *);

    80 

    81 extern int CFStringRef_Convert(PyObject *, CFStringRef *);

    82 extern int CFBundleRef_Convert(PyObject *, CFBundleRef *);

    83 

    84 int EventTargetRef_Convert(PyObject *, EventTargetRef *);

    85 PyObject *EventHandlerCallRef_New(EventHandlerCallRef itself);

    86 PyObject *EventRef_New(EventRef itself);

    87 

    88 /********** EventTypeSpec *******/

    89 static PyObject*

    90 EventTypeSpec_New(EventTypeSpec *in)

    91 {

    92         return Py_BuildValue("ll", in->eventClass, in->eventKind);

    93 }

    94 

    95 static int

    96 EventTypeSpec_Convert(PyObject *v, EventTypeSpec *out)

    97 {

    98         if (PyArg_Parse(v, "(O&l)",

    99                         PyMac_GetOSType, &(out->eventClass),

   100                         &(out->eventKind)))

   101                 return 1;

   102         return NULL;

   103 }

   104 

   105 /********** end EventTypeSpec *******/

   106 

   107 /********** HIPoint *******/

   108 

   109 #if 0  /* XXX doesn't compile */

   110 static PyObject*

   111 HIPoint_New(HIPoint *in)

   112 {

   113         return Py_BuildValue("ff", in->x, in->y);

   114 }

   115 

   116 static int

   117 HIPoint_Convert(PyObject *v, HIPoint *out)

   118 {

   119         if (PyArg_ParseTuple(v, "ff", &(out->x), &(out->y)))

   120                 return 1;

   121         return NULL;

   122 }

   123 #endif

   124 

   125 /********** end HIPoint *******/

   126 

   127 /********** EventHotKeyID *******/

   128 

   129 static PyObject*

   130 EventHotKeyID_New(EventHotKeyID *in)

   131 {

   132         return Py_BuildValue("ll", in->signature, in->id);

   133 }

   134 

   135 static int

   136 EventHotKeyID_Convert(PyObject *v, EventHotKeyID *out)

   137 {

   138         if (PyArg_ParseTuple(v, "ll", &out->signature, &out->id))

   139                 return 1;

   140         return NULL;

   141 }

   142 

   143 /********** end EventHotKeyID *******/

   144 

   145 /******** myEventHandler ***********/

   146 

   147 static EventHandlerUPP myEventHandlerUPP;

   148 

   149 static pascal OSStatus

   150 myEventHandler(EventHandlerCallRef handlerRef, EventRef event, void *outPyObject) {

   151         PyObject *retValue;

   152         int status;

   153 

   154         retValue = PyObject_CallFunction((PyObject *)outPyObject, "O&O&",

   155                                          EventHandlerCallRef_New, handlerRef,

   156                                          EventRef_New, event);

   157         if (retValue == NULL) {

   158                 PySys_WriteStderr("Error in event handler callback:\n");

   159                 PyErr_Print();  /* this also clears the error */

   160                 status = noErr; /* complain? how? */

   161         } else {

   162                 if (retValue == Py_None)

   163                         status = noErr;

   164                 else if (PyInt_Check(retValue)) {

   165                         status = PyInt_AsLong(retValue);

   166                 } else

   167                         status = noErr; /* wrong object type, complain? */

   168                 Py_DECREF(retValue);

   169         }

   170 

   171         return status;

   172 }

   173 

   174 /******** end myEventHandler ***********/

   175 

   176 """

   177 

   178 initstuff = initstuff + """

   179 myEventHandlerUPP = NewEventHandlerUPP(myEventHandler);

   180 """

   181 module = MacModule('_CarbonEvt', 'CarbonEvents', includestuff, finalstuff, initstuff)

   182 

   183 

   184 

   185 

   186 class EventHandlerRefObjectDefinition(PEP253Mixin, GlobalObjectDefinition):

   187     def outputStructMembers(self):

   188         Output("%s ob_itself;", self.itselftype)

   189         Output("PyObject *ob_callback;")

   190     def outputInitStructMembers(self):

   191         Output("it->ob_itself = %sitself;", self.argref)

   192         Output("it->ob_callback = NULL;")

   193     def outputFreeIt(self, name):

   194         OutLbrace("if (self->ob_itself != NULL)")

   195         Output("RemoveEventHandler(self->ob_itself);")

   196         Output("Py_DECREF(self->ob_callback);")

   197         OutRbrace()

   198 

   199 class MyGlobalObjectDefinition(PEP253Mixin, GlobalObjectDefinition):

   200     pass

   201 

   202 for typ in RefObjectTypes:

   203     if typ == 'EventHandlerRef':

   204         EventHandlerRefobject = EventHandlerRefObjectDefinition('EventHandlerRef')

   205     else:

   206         execstr = typ + 'object = MyGlobalObjectDefinition(typ)'

   207         exec execstr

   208     module.addobject(eval(typ + 'object'))

   209 

   210 

   211 functions = []

   212 for typ in RefObjectTypes: ## go thru all ObjectTypes as defined in CarbonEventsscan.py

   213     # initialize the lists for carbongen to fill

   214     execstr = typ + 'methods = []'

   215     exec execstr

   216 

   217 execfile('CarbonEventsgen.py')

   218 

   219 

   220 

   221 for f in functions: module.add(f)       # add all the functions carboneventsgen put in the list

   222 

   223 for typ in RefObjectTypes:                               ## go thru all ObjectTypes as defined in CarbonEventsscan.py

   224     methods = eval(typ + 'methods')  ## get a reference to the method list from the main namespace

   225     obj = eval(typ + 'object')                ## get a reference to the object

   226     for m in methods: obj.add(m)    ## add each method in the list to the object

   227 

   228 

   229 removeeventhandler = """

   230 OSStatus _err;

   231 if (_self->ob_itself == NULL) {

   232         PyErr_SetString(CarbonEvents_Error, "Handler has been removed");

   233         return NULL;

   234 }

   235 if (!PyArg_ParseTuple(_args, ""))

   236         return NULL;

   237 _err = RemoveEventHandler(_self->ob_itself);

   238 if (_err != noErr) return PyMac_Error(_err);

   239 _self->ob_itself = NULL;

   240 Py_DECREF(_self->ob_callback);

   241 _self->ob_callback = NULL;

   242 Py_INCREF(Py_None);

   243 _res = Py_None;

   244 return _res;"""

   245 

   246 f = ManualGenerator("RemoveEventHandler", removeeventhandler);

   247 f.docstring = lambda: "() -> None"

   248 EventHandlerRefobject.add(f)

   249 

   250 

   251 installeventhandler = """

   252 EventTypeSpec inSpec;

   253 PyObject *callback;

   254 EventHandlerRef outRef;

   255 OSStatus _err;

   256 

   257 if (!PyArg_ParseTuple(_args, "O&O", EventTypeSpec_Convert, &inSpec, &callback))

   258         return NULL;

   259 

   260 _err = InstallEventHandler(_self->ob_itself, myEventHandlerUPP, 1, &inSpec, (void *)callback, &outRef);

   261 if (_err != noErr) return PyMac_Error(_err);

   262 

   263 _res = EventHandlerRef_New(outRef);

   264 if (_res != NULL) {

   265         ((EventHandlerRefObject*)_res)->ob_callback = callback;

   266         Py_INCREF(callback);

   267 }

   268 return _res;"""

   269 

   270 f = ManualGenerator("InstallEventHandler", installeventhandler);

   271 f.docstring = lambda: "(EventTypeSpec inSpec, Method callback) -> (EventHandlerRef outRef)"

   272 EventTargetRefobject.add(f)

   273 

   274 # This may not be the best, but at least it lets you get the raw data back into python as a string. You'll have to cut it up yourself and parse the result.

   275 

   276 geteventparameter = """

   277 UInt32 bufferSize;

   278 EventParamName inName;

   279 EventParamType inType;

   280 OSErr _err;

   281 void * buffer;

   282 

   283 if (!PyArg_ParseTuple(_args, "O&O&", PyMac_GetOSType, &inName, PyMac_GetOSType, &inType))

   284       return NULL;

   285 

   286 /* Figure out the size by passing a null buffer to GetEventParameter */

   287 _err = GetEventParameter(_self->ob_itself, inName, inType, NULL, 0, &bufferSize, NULL);

   288 

   289 if (_err != noErr)

   290       return PyMac_Error(_err);

   291 buffer = PyMem_NEW(char, bufferSize);

   292 if (buffer == NULL)

   293       return PyErr_NoMemory();

   294 

   295 _err = GetEventParameter(_self->ob_itself, inName, inType, NULL, bufferSize, NULL, buffer);

   296 

   297 if (_err != noErr) {

   298       PyMem_DEL(buffer);

   299       return PyMac_Error(_err);

   300 }

   301 _res = Py_BuildValue("s#", buffer, bufferSize);

   302 PyMem_DEL(buffer);

   303 return _res;

   304 """

   305 

   306 f = ManualGenerator("GetEventParameter", geteventparameter);

   307 f.docstring = lambda: "(EventParamName eventName, EventParamType eventType) -> (String eventParamData)"

   308 EventRefobject.add(f)

   309 

   310 SetOutputFileName('_CarbonEvtmodule.c')

   311 module.generate()

   312 

   313 ##import os

   314 ##os.system("python setup.py build")