← Back to branch summary

~malept/ubuntu/lucid/python2.6/dev-dependency-fix

« back to all changes in this revision

Viewing changes to Mac/Modules/dlg/dlgsupport.py

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-02-13 12:51:00 UTC
  • Revision ID: james.westby@ubuntu.com-20090213125100-uufgcb9yeqzujpqw
Tags: upstream-2.6.1
Import upstream version 2.6.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Mac/Modules/dlg/dlgsupport.py
 
1
# This script generates the Dialogs interface for Python.
 
2
# It uses the "bgen" package to generate C code.
 
3
# It execs the file dlggen.py which contain the function definitions
 
4
# (dlggen.py was generated by dlgscan.py, scanning the <Dialogs.h> header file).
 
5
 
 
6
from macsupport import *
 
7
 
 
8
# Create the type objects
 
9
 
 
10
DialogPtr = OpaqueByValueType("DialogPtr", "DlgObj")
 
11
DialogRef = DialogPtr
 
12
 
 
13
# An OptHandle is either a handle or None (in case NULL is passed in).
 
14
# This is needed for GetDialogItem().
 
15
OptHandle = OpaqueByValueType("Handle", "OptResObj")
 
16
 
 
17
ModalFilterProcPtr = InputOnlyType("PyObject*", "O")
 
18
ModalFilterProcPtr.passInput = lambda name: "Dlg_PassFilterProc(%s)" % name
 
19
ModalFilterUPP = ModalFilterProcPtr
 
20
 
 
21
RgnHandle = OpaqueByValueType("RgnHandle", "ResObj")
 
22
TEHandle = OpaqueByValueType("TEHandle", "ResObj")
 
23
CGrafPtr = OpaqueByValueType("CGrafPtr", "GrafObj")
 
24
 
 
25
DITLMethod = Type("DITLMethod", "h")
 
26
DialogItemIndex = Type("DialogItemIndex", "h")
 
27
DialogItemType = Type("DialogItemType", "h")
 
28
DialogItemIndexZeroBased = Type("DialogItemIndexZeroBased", "h")
 
29
AlertType = Type("AlertType", "h")
 
30
StringPtr = Str255
 
31
EventMask = Type("EventMask", "H")
 
