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