← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Mac/Modules/Nav.c

  • 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/Nav.c
 
1
/***********************************************************
 
2
Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
 
3
The Netherlands.
 
4
 
 
5
                        All Rights Reserved
 
6
 
 
7
Permission to use, copy, modify, and distribute this software and its
 
8
documentation for any purpose and without fee is hereby granted,
 
9
provided that the above copyright notice appear in all copies and that
 
10
both that copyright notice and this permission notice appear in
 
11
supporting documentation, and that the names of Stichting Mathematisch
 
12
Centrum or CWI or Corporation for National Research Initiatives or
 
13
CNRI not be used in advertising or publicity pertaining to
 
14
distribution of the software without specific, written prior
 
15
permission.
 
16
 
 
17
While CWI is the initial source for this software, a modified version
 
18
is made available by the Corporation for National Research Initiatives
 
19
(CNRI) at the Internet address ftp://ftp.python.org.
 
20
 
 
21
STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
 
22
REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
 
23
MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
 
24
CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
 
25
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
 
26
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 
27
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 
28
PERFORMANCE OF THIS SOFTWARE.
 
29
 
 
30
******************************************************************/
 
31
 
 
32
#include "Python.h"
 
33
#include "pymactoolbox.h"
 
34
#include <Carbon/Carbon.h>
 
35
 
 
36
static PyObject *ErrorObject;
 
37
 
 
38
static NavEventUPP my_eventProcUPP;
 
39
static NavPreviewUPP my_previewProcUPP;
 
40
static NavObjectFilterUPP my_filterProcUPP;
 
41
 
 
42
/* Callback functions */
 
43
static pascal void
 
44
my_eventProc(NavEventCallbackMessage callBackSelector,
 
45
                         NavCBRecPtr callBackParms,
 
46
                         NavCallBackUserData callbackUD)
 
47
{
 
48
        PyObject *dict = (PyObject *)callbackUD;
 
49
        PyObject *pyfunc;
 
50
        PyObject *rv;
 
51
        
 
52
        if (!dict) return;
 
53
        if ( (pyfunc = PyDict_GetItemString(dict, "eventProc")) == NULL ) {
 
54
                PyErr_Print();
 
55
                return;
 
56
        }
 
57
        if ( pyfunc == Py_None ) {
 
58
                return;
 
59
        }
 
60
        rv = PyObject_CallFunction(pyfunc, "ls#", (long)callBackSelector,
 
61
                        (void *)callBackParms, sizeof(NavCBRec));
 
62
        if ( rv )
 
63
                Py_DECREF(rv);
 
64
        else {
 
65
                PySys_WriteStderr("Nav: exception in eventProc callback\n");
 
66
                PyErr_Print();
 
67
        }
 
68
}
 
69
 
 
70
static pascal Boolean
 
71
my_previewProc(NavCBRecPtr callBackParms,
 
72
                           NavCallBackUserData callbackUD)
 
73
{
 
74
        PyObject *dict = (PyObject *)callbackUD;
 
75
        PyObject *pyfunc;
 
76
        PyObject *rv;
 
77
        Boolean c_rv = false;
 
78
        
 
79
        if (!dict) return false;
 
80
        if ( (pyfunc = PyDict_GetItemString(dict, "previewProc")) == NULL ) {
 
81
                PyErr_Print();
 
82
                return false;
 
83
        }
 
84
        rv = PyObject_CallFunction(pyfunc, "s#", (void *)callBackParms, sizeof(NavCBRec));
 
85
        if ( rv ) {
 
86
                c_rv = PyObject_IsTrue(rv);
 
87
                Py_DECREF(rv);
 
88
        } else {
 
89
                PySys_WriteStderr("Nav: exception in previewProc callback\n");
 
90
                PyErr_Print();
 
91
        }
 
92
        return c_rv;
 
93
}
 
94
 
 
95
static pascal Boolean
 
96
my_filterProc(AEDesc *theItem, void *info,
 
97
                          NavCallBackUserData callbackUD,
 
98
                          NavFilterModes filterMode)
 
99
{
 
100
        PyObject *dict = (PyObject *)callbackUD;
 
101
        PyObject *pyfunc;
 
102
        PyObject *rv;
 
103
        Boolean c_rv = false;
 
104
        
 
105
        if (!dict) return false;
 
106
        if ( (pyfunc = PyDict_GetItemString(dict, "filterProc")) == NULL ) {
 
107
                PyErr_Print();
 
108
                return false;
 
109
        }
 
110
        rv = PyObject_CallFunction(pyfunc, "O&s#h",
 
111
                AEDesc_NewBorrowed, theItem, info, sizeof(NavFileOrFolderInfo), (short)filterMode);
 
112
        if ( rv ) {
 
113
                c_rv = PyObject_IsTrue(rv);
 
114
                Py_DECREF(rv);
 
115
        } else {
 
116
                PySys_WriteStderr("Nav: exception in filterProc callback\n");
 
117
                PyErr_Print();
 
118
        }
 
119
        return c_rv;
 
120
}
 
121
 
 
122
/* ----------------------------------------------------- */
 
123
static int
 
124
filldialogoptions(PyObject *d,
 
125
                AEDesc **defaultLocationP,
 
126
                NavDialogOptions *opt,
 
127
                NavEventUPP *eventProcP,
 
128
                NavPreviewUPP *previewProcP,
 
129
                NavObjectFilterUPP *filterProcP,
 
130
                NavTypeListHandle *typeListP,
 
131
                OSType *fileTypeP,
 
132
                OSType *fileCreatorP)
 