32
 
 
33
includestuff = includestuff + """
 
34
#include <Carbon/Carbon.h>
 
35
 
 
36
#ifdef USE_TOOLBOX_OBJECT_GLUE
 
37
extern PyObject *_DlgObj_New(DialogRef);
 
38
extern PyObject *_DlgObj_WhichDialog(DialogRef);
 
39
extern int _DlgObj_Convert(PyObject *, DialogRef *);
 
40
 
 
41
#define DlgObj_New _DlgObj_New
 
42
#define DlgObj_WhichDialog _DlgObj_WhichDialog
 
43
#define DlgObj_Convert _DlgObj_Convert
 
44
#endif
 
45
 
 
46
/* XXX Shouldn't this be a stack? */
 
47
static PyObject *Dlg_FilterProc_callback = NULL;
 
48
 
 
49
static pascal Boolean Dlg_UnivFilterProc(DialogPtr dialog,
 
50
                                         EventRecord *event,
 
51
                                         short *itemHit)
 
52
{
 
53
        Boolean rv;
 
54
        PyObject *args, *res;
 
55
        PyObject *callback = Dlg_FilterProc_callback;
 
56
        if (callback == NULL)
 
57
                return 0; /* Default behavior */
 
58
        Dlg_FilterProc_callback = NULL; /* We'll restore it when call successful */
 
59
        args = Py_BuildValue("O&O&", DlgObj_WhichDialog, dialog, PyMac_BuildEventRecord, event);
 
60
        if (args == NULL)
 
61
                res = NULL;
 
62
        else {
 
63
                res = PyEval_CallObject(callback, args);
 
64
                Py_DECREF(args);
 
65
        }
 
66
        if (res == NULL) {
 
67
                PySys_WriteStderr("Exception in Dialog Filter\\n");
 
68
                PyErr_Print();
 
69
                *itemHit = -1; /* Fake return item */
 
70
                return 1; /* We handled it */
 
71
        }
 
72
        else {
 
73
                Dlg_FilterProc_callback = callback;
 
74
                if (PyInt_Check(res)) {
 
75
                        *itemHit = PyInt_AsLong(res);
 
76
                        rv = 1;
 
77
                }
 
78
                else
 
79
                        rv = PyObject_IsTrue(res);
 
80
        }
 
81
        Py_DECREF(res);
 
82
        return rv;
 
83
}
 
84
 
 
85
static ModalFilterUPP
 
86
Dlg_PassFilterProc(PyObject *callback)
 
87
{
 
88
        PyObject *tmp = Dlg_FilterProc_callback;
 
89
        static ModalFilterUPP UnivFilterUpp = NULL;
 
90
 
 
91
        Dlg_FilterProc_callback = NULL;
 
92
        if (callback == Py_None) {
 
93
                Py_XDECREF(tmp);
 
94
                return NULL;
 
95
        }
 
96
        Py_INCREF(callback);
 
97
        Dlg_FilterProc_callback = callback;
 
98
        Py_XDECREF(tmp);
 
99
        if ( UnivFilterUpp == NULL )
 
100
                UnivFilterUpp = NewModalFilterUPP(&Dlg_UnivFilterProc);
 
101
        return UnivFilterUpp;
 
102
}
 
103
 
 
104
static PyObject *Dlg_UserItemProc_callback = NULL;
 
105
 
 
106
static pascal void Dlg_UnivUserItemProc(DialogPtr dialog,
 
107
                                         short item)
 
108
{
 
109
        PyObject *args, *res;
 
110
 
 
111
        if (Dlg_UserItemProc_callback == NULL)
 
112
                return; /* Default behavior */
 
113
        Dlg_FilterProc_callback = NULL; /* We'll restore it when call successful */
 
114
        args = Py_BuildValue("O&h", DlgObj_WhichDialog, dialog, item);
 
115
        if (args == NULL)
 
116
                res = NULL;
 
117
        else {
 
118
                res = PyEval_CallObject(Dlg_UserItemProc_callback, args);
 
119
                Py_DECREF(args);
 
120
        }
 
121
        if (res == NULL) {
 
122
                PySys_WriteStderr("Exception in Dialog UserItem proc\\n");
 
123
                PyErr_Print();
 
124
        }
 
125
        Py_XDECREF(res);
 
126
        return;
 
127
}
 
128
 
 
129
#if 0
 
130
/*
 
131
** Treating DialogObjects as WindowObjects is (I think) illegal under Carbon.
 
132
** However, as they are still identical under MacOS9 Carbon this is a problem, even
 
133
** if we neatly call GetDialogWindow() at the right places: there's one refcon field
 
134
** and it points to the DialogObject, so WinObj_WhichWindow will smartly return the
 
135
** dialog object, and therefore we still don't have a WindowObject.
 
136
** I'll leave the chaining code in place for now, with this comment to warn the
 
137
** unsuspecting victims (i.e. me, probably, in a few weeks:-)
 
138
*/
 
139
extern PyMethodChain WinObj_chain;
 
140
#endif
 
141
"""
 
142
 
 
143
finalstuff = finalstuff + """
 
144
/* Return the WindowPtr corresponding to a DialogObject */
 
145
#if 0
 
146
WindowPtr
 
147
DlgObj_ConvertToWindow(PyObject *self)
 
148
{
 
149
        if ( DlgObj_Check(self) )
 
150
                return GetDialogWindow(((DialogObject *)self)->ob_itself);
 
151
        return NULL;
 
152
}
 
153
#endif
 
154
/* Return the object corresponding to the dialog, or None */
 
155
 
 
156
PyObject *
 
157
DlgObj_WhichDialog(DialogPtr d)
 
158
{
 
159
        PyObject *it;
 
160
 
 
161
        if (d == NULL) {
 
162
                it = Py_None;
 
163
                Py_INCREF(it);
 
164
        } else {
 
165
                WindowPtr w = GetDialogWindow(d);
 
166
 
 
167
                it = (PyObject *) GetWRefCon(w);
 
168
                if (it == NULL || ((DialogObject *)it)->ob_itself != d || !DlgObj_Check(it)) {
 
169
#if 0
 
170
                        /* Should do this, but we don't have an ob_freeit for dialogs yet. */
 
171
                        it = WinObj_New(w);
 
172
                        ((WindowObject *)it)->ob_freeit = NULL;
 
173
#else
 
174
                        it = Py_None;
 
175
                        Py_INCREF(it);
 
176
#endif
 
177
                } else {
 
178
                        Py_INCREF(it);
 
179
                }
 
180
        }
 
181
        return it;
 
182
}
 
183
"""
 
