Mac/Modules/macfsmodule.c

   1 /***********************************************************
   2 Copyright 1991-1997 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 not be used in advertising or publicity pertaining to
  13 distribution of the software without specific, written prior permission.
  14
  15 STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16 THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17 FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18 FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21 OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22
  23 ******************************************************************/
  24
  25 #include "Python.h"
  26 #include "macglue.h"
  27
  28 #include <Memory.h>
  29 #include <Files.h>
  30 #include <Folders.h>
  31 #include <StandardFile.h>
  32 #include <Aliases.h>
  33 #include <LowMem.h>
  34
  35 #include "getapplbycreator.h"
  36
  37 #ifdef THINK_C
  38 #define FileFilterUPP FileFilterProcPtr
  39 #endif
  40
  41 static PyObject *ErrorObject;
  42
  43 /* ----------------------------------------------------- */
  44 /* Declarations for objects of type Alias */
  45
  46 typedef struct {
  47         PyObject_HEAD
  48         AliasHandle alias;
  49 } mfsaobject;
  50
  51 staticforward PyTypeObject Mfsatype;
  52
  53 #define is_mfsaobject(v)                ((v)->ob_type == &Mfsatype)
  54
  55 /* ---------------------------------------------------------------- */
  56 /* Declarations for objects of type FSSpec */
  57
  58 typedef struct {
  59         PyObject_HEAD
  60         FSSpec fsspec;
  61 } mfssobject;
  62
  63 staticforward PyTypeObject Mfsstype;
  64
  65 #define is_mfssobject(v)                ((v)->ob_type == &Mfsstype)
  66
  67
  68 /* ---------------------------------------------------------------- */
  69 /* Declarations for objects of type FInfo */
  70
  71 typedef struct {
  72         PyObject_HEAD
  73         FInfo finfo;
  74 } mfsiobject;
  75
  76 staticforward PyTypeObject Mfsitype;
  77
  78 #define is_mfsiobject(v)                ((v)->ob_type == &Mfsitype)
  79
  80
  81 mfssobject *newmfssobject(FSSpec *fss); /* Forward */
  82
  83 /* ---------------------------------------------------------------- */
  84
  85 static PyObject *
  86 mfsa_Resolve(self, args)
  87         mfsaobject *self;
  88         PyObject *args;
  89 {
  90         FSSpec from, *fromp, result;
  91         Boolean changed;
  92         OSErr err;
  93
  94         from.name[0] = 0;
  95         if (!PyArg_ParseTuple(args, "|O&", PyMac_GetFSSpec, &from))
  96                 return NULL;
  97         if (from.name[0] )
  98                 fromp = &from;
  99         else
 100                 fromp = NULL;
 101         err = ResolveAlias(fromp, self->alias, &result, &changed);
 102         if ( err && err != fnfErr ) {
 103                 PyErr_Mac(ErrorObject, err);
 104                 return NULL;
 105         }
 106         return Py_BuildValue("(Oi)", newmfssobject(&result), (int)changed);
 107 }
 108
 109 static PyObject *
 110 mfsa_GetInfo(self, args)
 111         mfsaobject *self;
 112         PyObject *args;
 113 {
 114         Str63 value;
 115         int i;
 116         OSErr err;
 117
 118         if (!PyArg_ParseTuple(args, "i", &i))
 119                 return NULL;
 120         err = GetAliasInfo(self->alias, (AliasInfoType)i, value);
 121         if ( err ) {
 122                 PyErr_Mac(ErrorObject, err);
 123                 return 0;
 124         }
 125         return PyString_FromStringAndSize((char *)&value[1], value[0]);
 126 }
 127
 128 static PyObject *
 129 mfsa_Update(self, args)
 130         mfsaobject *self;
 131         PyObject *args;
 132 {
 133         FSSpec target, fromfile, *fromfilep;
 134         OSErr err;
 135         Boolean changed;
 136
 137         fromfile.name[0] = 0;
 138         if (!PyArg_ParseTuple(args, "O&|O&",  PyMac_GetFSSpec, &target,
 139                                          PyMac_GetFSSpec, &fromfile))
 140                 return NULL;
 141         if ( fromfile.name[0] )
 142                 fromfilep = &fromfile;
 143         else
 144                 fromfilep = NULL;
 145         err = UpdateAlias(fromfilep, &target, self->alias, &changed);
 146         if ( err ) {
 147                 PyErr_Mac(ErrorObject, err);
 148                 return 0;
 149         }
 150         return Py_BuildValue("i", (int)changed);
 151 }
 152
 153 static struct PyMethodDef mfsa_methods[] = {
 154         {"Resolve",     (PyCFunction)mfsa_Resolve,      1},
 155         {"GetInfo",     (PyCFunction)mfsa_GetInfo,      1},
 156         {"Update",      (PyCFunction)mfsa_Update,       1},
 157
 158         {NULL,          NULL}           /* sentinel */
 159 };
 160
 161 /* ---------- */
 162
 163 static PyObject *
 164 mfsa_getattr(self, name)
 165         mfsaobject *self;
 166         char *name;
 167 {
 168         if ( strcmp(name, "data") == 0 ) {
 169                 int size;
 170                 PyObject *rv;
 171
 172                 size = GetHandleSize((Handle)self->alias);
 173                 HLock((Handle)self->alias);
 174                 rv = PyString_FromStringAndSize(*(Handle)self->alias, size);
 175                 HUnlock((Handle)self->alias);
 176                 return rv;
 177         }
 178         return Py_FindMethod(mfsa_methods, (PyObject *)self, name);
 179 }
 180
 181 mfsaobject *
 182 newmfsaobject(alias)
 183         AliasHandle alias;
 184 {
 185         mfsaobject *self;
 186
 187         self = PyObject_NEW(mfsaobject, &Mfsatype);
 188         if (self == NULL)
 189                 return NULL;
 190         self->alias = alias;
 191         return self;
 192 }
 193
 194
 195 static void
 196 mfsa_dealloc(self)
 197         mfsaobject *self;
 198 {
 199 #if 0
 200         if ( self->alias ) {
 201                 should we do something here?
 202         }
 203 #endif
 204
 205         PyMem_DEL(self);
 206 }
 207
 208 statichere PyTypeObject Mfsatype = {
 209         PyObject_HEAD_INIT(&PyType_Type)
 210         0,                              /*ob_size*/
 211         "Alias",                        /*tp_name*/
 212         sizeof(mfsaobject),             /*tp_basicsize*/
 213         0,                              /*tp_itemsize*/
 214         /* methods */
 215         (destructor)mfsa_dealloc,       /*tp_dealloc*/
 216         (printfunc)0,                   /*tp_print*/
 217         (getattrfunc)mfsa_getattr,      /*tp_getattr*/
 218         (setattrfunc)0,                 /*tp_setattr*/
 219         (cmpfunc)0,                     /*tp_compare*/
 220         (reprfunc)0,                    /*tp_repr*/
 221         0,                              /*tp_as_number*/
 222         0,                              /*tp_as_sequence*/
 223         0,                              /*tp_as_mapping*/
 224         (hashfunc)0,                    /*tp_hash*/
 225 };
 226
 227 /* End of code for Alias objects */
 228 /* -------------------------------------------------------- */
 229
 230 /* ---------------------------------------------------------------- */
 231
 232 static struct PyMethodDef mfsi_methods[] = {
 233
 234         {NULL,          NULL}           /* sentinel */
 235 };
 236
 237 /* ---------- */
 238
 239 static mfsiobject *
 240 newmfsiobject()
 241 {
 242         mfsiobject *self;
 243
 244         self = PyObject_NEW(mfsiobject, &Mfsitype);
 245         if (self == NULL)
 246                 return NULL;
 247         memset((char *)&self->finfo, '\0', sizeof(self->finfo));
 248         return self;
 249 }
 250
 251 static void
 252 mfsi_dealloc(self)
 253         mfsiobject *self;
 254 {
 255         PyMem_DEL(self);
 256 }
 257
 258 static PyObject *
 259 mfsi_getattr(self, name)
 260         mfsiobject *self;
 261         char *name;
 262 {
 263         if ( strcmp(name, "Type") == 0 )
 264                 return PyMac_BuildOSType(self->finfo.fdType);
 265         else if ( strcmp(name, "Creator") == 0 )
 266                 return PyMac_BuildOSType(self->finfo.fdCreator);
 267         else if ( strcmp(name, "Flags") == 0 )
 268                 return Py_BuildValue("i", (int)self->finfo.fdFlags);
 269         else if ( strcmp(name, "Location") == 0 )
 270                 return PyMac_BuildPoint(self->finfo.fdLocation);
 271         else if ( strcmp(name, "Fldr") == 0 )
 272                 return Py_BuildValue("i", (int)self->finfo.fdFldr);
 273         else
 274                 return Py_FindMethod(mfsi_methods, (PyObject *)self, name);
 275 }
 276
 277
 278 static int
 279 mfsi_setattr(self, name, v)
 280         mfsiobject *self;
 281         char *name;
 282         PyObject *v;
 283 {
 284         int rv;
 285         int i;
 286
 287         if ( v == NULL ) {
 288                 PyErr_SetString(PyExc_AttributeError, "Cannot delete attribute");
 289                 return -1;
 290         }
 291         if ( strcmp(name, "Type") == 0 )
 292                 rv = PyMac_GetOSType(v, &self->finfo.fdType);
 293         else if ( strcmp(name, "Creator") == 0 )
 294                 rv = PyMac_GetOSType(v, &self->finfo.fdCreator);
 295         else if ( strcmp(name, "Flags") == 0 ) {
 296                 rv = PyArg_Parse(v, "i", &i);
 297                 self->finfo.fdFlags = (short)i;
 298         } else if ( strcmp(name, "Location") == 0 )
 299                 rv = PyMac_GetPoint(v, &self->finfo.fdLocation);
 300         else if ( strcmp(name, "Fldr") == 0 ) {
 301                 rv = PyArg_Parse(v, "i", &i);
 302                 self->finfo.fdFldr = (short)i;
 303         } else {
 304                 PyErr_SetString(PyExc_AttributeError, "No such attribute");
 305                 return -1;
 306         }
 307         if (rv)
 308                 return 0;
 309         return -1;
 310 }
 311
 312
 313 static PyTypeObject Mfsitype = {
 314         PyObject_HEAD_INIT(&PyType_Type)
 315         0,                              /*ob_size*/
 316         "FInfo",                        /*tp_name*/
 317         sizeof(mfsiobject),             /*tp_basicsize*/
 318         0,                              /*tp_itemsize*/
 319         /* methods */
 320         (destructor)mfsi_dealloc,       /*tp_dealloc*/
 321         (printfunc)0,           /*tp_print*/
 322         (getattrfunc)mfsi_getattr,      /*tp_getattr*/
 323         (setattrfunc)mfsi_setattr,      /*tp_setattr*/
 324         (cmpfunc)0,             /*tp_compare*/
 325         (reprfunc)0,            /*tp_repr*/
 326         0,                      /*tp_as_number*/
 327         0,              /*tp_as_sequence*/
 328         0,              /*tp_as_mapping*/
 329         (hashfunc)0,            /*tp_hash*/
 330 };
 331
 332 /* End of code for FInfo object objects */
 333 /* -------------------------------------------------------- */
 334
 335
 336 /*
 337 ** Helper routine for other modules: return an FSSpec * if the
 338 ** object is a python fsspec object, else NULL
 339 */
 340 FSSpec *
 341 mfs_GetFSSpecFSSpec(self)
 342         PyObject *self;
 343 {
 344         if ( is_mfssobject(self) )
 345                 return &((mfssobject *)self)->fsspec;
 346         return NULL;
 347 }
 348
 349 /*
 350 ** Two generally useful routines
 351 */
 352 static OSErr
 353 PyMac_GetFileDates(fss, crdat, mddat, bkdat)
 354         FSSpec *fss;
 355         unsigned long *crdat, *mddat, *bkdat;
 356 {
 357         CInfoPBRec pb;
 358         OSErr error;
 359
 360         pb.dirInfo.ioNamePtr = fss->name;
 361         pb.dirInfo.ioFDirIndex = 0;
 362         pb.dirInfo.ioVRefNum = fss->vRefNum;
 363         pb.dirInfo.ioDrDirID = fss->parID;
 364         error = PBGetCatInfoSync(&pb);
 365         if ( error ) return error;
 366         *crdat = pb.hFileInfo.ioFlCrDat;
 367         *mddat = pb.hFileInfo.ioFlMdDat;
 368         *bkdat = pb.hFileInfo.ioFlBkDat;
 369         return 0;
 370 }
 371
 372 static OSErr
 373 PyMac_SetFileDates(fss, crdat, mddat, bkdat)
 374         FSSpec *fss;
 375         unsigned long crdat, mddat, bkdat;
 376 {
 377         CInfoPBRec pb;
 378         OSErr error;
 379
 380         pb.dirInfo.ioNamePtr = fss->name;
 381         pb.dirInfo.ioFDirIndex = 0;
 382         pb.dirInfo.ioVRefNum = fss->vRefNum;
 383         pb.dirInfo.ioDrDirID = fss->parID;
 384         error = PBGetCatInfoSync(&pb);
 385         if ( error ) return error;
 386         pb.dirInfo.ioNamePtr = fss->name;
 387         pb.dirInfo.ioFDirIndex = 0;
 388         pb.dirInfo.ioVRefNum = fss->vRefNum;
 389         pb.dirInfo.ioDrDirID = fss->parID;
 390         pb.hFileInfo.ioFlCrDat = crdat;
 391         pb.hFileInfo.ioFlMdDat = mddat;
 392         pb.hFileInfo.ioFlBkDat = bkdat;
 393         error = PBSetCatInfoSync(&pb);
 394         return error;
 395 }
 396
 397 static PyObject *
 398 mfss_as_pathname(self, args)
 399         mfssobject *self;
 400         PyObject *args;
 401 {
 402         char strbuf[257];
 403         OSErr err;
 404
 405         if (!PyArg_ParseTuple(args, ""))
 406                 return NULL;
 407         err = PyMac_GetFullPath(&self->fsspec, strbuf);
 408         if ( err ) {
 409                 PyErr_Mac(ErrorObject, err);
 410                 return NULL;
 411         }
 412         return PyString_FromString(strbuf);
 413 }
 414
 415 static PyObject *
 416 mfss_as_tuple(self, args)
 417         mfssobject *self;
 418         PyObject *args;
 419 {
 420         if (!PyArg_ParseTuple(args, ""))
 421                 return NULL;
 422         return Py_BuildValue("(iis#)", self->fsspec.vRefNum, self->fsspec.parID,
 423                                                 &self->fsspec.name[1], self->fsspec.name[0]);
 424 }
 425
 426 static PyObject *
 427 mfss_NewAlias(self, args)
 428         mfssobject *self;
 429         PyObject *args;
 430 {
 431         FSSpec src, *srcp;
 432         OSErr err;
 433         AliasHandle alias;
 434
 435         src.name[0] = 0;
 436         if (!PyArg_ParseTuple(args, "|O&", PyMac_GetFSSpec, &src))
 437                 return NULL;
 438         if ( src.name[0] )
 439                 srcp = &src;
 440         else
 441                 srcp = NULL;
 442         err = NewAlias(srcp, &self->fsspec, &alias);
 443         if ( err ) {
 444                 PyErr_Mac(ErrorObject, err);
 445                 return NULL;
 446         }
 447
 448         return (PyObject *)newmfsaobject(alias);
 449 }
 450
 451 static PyObject *
 452 mfss_NewAliasMinimal(self, args)
 453         mfssobject *self;
 454         PyObject *args;
 455 {
 456         OSErr err;
 457         AliasHandle alias;
 458
 459         if (!PyArg_ParseTuple(args, ""))
 460                 return NULL;
 461         err = NewAliasMinimal(&self->fsspec, &alias);
 462         if ( err ) {
 463                 PyErr_Mac(ErrorObject, err);
 464                 return NULL;
 465         }
 466         return (PyObject *)newmfsaobject(alias);
 467 }
 468
 469 /* XXXX These routines should be replaced by a wrapper to the *FInfo routines */
 470 static PyObject *
 471 mfss_GetCreatorType(self, args)
 472         mfssobject *self;
 473         PyObject *args;
 474 {
 475         OSErr err;
 476         FInfo info;
 477
 478         if (!PyArg_ParseTuple(args, ""))
 479                 return NULL;
 480         err = FSpGetFInfo(&self->fsspec, &info);
 481         if ( err ) {
 482                 PyErr_Mac(ErrorObject, err);
 483                 return NULL;
 484         }
 485         return Py_BuildValue("(O&O&)",
 486                    PyMac_BuildOSType, info.fdCreator, PyMac_BuildOSType, info.fdType);
 487 }
 488
 489 static PyObject *
 490 mfss_SetCreatorType(self, args)
 491         mfssobject *self;
 492         PyObject *args;
 493 {
 494         OSErr err;
 495         OSType creator, type;
 496         FInfo info;
 497
 498         if (!PyArg_ParseTuple(args, "O&O&", PyMac_GetOSType, &creator, PyMac_GetOSType, &type))
 499                 return NULL;
 500         err = FSpGetFInfo(&self->fsspec, &info);
 501         if ( err ) {
 502                 PyErr_Mac(ErrorObject, err);
 503                 return NULL;
 504         }
 505         info.fdType = type;
 506         info.fdCreator = creator;
 507         err = FSpSetFInfo(&self->fsspec, &info);
 508         if ( err ) {
 509                 PyErr_Mac(ErrorObject, err);
 510                 return NULL;
 511         }
 512         Py_INCREF(Py_None);
 513         return Py_None;
 514 }
 515
 516 static PyObject *
 517 mfss_GetFInfo(self, args)
 518         mfssobject *self;
 519         PyObject *args;
 520 {
 521         OSErr err;
 522         mfsiobject *fip;
 523
 524
 525         if (!PyArg_ParseTuple(args, ""))
 526                 return NULL;
 527         if ( (fip=newmfsiobject()) == NULL )
 528                 return NULL;
 529         err = FSpGetFInfo(&self->fsspec, &fip->finfo);
 530         if ( err ) {
 531                 PyErr_Mac(ErrorObject, err);
 532                 Py_DECREF(fip);
 533                 return NULL;
 534         }
 535         return (PyObject *)fip;
 536 }
 537
 538 static PyObject *
 539 mfss_SetFInfo(self, args)
 540         mfssobject *self;
 541         PyObject *args;
 542 {
 543         OSErr err;
 544         mfsiobject *fip;
 545
 546         if (!PyArg_ParseTuple(args, "O!", &Mfsitype, &fip))
 547                 return NULL;
 548         err = FSpSetFInfo(&self->fsspec, &fip->finfo);
 549         if ( err ) {
 550                 PyErr_Mac(ErrorObject, err);
 551                 return NULL;
 552         }
 553         Py_INCREF(Py_None);
 554         return Py_None;
 555 }
 556
 557 static PyObject *
 558 mfss_GetDates(self, args)
 559         mfssobject *self;
 560         PyObject *args;
 561 {
 562         OSErr err;
 563         unsigned long crdat, mddat, bkdat;
 564
 565         if (!PyArg_ParseTuple(args, ""))
 566                 return NULL;
 567         err = PyMac_GetFileDates(&self->fsspec, &crdat, &mddat, &bkdat);
 568         if ( err ) {
 569                 PyErr_Mac(ErrorObject, err);
 570                 return NULL;
 571         }
 572         return Py_BuildValue("ddd", (double)crdat, (double)mddat, (double)bkdat);
 573 }
 574
 575 static PyObject *
 576 mfss_SetDates(self, args)
 577         mfssobject *self;
 578         PyObject *args;
 579 {
 580         OSErr err;
 581         double crdat, mddat, bkdat;
 582
 583         if (!PyArg_ParseTuple(args, "ddd", &crdat, &mddat, &bkdat))
 584                 return NULL;
 585         err = PyMac_SetFileDates(&self->fsspec, (unsigned long)crdat,
 586                                 (unsigned long)mddat, (unsigned long)bkdat);
 587         if ( err ) {
 588                 PyErr_Mac(ErrorObject, err);
 589                 return NULL;
 590         }
 591         Py_INCREF(Py_None);
 592         return Py_None;
 593 }
 594
 595 static struct PyMethodDef mfss_methods[] = {
 596         {"as_pathname",         (PyCFunction)mfss_as_pathname,                  1},
 597         {"as_tuple",            (PyCFunction)mfss_as_tuple,                             1},
 598         {"NewAlias",            (PyCFunction)mfss_NewAlias,                             1},
 599         {"NewAliasMinimal",     (PyCFunction)mfss_NewAliasMinimal,              1},
 600         {"GetCreatorType",      (PyCFunction)mfss_GetCreatorType,               1},
 601         {"SetCreatorType",      (PyCFunction)mfss_SetCreatorType,               1},
 602         {"GetFInfo",            (PyCFunction)mfss_GetFInfo,                             1},
 603         {"SetFInfo",            (PyCFunction)mfss_SetFInfo,                             1},
 604         {"GetDates",            (PyCFunction)mfss_GetDates,                             1},
 605         {"SetDates",            (PyCFunction)mfss_SetDates,                             1},
 606
 607         {NULL,                  NULL}           /* sentinel */
 608 };
 609
 610 /* ---------- */
 611
 612 static PyObject *
 613 mfss_getattr(self, name)
 614         mfssobject *self;
 615         char *name;
 616 {
 617         if ( strcmp(name, "data") == 0)
 618                 return PyString_FromStringAndSize((char *)&self->fsspec, sizeof(FSSpec));
 619         return Py_FindMethod(mfss_methods, (PyObject *)self, name);
 620 }
 621
 622 mfssobject *
 623 newmfssobject(fss)
 624         FSSpec *fss;
 625 {
 626         mfssobject *self;
 627
 628         self = PyObject_NEW(mfssobject, &Mfsstype);
 629         if (self == NULL)
 630                 return NULL;
 631         self->fsspec = *fss;
 632         return self;
 633 }
 634
 635 static void
 636 mfss_dealloc(self)
 637         mfssobject *self;
 638 {
 639         PyMem_DEL(self);
 640 }
 641
 642 static PyObject *
 643 mfss_repr(self)
 644         mfssobject *self;
 645 {
 646         char buf[512];
 647
 648         sprintf(buf, "FSSpec((%d, %d, '%.*s'))",
 649                 self->fsspec.vRefNum,
 650                 self->fsspec.parID,
 651                 self->fsspec.name[0], self->fsspec.name+1);
 652         return PyString_FromString(buf);
 653 }
 654
 655 static int
 656 mfss_compare(v, w)
 657         mfssobject *v, *w;
 658 {
 659         int minlen;
 660         int res;
 661
 662         if ( v->fsspec.vRefNum < w->fsspec.vRefNum ) return -1;
 663         if ( v->fsspec.vRefNum > w->fsspec.vRefNum ) return 1;
 664         if ( v->fsspec.parID < w->fsspec.parID ) return -1;
 665         if ( v->fsspec.parID > w->fsspec.parID ) return 1;
 666         minlen = v->fsspec.name[0];
 667         if ( w->fsspec.name[0] < minlen ) minlen = w->fsspec.name[0];
 668         res = strncmp((char *)v->fsspec.name+1, (char *)w->fsspec.name+1, minlen);
 669         if ( res ) return res;
 670         if ( v->fsspec.name[0] < w->fsspec.name[0] ) return -1;
 671         if ( v->fsspec.name[0] > w->fsspec.name[0] ) return 1;
 672         return res;
 673 }
 674
 675 statichere PyTypeObject Mfsstype = {
 676         PyObject_HEAD_INIT(&PyType_Type)
 677         0,                              /*ob_size*/
 678         "FSSpec",                       /*tp_name*/
 679         sizeof(mfssobject),             /*tp_basicsize*/
 680         0,                              /*tp_itemsize*/
 681         /* methods */
 682         (destructor)mfss_dealloc,       /*tp_dealloc*/
 683         (printfunc)0,           /*tp_print*/
 684         (getattrfunc)mfss_getattr,      /*tp_getattr*/
 685         (setattrfunc)0, /*tp_setattr*/
 686         (cmpfunc)mfss_compare,          /*tp_compare*/
 687         (reprfunc)mfss_repr,            /*tp_repr*/
 688         0,                      /*tp_as_number*/
 689         0,              /*tp_as_sequence*/
 690         0,              /*tp_as_mapping*/
 691         (hashfunc)0,            /*tp_hash*/
 692 };
 693
 694 /* End of code for FSSpec objects */
 695 /* -------------------------------------------------------- */
 696
 697 static PyObject *
 698 mfs_ResolveAliasFile(self, args)
 699         PyObject *self; /* Not used */
 700         PyObject *args;
 701 {
 702         FSSpec fss;
 703         Boolean chain = 1, isfolder, wasaliased;
 704         OSErr err;
 705
 706         if (!PyArg_ParseTuple(args, "O&|i", PyMac_GetFSSpec, &fss, &chain))
 707                 return NULL;
 708         err = ResolveAliasFile(&fss, chain, &isfolder, &wasaliased);
 709         if ( err ) {
 710                 PyErr_Mac(ErrorObject, err);
 711                 return NULL;
 712         }
 713         return Py_BuildValue("Oii", newmfssobject(&fss), (int)isfolder, (int)wasaliased);
 714 }
 715
 716 static PyObject *
 717 mfs_StandardGetFile(self, args)
 718         PyObject *self; /* Not used */
 719         PyObject *args;
 720 {
 721         SFTypeList list;
 722         short numtypes;
 723         StandardFileReply reply;
 724
 725         list[0] = list[1] = list[2] = list[3] = 0;
 726         numtypes = 0;
 727         if (!PyArg_ParseTuple(args, "|O&O&O&O&", PyMac_GetOSType, &list[0],
 728                          PyMac_GetOSType, &list[1], PyMac_GetOSType, &list[2],
 729                           PyMac_GetOSType, &list[3]) )
 730                 return NULL;
 731         while ( numtypes < 4 && list[numtypes] ) {
 732                 numtypes++;
 733         }
 734         if ( numtypes == 0 )
 735                 numtypes = -1;
 736         StandardGetFile((FileFilterUPP)0, numtypes, list, &reply);
 737         return Py_BuildValue("(Oi)", newmfssobject(&reply.sfFile), reply.sfGood);
 738 }
 739
 740 static PyObject *
 741 mfs_PromptGetFile(self, args)
 742         PyObject *self; /* Not used */
 743         PyObject *args;
 744 {
 745         SFTypeList list;
 746         short numtypes;
 747         StandardFileReply reply;
 748         char *prompt = NULL;
 749
 750         list[0] = list[1] = list[2] = list[3] = 0;
 751         numtypes = 0;
 752         if (!PyArg_ParseTuple(args, "s|O&O&O&O&", &prompt, PyMac_GetOSType, &list[0],
 753                          PyMac_GetOSType, &list[1], PyMac_GetOSType, &list[2],
 754                           PyMac_GetOSType, &list[3]) )
 755                 return NULL;
 756         while ( numtypes < 4 && list[numtypes] ) {
 757                 numtypes++;
 758         }
 759         if ( numtypes == 0 )
 760                 numtypes = -1;
 761         PyMac_PromptGetFile(numtypes, list, &reply, prompt);
 762         return Py_BuildValue("(Oi)", newmfssobject(&reply.sfFile), reply.sfGood);
 763 }
 764
 765 static PyObject *
 766 mfs_StandardPutFile(self, args)
 767         PyObject *self; /* Not used */
 768         PyObject *args;
 769 {
 770         Str255 prompt, dft;
 771         StandardFileReply reply;
 772
 773         dft[0] = 0;
 774         if (!PyArg_ParseTuple(args, "O&|O&", PyMac_GetStr255, &prompt, PyMac_GetStr255, &dft) )
 775                 return NULL;
 776         StandardPutFile(prompt, dft, &reply);
 777         return Py_BuildValue("(Oi)",newmfssobject(&reply.sfFile), reply.sfGood);
 778 }
 779
 780 /*
 781 ** Set initial directory for file dialogs */
 782 static PyObject *
 783 mfs_SetFolder(self, args)
 784         PyObject *self;
 785         PyObject *args;
 786 {
 787         FSSpec spec;
 788         FSSpec ospec;
 789         short orefnum;
 790         long oparid;
 791
 792         /* Get old values */
 793         orefnum = -LMGetSFSaveDisk();
 794         oparid = LMGetCurDirStore();
 795         (void)FSMakeFSSpec(orefnum, oparid, "\pplaceholder", &ospec);
 796
 797         /* Go to working directory by default */
 798         (void)FSMakeFSSpec(0, 0, "\p:placeholder", &spec);
 799         if (!PyArg_ParseTuple(args, "|O&", PyMac_GetFSSpec, &spec))
 800                 return NULL;
 801         /* Set standard-file working directory */
 802         LMSetSFSaveDisk(-spec.vRefNum);
 803         LMSetCurDirStore(spec.parID);
 804         return (PyObject *)newmfssobject(&ospec);
 805 }
 806
 807 static PyObject *
 808 mfs_FSSpec(self, args)
 809         PyObject *self; /* Not used */
 810         PyObject *args;
 811 {
 812         FSSpec fss;
 813
 814         if (!PyArg_ParseTuple(args, "O&", PyMac_GetFSSpec, &fss))
 815                 return NULL;
 816         return (PyObject *)newmfssobject(&fss);
 817 }
 818
 819 static PyObject *
 820 mfs_RawFSSpec(self, args)
 821         PyObject *self; /* Not used */
 822         PyObject *args;
 823 {
 824         FSSpec *fssp;
 825         int size;
 826
 827         if (!PyArg_ParseTuple(args, "s#", &fssp, &size))
 828                 return NULL;
 829         if ( size != sizeof(FSSpec) ) {
 830                 PyErr_SetString(PyExc_TypeError, "Incorrect size for FSSpec record");
 831                 return NULL;
 832         }
 833         return (PyObject *)newmfssobject(fssp);
 834 }
 835
 836 static PyObject *
 837 mfs_RawAlias(self, args)
 838         PyObject *self; /* Not used */
 839         PyObject *args;
 840 {
 841         char *dataptr;
 842         Handle h;
 843         int size;
 844
 845         if (!PyArg_ParseTuple(args, "s#", &dataptr, &size))
 846                 return NULL;
 847         h = NewHandle(size);
 848         if ( h == NULL ) {
 849                 PyErr_NoMemory();
 850                 return NULL;
 851         }
 852         HLock(h);
 853         memcpy((char *)*h, dataptr, size);
 854         HUnlock(h);
 855         return (PyObject *)newmfsaobject((AliasHandle)h);
 856 }
 857
 858 static PyObject *
 859 mfs_GetDirectory(self, args)
 860         PyObject *self; /* Not used */
 861         PyObject *args;
 862 {
 863         FSSpec fsdir;
 864         int ok;
 865         char *prompt = NULL;
 866
 867         if (!PyArg_ParseTuple(args, "|s", &prompt) )
 868                 return NULL;
 869
 870         ok = PyMac_GetDirectory(&fsdir, prompt);
 871         return Py_BuildValue("(Oi)", newmfssobject(&fsdir), ok);
 872 }
 873
 874 static PyObject *
 875 mfs_FindFolder(self, args)
 876         PyObject *self; /* Not used */
 877         PyObject *args;
 878 {
 879         OSErr err;
 880         short where;
 881         OSType which;
 882         int create;
 883         short refnum;
 884         long dirid;
 885
 886         if (!PyArg_ParseTuple(args, "hO&i", &where, PyMac_GetOSType, &which, &create) )
 887                 return NULL;
 888         err = FindFolder(where, which, (Boolean)create, &refnum, &dirid);
 889         if ( err ) {
 890                 PyErr_Mac(ErrorObject, err);
 891                 return NULL;
 892         }
 893         return Py_BuildValue("(ii)", refnum, dirid);
 894 }
 895
 896 static PyObject *
 897 mfs_FindApplication(self, args)
 898         PyObject *self; /* Not used */
 899         PyObject *args;
 900 {
 901         OSErr err;
 902         OSType which;
 903         FSSpec  fss;
 904
 905         if (!PyArg_ParseTuple(args, "O&", PyMac_GetOSType, &which) )
 906                 return NULL;
 907         err = FindApplicationFromCreator(which, &fss);
 908         if ( err ) {
 909                 PyErr_Mac(ErrorObject, err);
 910                 return NULL;
 911         }
 912         return (PyObject *)newmfssobject(&fss);
 913 }
 914
 915 static PyObject *
 916 mfs_FInfo(self, args)
 917         PyObject *self;
 918         PyObject *args;
 919 {
 920         return (PyObject *)newmfsiobject();
 921 }
 922
 923 static PyObject *
 924 mfs_NewAliasMinimalFromFullPath(self, args)
 925         PyObject *self; /* Not used */
 926         PyObject *args;
 927 {
 928         OSErr err;
 929         char *fullpath;
 930         int fullpathlen;
 931         AliasHandle alias;
 932         Str32 zonename;
 933         Str31 servername;
 934
 935         if (!PyArg_ParseTuple(args, "s#", &fullpath, &fullpathlen) )
 936                 return NULL;
 937         zonename[0] = 0;
 938         servername[0] = 0;
 939         err = NewAliasMinimalFromFullPath(fullpathlen, (Ptr)fullpath, zonename,
 940                         servername, &alias);
 941         if ( err ) {
 942                 PyErr_Mac(ErrorObject, err);
 943                 return NULL;
 944         }
 945         return (PyObject *)newmfsaobject(alias);
 946 }
 947
 948
 949 /* List of methods defined in the module */
 950
 951 static struct PyMethodDef mfs_methods[] = {
 952         {"ResolveAliasFile",    mfs_ResolveAliasFile,   1},
 953         {"StandardGetFile",             mfs_StandardGetFile,    1},
 954         {"PromptGetFile",               mfs_PromptGetFile,              1},
 955         {"StandardPutFile",             mfs_StandardPutFile,    1},
 956         {"GetDirectory",                mfs_GetDirectory,               1},
 957         {"SetFolder",                   mfs_SetFolder,                  1},
 958         {"FSSpec",                              mfs_FSSpec,                             1},
 959         {"RawFSSpec",                   mfs_RawFSSpec,                  1},
 960         {"RawAlias",                    mfs_RawAlias,                   1},
 961         {"FindFolder",                  mfs_FindFolder,                 1},
 962         {"FindApplication",             mfs_FindApplication,    1},
 963         {"FInfo",                               mfs_FInfo,                              1},
 964         {"NewAliasMinimalFromFullPath", mfs_NewAliasMinimalFromFullPath,        1},
 965
 966         {NULL,          NULL}           /* sentinel */
 967 };
 968
 969
 970 /* Initialization function for the module (*must* be called initmacfs) */
 971
 972 void
 973 initmacfs()
 974 {
 975         PyObject *m, *d;
 976
 977         /* Create the module and add the functions */
 978         m = Py_InitModule("macfs", mfs_methods);
 979
 980         /* Add some symbolic constants to the module */
 981         d = PyModule_GetDict(m);
 982         ErrorObject = PyErr_NewException("macfs.error", NULL, NULL);
 983         PyDict_SetItemString(d, "error", ErrorObject);
 984
 985         Mfsatype.ob_type = &PyType_Type;
 986         Py_INCREF(&Mfsatype);
 987         PyDict_SetItemString(d, "AliasType", (PyObject *)&Mfsatype);
 988         Mfsstype.ob_type = &PyType_Type;
 989         Py_INCREF(&Mfsstype);
 990         PyDict_SetItemString(d, "FSSpecType", (PyObject *)&Mfsstype);
 991         Mfsitype.ob_type = &PyType_Type;
 992         Py_INCREF(&Mfsitype);
 993         PyDict_SetItemString(d, "FInfoType", (PyObject *)&Mfsitype);
 994         /* XXXX Add constants here */
 995 }