133
{
 
134
        Py_ssize_t pos = 0;
 
135
        PyObject *key, *value;
 
136
        char *keystr;
 
137
        AEDesc *defaultLocation_storage;
 
138
        
 
139
        NavGetDefaultDialogOptions(opt);
 
140
 
 
141
        while ( PyDict_Next(d, &pos, &key, &value) ) {
 
142
                if ( !key || !value || !PyString_Check(key) ) {
 
143
                        PyErr_SetString(ErrorObject, "DialogOption has non-string key");
 
144
                        return 0;
 
145
                }
 
146
                keystr = PyString_AsString(key);
 
147
                if( strcmp(keystr, "defaultLocation") == 0 ) {
 
148
                        if ( (defaultLocation_storage = PyMem_NEW(AEDesc, 1)) == NULL ) {
 
149
                                PyErr_NoMemory();
 
150
                                return 0;
 
151
                        }
 
152
                        if ( !PyArg_Parse(value, "O&", AEDesc_Convert, defaultLocation_storage) ) {
 
153
                                PyMem_DEL(defaultLocation_storage);
 
154
                                return 0;
 
155
                        }
 
156
                        *defaultLocationP = defaultLocation_storage;
 
157
                } else if( strcmp(keystr, "version") == 0 ) {
 
158
                        if ( !PyArg_Parse(value, "H", &opt->version) )
 
159
                                return 0;
 
160
                } else if( strcmp(keystr, "dialogOptionFlags") == 0 ) {
 
161
                        if ( !PyArg_Parse(value, "k", &opt->dialogOptionFlags) )
 
162
                                return 0;
 
163
                } else if( strcmp(keystr, "location") == 0 ) {
 
164
                        if ( !PyArg_Parse(value, "O&", PyMac_GetPoint, &opt->location) )
 
165
                                return 0;
 
166
                } else if( strcmp(keystr, "clientName") == 0 ) {
 
167
                        if ( !PyArg_Parse(value, "O&", PyMac_GetStr255, &opt->clientName) )
 
168
                                return 0;
 
169
                } else if( strcmp(keystr, "windowTitle") == 0 ) {
 
170
                        if ( !PyArg_Parse(value, "O&", PyMac_GetStr255, &opt->windowTitle) )
 
171
                                return 0;
 
172
                } else if( strcmp(keystr, "actionButtonLabel") == 0 ) {
 
173
                        if ( !PyArg_Parse(value, "O&", PyMac_GetStr255, &opt->actionButtonLabel) )
 
174
                                return 0;
 
175
                } else if( strcmp(keystr, "cancelButtonLabel") == 0 ) {
 
176
                        if ( !PyArg_Parse(value, "O&", PyMac_GetStr255, &opt->cancelButtonLabel) )
 
177
                                return 0;
 
178
                } else if( strcmp(keystr, "savedFileName") == 0 ) {
 
179
                        if ( !PyArg_Parse(value, "O&", PyMac_GetStr255, &opt->savedFileName) )
 
180
                                return 0;
 
181
                } else if( strcmp(keystr, "message") == 0 ) {
 
182
                        if ( !PyArg_Parse(value, "O&", PyMac_GetStr255, &opt->message) )
 
183
                                return 0;
 
184
                } else if( strcmp(keystr, "preferenceKey") == 0 ) {
 
185
                        if ( !PyArg_Parse(value, "O&", PyMac_GetOSType, &opt->preferenceKey) )
 
186
                                return 0;
 
187
#ifndef __LP64__
 
188
                } else if( strcmp(keystr, "popupExtension") == 0 ) {
 
189
                        if ( !PyArg_Parse(value, "O&", ResObj_Convert, &opt->popupExtension) )
 
190
                                return 0;
 
191
#endif /* !__LP64__ */
 
192
                } else if( eventProcP && strcmp(keystr, "eventProc") == 0 ) {
 
193
                        *eventProcP = my_eventProcUPP;
 
194
                } else if( previewProcP && strcmp(keystr, "previewProc") == 0 ) {
 
195
                        *previewProcP = my_previewProcUPP;
 
196
                } else if( filterProcP && strcmp(keystr, "filterProc") == 0 ) {
 
197
                        *filterProcP = my_filterProcUPP;
 
198
#ifndef __LP64__
 
199
                } else if( typeListP && strcmp(keystr, "typeList") == 0 ) {
 
200
                        if ( !PyArg_Parse(value, "O&", ResObj_Convert, typeListP) )
 
201
                                return 0;
 
202
#endif /* !__LP64__ */
 
203
                } else if( fileTypeP && strcmp(keystr, "fileType") == 0 ) {
 
204
                        if ( !PyArg_Parse(value, "O&", PyMac_GetOSType, fileTypeP) )
 
205
                                return 0;
 
206
                } else if( fileCreatorP && strcmp(keystr, "fileCreator") == 0 ) {
 
207
                        if ( !PyArg_Parse(value, "O&", PyMac_GetOSType, fileCreatorP) )
 
208
                                return 0;
 
209
                } else {
 
210
                        PyErr_Format(ErrorObject, "Unknown DialogOption key: %s", keystr);
 
211
                        return 0;
 
212
                }
 
213
        }
 
214
        return 1;
 
215
}
 
216
 
 
217
/* ----------------------------------------------------- */
 
218
 
 
219
/* Declarations for objects of type NavReplyRecord */
 
220
 
 
221
typedef struct {
 
222
        PyObject_HEAD
 
223
        NavReplyRecord itself;
 
224
} navrrobject;
 
225
 
 
226
static PyTypeObject Navrrtype;
 
227
 
 
228
 
 
229
 
 
230
/* ---------------------------------------------------------------- */
 
231
 
 
232
static char nav_NavTranslateFile__doc__[] =
 
233
"(NavTranslationOptions)->None"
 
234
;
 
235
 
 
236
static PyObject *
 
237
nav_NavTranslateFile(navrrobject *self, PyObject *args)
 
238
{
 
239
        NavTranslationOptions howToTranslate;
 
240
        OSErr err;
 
241
 
 
242
        if (!PyArg_ParseTuple(args, "k", &howToTranslate))
 
243
                return NULL;
 
244
        err = NavTranslateFile(&self->itself, howToTranslate);
 
245
        if ( err ) {
 
246
                PyErr_Mac(ErrorObject, err);
 
247
                return NULL;
 
248
        }
 
249
        Py_INCREF(Py_None);
 
250
        return Py_None;
 
251
}
 