184
 
 
185
initstuff = initstuff + """
 
186
        PyMac_INIT_TOOLBOX_OBJECT_NEW(DialogPtr, DlgObj_New);
 
187
        PyMac_INIT_TOOLBOX_OBJECT_NEW(DialogPtr, DlgObj_WhichDialog);
 
188
        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(DialogPtr, DlgObj_Convert);
 
189
"""
 
190
 
 
191
 
 
192
# Define a class which specializes our object definition
 
193
class MyObjectDefinition(PEP253Mixin, GlobalObjectDefinition):
 
194
    def __init__(self, name, prefix = None, itselftype = None):
 
195
        GlobalObjectDefinition.__init__(self, name, prefix, itselftype)
 
196
## This won't work in Carbon, so we disable it for all MacPythons:-(
 
197
## But see the comment above:-((
 
198
##              self.basechain = "&WinObj_chain"
 
199
 
 
200
    def outputInitStructMembers(self):
 
201
        GlobalObjectDefinition.outputInitStructMembers(self)
 
202
        Output("SetWRefCon(GetDialogWindow(itself), (long)it);")
 
203
 
 
204
    def outputCheckNewArg(self):
 
205
        Output("if (itself == NULL) { Py_INCREF(Py_None); return Py_None; }")
 
206
 
 
207
    def outputCheckConvertArg(self):
 
208
        Output("if (v == Py_None) { *p_itself = NULL; return 1; }")
 
209
        Output("if (PyInt_Check(v)) { *p_itself = (DialogPtr)PyInt_AsLong(v);")
 
210
        Output("                      return 1; }")
 
211
 
 
212
    def outputCompare(self):
 
213
        Output()
 
214
        Output("static int %s_compare(%s *self, %s *other)", self.prefix, self.objecttype, self.objecttype)
 
215
        OutLbrace()
 
216
        Output("if ( self->ob_itself > other->ob_itself ) return 1;")
 
217
        Output("if ( self->ob_itself < other->ob_itself ) return -1;")
 
218
        Output("return 0;")
 
219
        OutRbrace()
 
220
 
 
221
    def outputHash(self):
 
222
        Output()
 
223
        Output("static int %s_hash(%s *self)", self.prefix, self.objecttype)
 
224
        OutLbrace()
 
225
        Output("return (int)self->ob_itself;")
 
226
        OutRbrace()
 
227
 
 
228
    def outputFreeIt(self, itselfname):
 
229
        Output("DisposeDialog(%s);", itselfname)
 
230
 
 
231
# Create the generator groups and link them
 
232
module = MacModule('_Dlg', 'Dlg', includestuff, finalstuff, initstuff)
 
233
object = MyObjectDefinition('Dialog', 'DlgObj', 'DialogPtr')
 
234
module.addobject(object)
 
235
 
 
236
# Create the generator classes used to populate the lists
 
237
Function = OSErrWeakLinkFunctionGenerator
 
238
Method = OSErrWeakLinkMethodGenerator
 
239
 
 
240
# Create and populate the lists
 
241
functions = []
 
242
methods = []
 
243
execfile("dlggen.py")
 
244
 
 
245
# add the populated lists to the generator groups
 
246
for f in functions: module.add(f)
 
247
for f in methods: object.add(f)
 
248
 
 
249
setuseritembody = """
 
250
        PyObject *new = NULL;
 
251
 
 
252
 
 
253
        if (!PyArg_ParseTuple(_args, "|O", &new))
 
254
                return NULL;
 
255
 
 
256
        if (Dlg_UserItemProc_callback && new && new != Py_None) {
 
257
                PyErr_SetString(Dlg_Error, "Another UserItemProc is already installed");
 
258
                return NULL;
 
259
        }
 
260
 
 
261
        if (new == NULL || new == Py_None) {
 
262
                new = NULL;
 
263
                _res = Py_None;
 
264
                Py_INCREF(Py_None);
 
265
        } else {
 
266
                Py_INCREF(new);
 
267
                _res = Py_BuildValue("O&", ResObj_New, (Handle)NewUserItemUPP(Dlg_UnivUserItemProc));
 
268
        }
 
269
 
 
270
        Dlg_UserItemProc_callback = new;
 
271
        return _res;
 
272
"""
 
273
f = ManualGenerator("SetUserItemHandler", setuseritembody)
 
274
module.add(f)
 
275
 
 
276
# generate output
 
277
SetOutputFileName('_Dlgmodule.c')
 
278
module.generate()