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