252
 
 
253
static char nav_NavCompleteSave__doc__[] =
 
254
"(NavTranslationOptions)->None"
 
255
;
 
256
 
 
257
static PyObject *
 
258
nav_NavCompleteSave(navrrobject *self, PyObject *args)
 
259
{
 
260
        NavTranslationOptions howToTranslate;
 
261
        OSErr err;
 
262
 
 
263
        if (!PyArg_ParseTuple(args, "k", &howToTranslate))
 
264
                return NULL;
 
265
        err = NavCompleteSave(&self->itself, howToTranslate);
 
266
        if ( err ) {
 
267
                PyErr_Mac(ErrorObject, err);
 
268
                return NULL;
 
269
        }
 
270
        Py_INCREF(Py_None);
 
271
        return Py_None;
 
272
}
 
273
 
 
274
 
 
275
static struct PyMethodDef navrr_methods[] = {
 
276
 {"NavTranslateFile",   (PyCFunction)nav_NavTranslateFile,      METH_VARARGS,   nav_NavTranslateFile__doc__},
 
277
 {"NavCompleteSave",    (PyCFunction)nav_NavCompleteSave,       METH_VARARGS,   nav_NavCompleteSave__doc__},
 
278
        
 
279
        {NULL,          NULL}           /* sentinel */
 
280
};
 
281
 
 
282
/* ---------- */
 
283
 
 
284
 
 
285
static navrrobject *
 
286
newnavrrobject(NavReplyRecord *itself)
 
287
{
 
288
        navrrobject *self;
 
289
        
 
290
        self = PyObject_NEW(navrrobject, &Navrrtype);
 
291
        if (self == NULL)
 
292
                return NULL;
 
293
        self->itself = *itself;
 
294
        return self;
 
295
}
 
296
 
 
297
 
 
298
static void
 
299
navrr_dealloc(navrrobject *self)
 
300
{
 
301
        NavDisposeReply(&self->itself);
 
302
        PyObject_DEL(self);
 
303
}
 
304
 
 
305
static PyObject *
 
306
navrr_getattr(navrrobject *self, char *name)
 
307
{
 
308
        FSRef fsr;
 
309
#ifndef __LP64__
 
310
        FSSpec fss;
 
311
#endif /* !__LP64__ */
 
312
        
 
313
        if( strcmp(name, "__members__") == 0 )
 
314
                return Py_BuildValue(
 
315
#ifndef __LP64__
 
316
                                "ssssssssss", 
 
317
#else /* __LP64__ */
 
318
                                "ssssssssss", 
 
319
#endif /* __LP64__ */
 
320
                                "version", "validRecord", "replacing",
 
321
                        "isStationery", "translationNeeded", 
 
322
#ifndef __LP64__
 
323
                        "selection", 
 
324
#endif /* !__LP64__ */
 
325
                        "selection_fsr",
 
326
                        "fileTranslation", "keyScript", "saveFileName");
 
327
 
 
328
        if( strcmp(name, "version") == 0 )
 
329
                return Py_BuildValue("h", self->itself.version);
 
330
        if( strcmp(name, "validRecord") == 0 )
 
331
                return Py_BuildValue("l", (long)self->itself.validRecord);
 
332
        if( strcmp(name, "replacing") == 0 )
 
333
                return Py_BuildValue("l", (long)self->itself.replacing);
 
334
        if( strcmp(name, "isStationery") == 0 )
 
335
                return Py_BuildValue("l", (long)self->itself.isStationery);
 
336
        if( strcmp(name, "translationNeeded") == 0 )
 
337
                return Py_BuildValue("l", (long)self->itself.translationNeeded);
 
338
#ifndef __LP64__
 
339
        if( strcmp(name, "selection") == 0 ) {
 
340
                SInt32 i;
 
341
                long count;
 
342
                OSErr err;
 
343
                PyObject *rv, *rvitem;
 
344
                AEDesc desc;
 
345
                
 
346
                if ((err=AECountItems(&self->itself.selection, &count))) {
 
347
                        PyErr_Mac(ErrorObject, err);
 
348
                        return NULL;
 
349
                }
 
350
                if ( (rv=PyList_New(count)) == NULL )
 
351
                        return NULL;
 
352
                for(i=0; i<count; i++) {
 
353
                        desc.dataHandle = NULL;
 
354
                        if ((err=AEGetNthDesc(&self->itself.selection, i+1, typeFSS, NULL, &desc))) {
 
355
                                Py_DECREF(rv);
 
356
                                PyErr_Mac(ErrorObject, err);
 
357
                                return NULL;
 
358
                        }
 
359
                        if ((err=AEGetDescData(&desc, &fss, sizeof(FSSpec)))) {
 
360
                                Py_DECREF(rv);
 
361
                                PyErr_Mac(ErrorObject, err);
 
362
                                return NULL;
 
363
                        }
 
364
                        rvitem = PyMac_BuildFSSpec(&fss);
 
365
                        PyList_SetItem(rv, i, rvitem);
 
366
                        AEDisposeDesc(&desc);
 
367
                }
 
368
                return rv;
 
369
        }
 
370
#endif /* !__LP64__ */
 
371
        if( strcmp(name, "selection_fsr") == 0 ) {
 
372
                SInt32 i;
 
373
                long count;
 
374
                OSErr err;
 
375
                PyObject *rv, *rvitem;
 
376
                AEDesc desc;
 
377
                
 
378
                if ((err=AECountItems(&self->itself.selection, &count))) {
 
379
                        PyErr_Mac(ErrorObject, err);
 
380
                        return NULL;
 
381
                }
 
382
                if ( (rv=PyList_New(count)) == NULL )
 
383
                        return NULL;
 
384
                for(i=0; i<count; i++) {
 
385
                        desc.dataHandle = NULL;
 
386
                        if ((err=AEGetNthDesc(&self->itself.selection, i+1, typeFSRef, NULL, &desc))) {
 
387
                                Py_DECREF(rv);
 
388
                                PyErr_Mac(ErrorObject, err);
 
389
                                return NULL;
 
390
                        }
 
391
                        if ((err=AEGetDescData(&desc, &fsr, sizeof(FSRef)))) {
 
392
                                Py_DECREF(rv);
 
393
                                PyErr_Mac(ErrorObject, err);
 
394
                                return NULL;
 
395
                        }
 
396
                        rvitem = PyMac_BuildFSRef(&fsr);
 
397
                        PyList_SetItem(rv, i, rvitem);
 
398
                        AEDisposeDesc(&desc);
 
399
                }
 
400
                return rv;
 
401
        }
 
402
#ifndef __LP64__
 
403
        if( strcmp(name, "fileTranslation") == 0 )
 
404
                return ResObj_New((Handle)self->itself.fileTranslation);
 
405
#endif
 
406
        if( strcmp(name, "keyScript") == 0 )
 
407
                return Py_BuildValue("h", (short)self->itself.keyScript);
 
408
        if( strcmp(name, "saveFileName") == 0 )
 
409
                return Py_BuildValue("O&", CFStringRefObj_New, self->itself.saveFileName);
 
410
 
 
411
 
 
412
        return Py_FindMethod(navrr_methods, (PyObject *)self, name);
 
413
}
 
414
 
 
415
static int
 
416
navrr_setattr(navrrobject *self, char *name, PyObject *v)
 
417
{
 
418
        /* Set attribute 'name' to value 'v'. v==NULL means delete */
 
419
        
 
420
        /* XXXX Add your own setattr code here */
 
421
        return -1;
 
422
}
 
423
 
 
424
static char Navrrtype__doc__[] = 
 
425
"Record containing result of a Nav file selection call. Use dir() for member names."
 
426
;
 
427
 
 
428
static PyTypeObject Navrrtype = {
 
429
        PyObject_HEAD_INIT(&PyType_Type)
 
430
        0,                              /*ob_size*/
 
431
        "Nav.NavReplyRecord",                   /*tp_name*/
 
432
        sizeof(navrrobject),            /*tp_basicsize*/
 
433
        0,                              /*tp_itemsize*/
 
434
        /* methods */
 
435
        (destructor)navrr_dealloc,      /*tp_dealloc*/
 
436
        (printfunc)0,           /*tp_print*/
 
437
        (getattrfunc)navrr_getattr,     /*tp_getattr*/
 
438
        (setattrfunc)navrr_setattr,     /*tp_setattr*/
 
439
        (cmpfunc)0,             /*tp_compare*/
 
440
        (reprfunc)0,            /*tp_repr*/
 
441
        0,                      /*tp_as_number*/
 
442
        0,              /*tp_as_sequence*/
 
443
        0,              /*tp_as_mapping*/
 
444
        (hashfunc)0,            /*tp_hash*/
 
445
        (ternaryfunc)0,         /*tp_call*/
 
446
        (reprfunc)0,            /*tp_str*/
 
447
 
 
448
        /* Space for future expansion */
 
449
        0L,0L,0L,0L,
 
450
        Navrrtype__doc__ /* Documentation string */
 
451
};
 
452
 
 
453
/* End of code for NavReplyRecord objects */
 
454
                
 
455
/* ----------------------------------------------------- */
 
456
 
 
457
static char nav_NavGetFile__doc__[] =
 
458
"(DialogOptions dict or kwargs+defaultLocation,eventProc,previewProc,filterProc,typeList) -> NavReplyRecord"
 
459
;
 
460
 
 
461
static PyObject *
 
462
nav_NavGetFile(PyObject *self, PyObject *args, PyObject *kw)
 
463
{
 
464
        PyObject *dict;
 
465
        AEDesc  *defaultLocation = NULL;
 
466
        NavReplyRecord reply;
 
467
        NavDialogOptions dialogOptions;
 
468
        NavEventUPP eventProc = NULL;
 
469
        NavPreviewUPP previewProc = NULL;
 
470
        NavObjectFilterUPP filterProc = NULL;
 
471
        NavTypeListHandle typeList = NULL;
 
472
        OSErr err;
 
473
 
 
474
        if ( kw && PyObject_IsTrue(kw) ) {
 
475
                if (!PyArg_ParseTuple(args, ";either keyword arguments or dictionary expected"))
 
476
                        return NULL;
 
477
                dict = kw;
 
478
        } else if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &dict))
 
479
                return NULL;
 
480
        if (!filldialogoptions(dict, &defaultLocation, &dialogOptions, &eventProc, &previewProc, &filterProc, &typeList, NULL, NULL))
 
481
                return NULL;
 
482
        err = NavGetFile(defaultLocation, &reply, &dialogOptions,
 
483
                        eventProc, previewProc, filterProc, typeList, (void *)dict);
 
484
        PyMem_DEL(defaultLocation);
 
485
        if ( err ) {
 
486
                PyErr_Mac(ErrorObject, err);
 
487
                return NULL;
 
488
        }
 
489
        return (PyObject *)newnavrrobject(&reply);
 
490
}
 
491
 
 
492
static char nav_NavPutFile__doc__[] =
 
493
"(DialogOptions dict or kwargs+defaultLocation,eventProc,fileCreator,fileType) -> NavReplyRecord"
 
494
;
 
495
 
 
496
static PyObject *
 
497
nav_NavPutFile(PyObject *self, PyObject *args, PyObject *kw)
 
498
{
 
499
        PyObject *dict;
 
500
        AEDesc  *defaultLocation = NULL;
 
501
        NavReplyRecord reply;
 
502
        NavDialogOptions dialogOptions;
 
503
        NavEventUPP eventProc = NULL;
 
504
        OSType fileType;
 
505
        OSType fileCreator;
 
506
        OSErr err;
 
507
 
 
508
        if ( kw && PyObject_IsTrue(kw) ) {
 
509
                if (!PyArg_ParseTuple(args, ";either keyword arguments or dictionary expected"))
 
510
                        return NULL;
 
511
                dict = kw;
 
512
        } else if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &dict))
 
513
                return NULL;
 
514
        if (!filldialogoptions(dict, &defaultLocation, &dialogOptions, &eventProc, NULL, NULL, NULL, &fileType, &fileCreator))
 
515
                return NULL;
 
516
        err = NavPutFile(defaultLocation, &reply, &dialogOptions,
 
517
                        eventProc, fileType, fileCreator, (void *)dict);
 
518
        PyMem_DEL(defaultLocation);
 
519
        if ( err ) {
 
520
                PyErr_Mac(ErrorObject, err);
 
521
                return NULL;
 
522
        }
 
523
        return (PyObject *)newnavrrobject(&reply);
 
524
}
 
525
 
 
526
static char nav_NavAskSaveChanges__doc__[] =
 
527
"(NavAskSaveChangesAction, DialogOptions dict or kwargs+eventProc) -> NavAskSaveChangesResult"
 
528
 
 
529
;
 
530
 
 
531
static PyObject *
 
532
nav_NavAskSaveChanges(PyObject *self, PyObject *args, PyObject *kw)
 
533
{
 
534
        PyObject *dict;
 
535
        NavDialogOptions dialogOptions;
 
536
        NavAskSaveChangesAction action;
 
537
        NavAskSaveChangesResult reply;
 
538
        NavEventUPP eventProc = NULL;
 
539
        OSErr err;
 
540
 
 
541
        if ( kw && PyObject_IsTrue(kw) ) {
 
542
                if (!PyArg_ParseTuple(args, "k", &action))
 
543
                        return NULL;
 
544
                dict = kw;
 
545
        } else if (!PyArg_ParseTuple(args, "lO!", &action, &PyDict_Type, &dict))
 
546
                return NULL;
 
547
        if (!filldialogoptions(dict, NULL, &dialogOptions, &eventProc, NULL, NULL, NULL, NULL, NULL))
 
548
                return NULL;
 
549
        err = NavAskSaveChanges(&dialogOptions, action, &reply, eventProc, (void *)dict);
 
550
        if ( err ) {
 
551
                PyErr_Mac(ErrorObject, err);
 
552
                return NULL;
 
553
        }
 
554
        return Py_BuildValue("l", (long)reply);
 
555
}
 
556
 
 
557
static char nav_NavCustomAskSaveChanges__doc__[] =
 
558
"(DialogOptions dict or kwargs+eventProc) -> NavAskSaveChangesResult"
 
559
;
 
560
 
 
561
static PyObject *
 
562
nav_NavCustomAskSaveChanges(PyObject *self, PyObject *args, PyObject *kw)
 
563
{
 
564
        PyObject *dict;
 
565
        NavDialogOptions dialogOptions;
 
566
        NavAskSaveChangesResult reply;
 
567
        NavEventUPP eventProc = NULL;
 
568
        OSErr err;
 
569
 
 
570
        if ( kw && PyObject_IsTrue(kw) ) {
 
571
                if (!PyArg_ParseTuple(args, ";either keyword arguments or dictionary expected"))
 
572
                        return NULL;
 
573
                dict = kw;
 
574
        } else if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &dict))
 
575
                return NULL;
 
576
        if (!filldialogoptions(dict, NULL, &dialogOptions, &eventProc, NULL, NULL, NULL, NULL, NULL))
 
577
                return NULL;
 
578
        err = NavCustomAskSaveChanges(&dialogOptions, &reply, eventProc, (void *)dict);
 
579
        if ( err ) {
 
580
                PyErr_Mac(ErrorObject, err);
 
581
                return NULL;
 
582
        }
 
583
        return Py_BuildValue("l", (long)reply);
 
584
}
 
585
 
 
586
static char nav_NavAskDiscardChanges__doc__[] =
 
587
"(DialogOptions dict or kwargs+eventProc) -> NavAskSaveChangesResult"
 
588
;
 
589
 
 
590
static PyObject *
 
591
nav_NavAskDiscardChanges(PyObject *self, PyObject *args, PyObject *kw)
 
592
{
 
593
        PyObject *dict;
 
594
        NavDialogOptions dialogOptions;
 
595
        NavAskSaveChangesResult reply;
 
596
        NavEventUPP eventProc = NULL;
 
597
        OSErr err;
 
598
 
 
599
        if ( kw && PyObject_IsTrue(kw) ) {
 
600
                if (!PyArg_ParseTuple(args, ";either keyword arguments or dictionary expected"))
 
601
                        return NULL;
 
602
                dict = kw;
 
603
        } else if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &dict))
 
604
                return NULL;
 
605
        if (!filldialogoptions(dict, NULL, &dialogOptions, &eventProc, NULL, NULL, NULL, NULL, NULL))
 
606
                return NULL;
 
607
        err = NavAskDiscardChanges(&dialogOptions, &reply, eventProc, (void *)dict);
 
608
        if ( err ) {
 
609
                PyErr_Mac(ErrorObject, err);
 
610
                return NULL;
 
611
        }
 
612
        return Py_BuildValue("l", (long)reply);
 
613
}
 
614
 
 
615
static char nav_NavChooseFile__doc__[] =
 
616
"(DialogOptions dict or kwargs+defaultLocation,eventProc,previewProc,filterProc,typeList) -> NavReplyRecord"
 
617
;
 
618
 
 
619
static PyObject *
 
620
nav_NavChooseFile(PyObject *self, PyObject *args, PyObject *kw)
 
621
{
 
622
        PyObject *dict;
 
623
        AEDesc  *defaultLocation = NULL;
 
624
        NavReplyRecord reply;
 
625
        NavDialogOptions dialogOptions;
 
626
        NavEventUPP eventProc = NULL;
 
627
        NavPreviewUPP previewProc = NULL;
 
628
        NavObjectFilterUPP filterProc = NULL;
 
629
        NavTypeListHandle typeList = NULL;
 
630
        OSErr err;
 
631
 
 
632
        if ( kw && PyObject_IsTrue(kw) ) {
 
633
                if (!PyArg_ParseTuple(args, ";either keyword arguments or dictionary expected"))
 
634
                        return NULL;
 
635
                dict = kw;
 
636
        } else if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &dict))
 
637
                return NULL;
 
638
        if (!filldialogoptions(dict, &defaultLocation, &dialogOptions, &eventProc, &previewProc, &filterProc, &typeList, NULL, NULL))
 
639
                return NULL;
 
640
        err = NavChooseFile(defaultLocation, &reply, &dialogOptions,
 
641
                        eventProc, previewProc, filterProc, typeList, (void *)dict);
 
642
        PyMem_DEL(defaultLocation);
 
643
        if ( err ) {
 
644
                PyErr_Mac(ErrorObject, err);
 
645
                return NULL;
 
646
        }
 
647
        return (PyObject *)newnavrrobject(&reply);
 
648
}
 
649
 
 
650
static char nav_NavChooseFolder__doc__[] =
 
651
"(DialogOptions dict or kwargs+defaultLocation,eventProc,filterProc) -> NavReplyRecord"
 
652
;
 
653
 
 
654
static PyObject *
 
655
nav_NavChooseFolder(PyObject *self, PyObject *args, PyObject *kw)
 
656
{
 
657
        PyObject *dict;
 
658
        AEDesc  *defaultLocation = NULL;
 
659
        NavReplyRecord reply;
 
660
        NavDialogOptions dialogOptions;
 
661
        NavEventUPP eventProc = NULL;
 
662
        NavObjectFilterUPP filterProc = NULL;
 
663
        OSErr err;
 
664
 
 
665
        if ( kw && PyObject_IsTrue(kw) ) {
 
666
                if (!PyArg_ParseTuple(args, ";either keyword arguments or dictionary expected"))
 
667
                        return NULL;
 
668
                dict = kw;
 
669
        } else if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &dict))
 
670
                return NULL;
 
671
        if (!filldialogoptions(dict, &defaultLocation, &dialogOptions, &eventProc, NULL, &filterProc, NULL, NULL, NULL))
 
672
                return NULL;
 
673
        err = NavChooseFolder(defaultLocation, &reply, &dialogOptions,
 
674
                        eventProc, filterProc, (void *)dict);
 
675
        PyMem_DEL(defaultLocation);
 
676
        if ( err ) {
 
677
                PyErr_Mac(ErrorObject, err);
 
678
                return NULL;
 
679
        }
 
680
        return (PyObject *)newnavrrobject(&reply);
 
681
}
 
682
 
 
683
static char nav_NavChooseVolume__doc__[] =
 
684
"(DialogOptions dict or kwargs+defaultLocation,eventProc,filterProc) -> NavReplyRecord"
 
685
;
 
686
 
 
687
static PyObject *
 
688
nav_NavChooseVolume(PyObject *self, PyObject *args, PyObject *kw)
 
689
{
 
690
        PyObject *dict;
 
691
        AEDesc  *defaultLocation = NULL;
 
692
        NavReplyRecord reply;
 
693
        NavDialogOptions dialogOptions;
 
694
        NavEventUPP eventProc = NULL;
 
695
        NavObjectFilterUPP filterProc = NULL;
 
696
        OSErr err;
 
697
 
 
698
        if ( kw && PyObject_IsTrue(kw) ) {
 
699
                if (!PyArg_ParseTuple(args, ";either keyword arguments or dictionary expected"))
 
700
                        return NULL;
 
701
                dict = kw;
 
702
        } else if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &dict))
 
703
                return NULL;
 
704
        if (!filldialogoptions(dict, &defaultLocation, &dialogOptions, &eventProc, NULL, &filterProc, NULL, NULL, NULL))
 
705
                return NULL;
 
706
        err = NavChooseVolume(defaultLocation, &reply, &dialogOptions,
 
707
                        eventProc, filterProc, (void *)dict);
 
708
        PyMem_DEL(defaultLocation);
 
709
        if ( err ) {
 
710
                PyErr_Mac(ErrorObject, err);
 
711
                return NULL;
 
712
        }
 
713
        return (PyObject *)newnavrrobject(&reply);
 
714
}
 
715
 
 
716
static char nav_NavChooseObject__doc__[] =
 
717
"(DialogOptions dict or kwargs+defaultLocation,eventProc,filterProc) -> NavReplyRecord"
 
718
;
 
719
 
 
720
static PyObject *
 
721
nav_NavChooseObject(PyObject *self, PyObject *args, PyObject *kw)
 
722
{
 
723
        PyObject *dict;
 
724
        AEDesc  *defaultLocation = NULL;
 
725
        NavReplyRecord reply;
 
726
        NavDialogOptions dialogOptions;
 
727
        NavEventUPP eventProc = NULL;
 
728
        NavObjectFilterUPP filterProc = NULL;
 
729
        OSErr err;
 
730
 
 
731
        if ( kw && PyObject_IsTrue(kw) ) {
 
732
                if (!PyArg_ParseTuple(args, ";either keyword arguments or dictionary expected"))
 
733
                        return NULL;
 
734
                dict = kw;
 
735
        } else if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &dict))
 
736
                return NULL;
 
737
        if (!filldialogoptions(dict, &defaultLocation, &dialogOptions, &eventProc, NULL, &filterProc, NULL, NULL, NULL))
 
738
                return NULL;
 
739
        err = NavChooseObject(defaultLocation, &reply, &dialogOptions,
 
740
                        eventProc, filterProc, (void *)dict);
 
741
        PyMem_DEL(defaultLocation);
 
742
        if ( err ) {
 
743
                PyErr_Mac(ErrorObject, err);
 
744
                return NULL;
 
745
        }
 
746
        return (PyObject *)newnavrrobject(&reply);
 
747
}
 
748
 
 
749
static char nav_NavNewFolder__doc__[] =
 
750
"(DialogOptions dict or kwargs+defaultLocation,eventProc) -> NavReplyRecord"
 
751
;
 
752
 
 
753
static PyObject *
 
754
nav_NavNewFolder(PyObject *self, PyObject *args, PyObject *kw)
 
755
{
 
756
        PyObject *dict;
 
757
        AEDesc  *defaultLocation = NULL;
 
758
        NavReplyRecord reply;
 
759
        NavDialogOptions dialogOptions;
 
760
        NavEventUPP eventProc = NULL;
 
761
        OSErr err;
 
762
 
 
763
        if ( kw && PyObject_IsTrue(kw) ) {
 
764
                if (!PyArg_ParseTuple(args, ";either keyword arguments or dictionary expected"))
 
765
                        return NULL;
 
766
                dict = kw;
 
767
        } else if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &dict))
 
768
                return NULL;
 
769
        if (!filldialogoptions(dict, &defaultLocation, &dialogOptions, &eventProc, NULL, NULL, NULL, NULL, NULL))
 
770
                return NULL;
 
771
        err = NavNewFolder(defaultLocation, &reply, &dialogOptions, eventProc, (void *)dict);
 
772
        PyMem_DEL(defaultLocation);
 
773
        if ( err ) {
 
774
                PyErr_Mac(ErrorObject, err);
 
775
                return NULL;
 
776
        }
 
777
        return (PyObject *)newnavrrobject(&reply);
 
778
}
 
779
 
 
780
#if 0
 
781
/* XXXX I don't know what to do with the void * argument */
 
782
static char nav_NavCustomControl__doc__[] =
 
783
""
 
784
;
 
785
 
 
786
 
 
787
static PyObject *
 
788
nav_NavCustomControl(PyObject *self, PyObject *args)
 
789
{
 
790
 
 
791
        if (!PyArg_ParseTuple(args, ""))
 
792
                return NULL;
 
793
        Py_INCREF(Py_None);
 
794
        return Py_None;
 
795
}
 
796
#endif
 
797
 
 
798
static char nav_NavServicesCanRun__doc__[] =
 
799
"()->int"
 
800
;
 
801
 
 
802
static PyObject *
 
803
nav_NavServicesCanRun(PyObject *self, PyObject *args)
 
804
{
 
805
        Boolean rv;
 
806
        if (!PyArg_ParseTuple(args, ""))
 
807
                return NULL;
 
808
        rv = NavServicesCanRun();
 
809
        return Py_BuildValue("l", (long)rv);
 
810
}
 
811
 
 
812
static char nav_NavServicesAvailable__doc__[] =
 
813
"()->int"
 
814
;
 
815
 
 
816
static PyObject *
 
817
nav_NavServicesAvailable(PyObject *self, PyObject *args)
 
818
{
 
819
        Boolean rv;
 
820
        
 
821
        if (!PyArg_ParseTuple(args, ""))
 
822
                return NULL;
 
823
        rv = NavServicesAvailable();
 
824
        return Py_BuildValue("l", (long)rv);
 
825
}
 
826
/* XX */
 
827
static char nav_NavLoad__doc__[] =
 
828
"()->None"
 
829
;
 
830
 
 
831
static PyObject *
 
832
nav_NavLoad(PyObject *self, PyObject *args)
 
833
{
 
834
 
 
835
        if (!PyArg_ParseTuple(args, ""))
 
836
                return NULL;
 
837
        NavLoad();
 
838
        Py_INCREF(Py_None);
 
839
        return Py_None;
 
840
}
 
841
 
 
842
static char nav_NavUnload__doc__[] =
 
843
"()->None"
 
844
;
 
845
 
 
846
static PyObject *
 
847
nav_NavUnload(PyObject *self, PyObject *args)
 
848
{
 
849
 
 
850
        if (!PyArg_ParseTuple(args, ""))
 
851
                return NULL;
 
852
        NavUnload();
 
853
        Py_INCREF(Py_None);
 
854
        return Py_None;
 
855
}
 
856
 
 
857
static char nav_NavLibraryVersion__doc__[] =
 
858
"()->int"
 
859
;
 
860
 
 
861
static PyObject *
 
862
nav_NavLibraryVersion(PyObject *self, PyObject *args)
 
863
{
 
864
        UInt32 rv;
 
865
        
 
866
        if (!PyArg_ParseTuple(args, ""))
 
867
                return NULL;
 
868
        rv = NavLibraryVersion();
 
869
        return Py_BuildValue("l", (long)rv);
 
870
}
 
871
 
 
872
static char nav_NavGetDefaultDialogOptions__doc__[] =
 
873
"()->dict\nPass dict or keyword args with same names to other calls."
 
874
;
 
875
 
 
876
static PyObject *
 
877
nav_NavGetDefaultDialogOptions(PyObject *self, PyObject *args)
 
878
{
 
879
        NavDialogOptions dialogOptions;
 
880
        OSErr err;
 
881
        
 
882
        err = NavGetDefaultDialogOptions(&dialogOptions);
 
883
        if ( err ) {
 
884
                PyErr_Mac(ErrorObject, err);
 
885
                return NULL;
 
886
        }
 
887
        return Py_BuildValue(
 
888
#ifndef __LP64__
 
889
                        "{s:h,s:l,s:O&,s:O&,s:O&,s:O&,s:O&,s:O&,s:O&,s:O&,s:O&}",
 
890
#else /* __LP64__ */
 
891
                        "{s:h,s:l,s:O&,s:O&,s:O&,s:O&,s:O&,s:O&,s:O&,s:O&}",
 
892
#endif /* __LP64__ */
 
893
                "version", dialogOptions.version,
 
894
                "dialogOptionFlags", dialogOptions.dialogOptionFlags,
 
895
                "location", PyMac_BuildPoint, dialogOptions.location,
 
896
                "clientName", PyMac_BuildStr255, &dialogOptions.clientName,
 
897
                "windowTitle", PyMac_BuildStr255, &dialogOptions.windowTitle,
 
898
                "actionButtonLabel", PyMac_BuildStr255, &dialogOptions.actionButtonLabel,
 
899
                "cancelButtonLabel", PyMac_BuildStr255, &dialogOptions.cancelButtonLabel,
 
900
                "savedFileName", PyMac_BuildStr255, &dialogOptions.savedFileName,
 
901
                "message", PyMac_BuildStr255, &dialogOptions.message,
 
902
                "preferenceKey", PyMac_BuildOSType, dialogOptions.preferenceKey
 
903
#ifndef __LP64__
 
904
                ,"popupExtension", OptResObj_New, dialogOptions.popupExtension
 
905
#endif /* __LP64__ */
 
906
                );
 
907
}
 
908
 
 
909
/* List of methods defined in the module */
 
910
 
 
911
static struct PyMethodDef nav_methods[] = {
 
912
        {"NavGetFile",  (PyCFunction)nav_NavGetFile,    METH_VARARGS|METH_KEYWORDS,     nav_NavGetFile__doc__},
 
913
 {"NavPutFile", (PyCFunction)nav_NavPutFile,    METH_VARARGS|METH_KEYWORDS,     nav_NavPutFile__doc__},
 
914
 {"NavAskSaveChanges",  (PyCFunction)nav_NavAskSaveChanges,     METH_VARARGS|METH_KEYWORDS,     nav_NavAskSaveChanges__doc__},
 
915
 {"NavCustomAskSaveChanges",    (PyCFunction)nav_NavCustomAskSaveChanges,       METH_VARARGS|METH_KEYWORDS,     nav_NavCustomAskSaveChanges__doc__},
 
916
 {"NavAskDiscardChanges",       (PyCFunction)nav_NavAskDiscardChanges,  METH_VARARGS|METH_KEYWORDS,     nav_NavAskDiscardChanges__doc__},
 
917
 {"NavChooseFile",      (PyCFunction)nav_NavChooseFile, METH_VARARGS|METH_KEYWORDS,     nav_NavChooseFile__doc__},
 
918
 {"NavChooseFolder",    (PyCFunction)nav_NavChooseFolder,       METH_VARARGS|METH_KEYWORDS,     nav_NavChooseFolder__doc__},
 
919
 {"NavChooseVolume",    (PyCFunction)nav_NavChooseVolume,       METH_VARARGS|METH_KEYWORDS,     nav_NavChooseVolume__doc__},
 
920
 {"NavChooseObject",    (PyCFunction)nav_NavChooseObject,       METH_VARARGS|METH_KEYWORDS,     nav_NavChooseObject__doc__},
 
921
 {"NavNewFolder",       (PyCFunction)nav_NavNewFolder,  METH_VARARGS|METH_KEYWORDS,     nav_NavNewFolder__doc__},
 
922
#if 0
 
923
 {"NavCustomControl",   (PyCFunction)nav_NavCustomControl,      METH_VARARGS,   nav_NavCustomControl__doc__},
 
924
#endif
 
925
 {"NavServicesCanRun",  (PyCFunction)nav_NavServicesCanRun,     METH_VARARGS,   nav_NavServicesCanRun__doc__},
 
926
 {"NavServicesAvailable",       (PyCFunction)nav_NavServicesAvailable,  METH_VARARGS,   nav_NavServicesAvailable__doc__},
 
927
 {"NavLoad",    (PyCFunction)nav_NavLoad,       METH_VARARGS,   nav_NavLoad__doc__},
 
928
 {"NavUnload",  (PyCFunction)nav_NavUnload,     METH_VARARGS,   nav_NavUnload__doc__},
 
929
 {"NavLibraryVersion",  (PyCFunction)nav_NavLibraryVersion,     METH_VARARGS,   nav_NavLibraryVersion__doc__},
 
930
 {"NavGetDefaultDialogOptions", (PyCFunction)nav_NavGetDefaultDialogOptions,    METH_VARARGS,   nav_NavGetDefaultDialogOptions__doc__},
 
931
        {NULL,   (PyCFunction)NULL, 0, NULL}            /* sentinel */
 
932
};
 
933
 
 
934
 
 
935
/* Initialization function for the module (*must* be called initNav) */
 
936
 
 
937
static char Nav_module_documentation[] = 
 
938
"Interface to Navigation Services\n"
 
939
"Most calls accept a NavDialogOptions dictionary or keywords with the same names, pass {}\n"
 
940
"if you want the default options.\n"
 
941
"Use NavGetDefaultDialogOptions() to find out common option names.\n"
 
942
"See individual docstrings for additional keyword args/dictentries supported by each call.\n"
 
943
"Pass None as eventProc to get movable-modal dialogs that process updates through the standard Python mechanism."
 
944
;
 
945
 
 
946
void
 
947
initNav(void)
 
948
{
 
949
        PyObject *m, *d;
 
950
        
 
951
        if (PyErr_WarnPy3k("In 3.x, Nav is removed.", 1))
 
952
                return;
 
953
 
 
954
        /* Test that we have NavServices */
 
955
        if ( !NavServicesAvailable() ) {
 
956
                PyErr_SetString(PyExc_ImportError, "Navigation Services not available");
 
957
                return;
 
958
        }
 
959
        /* Create the module and add the functions */
 
960
        m = Py_InitModule4("Nav", nav_methods,
 
961
                Nav_module_documentation,
 
962
                (PyObject*)NULL,PYTHON_API_VERSION);
 
963
 
 
964
        /* Add some symbolic constants to the module */
 
965
        d = PyModule_GetDict(m);
 
966
        ErrorObject = PyString_FromString("Nav.error");
 
967
        PyDict_SetItemString(d, "error", ErrorObject);
 
968
 
 
969
        /* XXXX Add constants here */
 
970
        
 
971
        /* Set UPPs */
 
972
        my_eventProcUPP = NewNavEventUPP(my_eventProc);
 
973
        my_previewProcUPP = NewNavPreviewUPP(my_previewProc);
 
974
        my_filterProcUPP = NewNavObjectFilterUPP(my_filterProc);
 
975
        
 
976
}
 
977