1 

     2 /* ========================== Module _Res =========================== */

     3 

     4 #include "Python.h"

     5 

     6 

     7 #include "pymactoolbox.h"

     8 

     9 /* Macro to test whether a weak-loaded CFM function exists */

    10 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\

    11         PyErr_SetString(PyExc_NotImplementedError, \

    12         "Not available in this shared library/OS version"); \

    13         return NULL; \

    14     }} while(0)

    15 

    16 

    17 #include <Carbon/Carbon.h>

    18 

    19 #ifdef USE_TOOLBOX_OBJECT_GLUE

    20 extern PyObject *_ResObj_New(Handle);

    21 extern int _ResObj_Convert(PyObject *, Handle *);

    22 extern PyObject *_OptResObj_New(Handle);

    23 extern int _OptResObj_Convert(PyObject *, Handle *);

    24 #define ResObj_New _ResObj_New

    25 #define ResObj_Convert _ResObj_Convert

    26 #define OptResObj_New _OptResObj_New

    27 #define OptResObj_Convert _OptResObj_Convert

    28 #endif

    29 

    30 /* Function to dispose a resource, with a "normal" calling sequence */

    31 static void

    32 PyMac_AutoDisposeHandle(Handle h)

    33 {

    34         DisposeHandle(h);

    35 }

    36 

    37 static PyObject *Res_Error;

    38 

    39 /* ---------------------- Object type Resource ---------------------- */

    40 

    41 PyTypeObject Resource_Type;

    42 

    43 #define ResObj_Check(x) ((x)->ob_type == &Resource_Type || PyObject_TypeCheck((x), &Resource_Type))

    44 

    45 typedef struct ResourceObject {

    46 	PyObject_HEAD

    47 	Handle ob_itself;

    48 	void (*ob_freeit)(Handle ptr);

    49 } ResourceObject;

    50 

    51 PyObject *ResObj_New(Handle itself)

    52 {

    53 	ResourceObject *it;

    54 	if (itself == NULL) return PyMac_Error(resNotFound);

    55 	it = PyObject_NEW(ResourceObject, &Resource_Type);

    56 	if (it == NULL) return NULL;

    57 	it->ob_itself = itself;

    58 	it->ob_freeit = NULL;

    59 	return (PyObject *)it;

    60 }

    61 

    62 int ResObj_Convert(PyObject *v, Handle *p_itself)

    63 {

    64 	if (!ResObj_Check(v))

    65 	{

    66 		PyObject *tmp;

    67 		if ( (tmp=PyObject_CallMethod(v, "as_Resource", "")) )

    68 		{

    69 			*p_itself = ((ResourceObject *)tmp)->ob_itself;

    70 			Py_DECREF(tmp);

    71 			return 1;

    72 		}

    73 		PyErr_Clear();

    74 	}

    75 	if (!ResObj_Check(v))

    76 	{

    77 		PyErr_SetString(PyExc_TypeError, "Resource required");

    78 		return 0;

    79 	}

    80 	*p_itself = ((ResourceObject *)v)->ob_itself;

    81 	return 1;

    82 }

    83 

    84 static void ResObj_dealloc(ResourceObject *self)

    85 {

    86 	if (self->ob_freeit && self->ob_itself)

    87 	{

    88 		self->ob_freeit(self->ob_itself);

    89 	}

    90 	self->ob_itself = NULL;

    91 	self->ob_type->tp_free((PyObject *)self);

    92 }

    93 

    94 static PyObject *ResObj_HomeResFile(ResourceObject *_self, PyObject *_args)

    95 {

    96 	PyObject *_res = NULL;

    97 	short _rv;

    98 #ifndef HomeResFile

    99 	PyMac_PRECHECK(HomeResFile);

   100 #endif

   101 	if (!PyArg_ParseTuple(_args, ""))

   102 		return NULL;

   103 	_rv = HomeResFile(_self->ob_itself);

   104 	{

   105 		OSErr _err = ResError();

   106 		if (_err != noErr) return PyMac_Error(_err);

   107 	}

   108 	_res = Py_BuildValue("h",

   109 	                     _rv);

   110 	return _res;

   111 }

   112 

   113 static PyObject *ResObj_MacLoadResource(ResourceObject *_self, PyObject *_args)

   114 {

   115 	PyObject *_res = NULL;

   116 #ifndef MacLoadResource

   117 	PyMac_PRECHECK(MacLoadResource);

   118 #endif

   119 	if (!PyArg_ParseTuple(_args, ""))

   120 		return NULL;

   121 	MacLoadResource(_self->ob_itself);

   122 	{

   123 		OSErr _err = ResError();

   124 		if (_err != noErr) return PyMac_Error(_err);

   125 	}

   126 	Py_INCREF(Py_None);

   127 	_res = Py_None;

   128 	return _res;

   129 }

   130 

   131 static PyObject *ResObj_ReleaseResource(ResourceObject *_self, PyObject *_args)

   132 {

   133 	PyObject *_res = NULL;

   134 #ifndef ReleaseResource

   135 	PyMac_PRECHECK(ReleaseResource);

   136 #endif

   137 	if (!PyArg_ParseTuple(_args, ""))

   138 		return NULL;

   139 	ReleaseResource(_self->ob_itself);

   140 	{

   141 		OSErr _err = ResError();

   142 		if (_err != noErr) return PyMac_Error(_err);

   143 	}

   144 	Py_INCREF(Py_None);

   145 	_res = Py_None;

   146 	return _res;

   147 }

   148 

   149 static PyObject *ResObj_DetachResource(ResourceObject *_self, PyObject *_args)

   150 {

   151 	PyObject *_res = NULL;

   152 #ifndef DetachResource

   153 	PyMac_PRECHECK(DetachResource);

   154 #endif

   155 	if (!PyArg_ParseTuple(_args, ""))

   156 		return NULL;

   157 	DetachResource(_self->ob_itself);

   158 	{

   159 		OSErr _err = ResError();

   160 		if (_err != noErr) return PyMac_Error(_err);

   161 	}

   162 	Py_INCREF(Py_None);

   163 	_res = Py_None;

   164 	return _res;

   165 }

   166 

   167 static PyObject *ResObj_GetResAttrs(ResourceObject *_self, PyObject *_args)

   168 {

   169 	PyObject *_res = NULL;

   170 	short _rv;

   171 #ifndef GetResAttrs

   172 	PyMac_PRECHECK(GetResAttrs);

   173 #endif

   174 	if (!PyArg_ParseTuple(_args, ""))

   175 		return NULL;

   176 	_rv = GetResAttrs(_self->ob_itself);

   177 	{

   178 		OSErr _err = ResError();

   179 		if (_err != noErr) return PyMac_Error(_err);

   180 	}

   181 	_res = Py_BuildValue("h",

   182 	                     _rv);

   183 	return _res;

   184 }

   185 

   186 static PyObject *ResObj_GetResInfo(ResourceObject *_self, PyObject *_args)

   187 {

   188 	PyObject *_res = NULL;

   189 	short theID;

   190 	ResType theType;

   191 	Str255 name;

   192 #ifndef GetResInfo

   193 	PyMac_PRECHECK(GetResInfo);

   194 #endif

   195 	if (!PyArg_ParseTuple(_args, ""))

   196 		return NULL;

   197 	GetResInfo(_self->ob_itself,

   198 	           &theID,

   199 	           &theType,

   200 	           name);

   201 	{

   202 		OSErr _err = ResError();

   203 		if (_err != noErr) return PyMac_Error(_err);

   204 	}

   205 	_res = Py_BuildValue("hO&O&",

   206 	                     theID,

   207 	                     PyMac_BuildOSType, theType,

   208 	                     PyMac_BuildStr255, name);

   209 	return _res;

   210 }

   211 

   212 static PyObject *ResObj_SetResInfo(ResourceObject *_self, PyObject *_args)

   213 {

   214 	PyObject *_res = NULL;

   215 	short theID;

   216 	Str255 name;

   217 #ifndef SetResInfo

   218 	PyMac_PRECHECK(SetResInfo);

   219 #endif

   220 	if (!PyArg_ParseTuple(_args, "hO&",

   221 	                      &theID,

   222 	                      PyMac_GetStr255, name))

   223 		return NULL;

   224 	SetResInfo(_self->ob_itself,

   225 	           theID,

   226 	           name);

   227 	{

   228 		OSErr _err = ResError();

   229 		if (_err != noErr) return PyMac_Error(_err);

   230 	}

   231 	Py_INCREF(Py_None);

   232 	_res = Py_None;

   233 	return _res;

   234 }

   235 

   236 static PyObject *ResObj_AddResource(ResourceObject *_self, PyObject *_args)

   237 {

   238 	PyObject *_res = NULL;

   239 	ResType theType;

   240 	short theID;

   241 	Str255 name;

   242 #ifndef AddResource

   243 	PyMac_PRECHECK(AddResource);

   244 #endif

   245 	if (!PyArg_ParseTuple(_args, "O&hO&",

   246 	                      PyMac_GetOSType, &theType,

   247 	                      &theID,

   248 	                      PyMac_GetStr255, name))

   249 		return NULL;

   250 	AddResource(_self->ob_itself,

   251 	            theType,

   252 	            theID,

   253 	            name);

   254 	{

   255 		OSErr _err = ResError();

   256 		if (_err != noErr) return PyMac_Error(_err);

   257 	}

   258 	Py_INCREF(Py_None);

   259 	_res = Py_None;

   260 	return _res;

   261 }

   262 

   263 static PyObject *ResObj_GetResourceSizeOnDisk(ResourceObject *_self, PyObject *_args)

   264 {

   265 	PyObject *_res = NULL;

   266 	long _rv;

   267 #ifndef GetResourceSizeOnDisk

   268 	PyMac_PRECHECK(GetResourceSizeOnDisk);

   269 #endif

   270 	if (!PyArg_ParseTuple(_args, ""))

   271 		return NULL;

   272 	_rv = GetResourceSizeOnDisk(_self->ob_itself);

   273 	{

   274 		OSErr _err = ResError();

   275 		if (_err != noErr) return PyMac_Error(_err);

   276 	}

   277 	_res = Py_BuildValue("l",

   278 	                     _rv);

   279 	return _res;

   280 }

   281 

   282 static PyObject *ResObj_GetMaxResourceSize(ResourceObject *_self, PyObject *_args)

   283 {

   284 	PyObject *_res = NULL;

   285 	long _rv;

   286 #ifndef GetMaxResourceSize

   287 	PyMac_PRECHECK(GetMaxResourceSize);

   288 #endif

   289 	if (!PyArg_ParseTuple(_args, ""))

   290 		return NULL;

   291 	_rv = GetMaxResourceSize(_self->ob_itself);

   292 	{

   293 		OSErr _err = ResError();

   294 		if (_err != noErr) return PyMac_Error(_err);

   295 	}

   296 	_res = Py_BuildValue("l",

   297 	                     _rv);

   298 	return _res;

   299 }

   300 

   301 static PyObject *ResObj_SetResAttrs(ResourceObject *_self, PyObject *_args)

   302 {

   303 	PyObject *_res = NULL;

   304 	short attrs;

   305 #ifndef SetResAttrs

   306 	PyMac_PRECHECK(SetResAttrs);

   307 #endif

   308 	if (!PyArg_ParseTuple(_args, "h",

   309 	                      &attrs))

   310 		return NULL;

   311 	SetResAttrs(_self->ob_itself,

   312 	            attrs);

   313 	{

   314 		OSErr _err = ResError();

   315 		if (_err != noErr) return PyMac_Error(_err);

   316 	}

   317 	Py_INCREF(Py_None);

   318 	_res = Py_None;

   319 	return _res;

   320 }

   321 

   322 static PyObject *ResObj_ChangedResource(ResourceObject *_self, PyObject *_args)

   323 {

   324 	PyObject *_res = NULL;

   325 #ifndef ChangedResource

   326 	PyMac_PRECHECK(ChangedResource);

   327 #endif

   328 	if (!PyArg_ParseTuple(_args, ""))

   329 		return NULL;

   330 	ChangedResource(_self->ob_itself);

   331 	{

   332 		OSErr _err = ResError();

   333 		if (_err != noErr) return PyMac_Error(_err);

   334 	}

   335 	Py_INCREF(Py_None);

   336 	_res = Py_None;

   337 	return _res;

   338 }

   339 

   340 static PyObject *ResObj_RemoveResource(ResourceObject *_self, PyObject *_args)

   341 {

   342 	PyObject *_res = NULL;

   343 #ifndef RemoveResource

   344 	PyMac_PRECHECK(RemoveResource);

   345 #endif

   346 	if (!PyArg_ParseTuple(_args, ""))

   347 		return NULL;

   348 	RemoveResource(_self->ob_itself);

   349 	{

   350 		OSErr _err = ResError();

   351 		if (_err != noErr) return PyMac_Error(_err);

   352 	}

   353 	Py_INCREF(Py_None);

   354 	_res = Py_None;

   355 	return _res;

   356 }

   357 

   358 static PyObject *ResObj_WriteResource(ResourceObject *_self, PyObject *_args)

   359 {

   360 	PyObject *_res = NULL;

   361 #ifndef WriteResource

   362 	PyMac_PRECHECK(WriteResource);

   363 #endif

   364 	if (!PyArg_ParseTuple(_args, ""))

   365 		return NULL;

   366 	WriteResource(_self->ob_itself);

   367 	{

   368 		OSErr _err = ResError();

   369 		if (_err != noErr) return PyMac_Error(_err);

   370 	}

   371 	Py_INCREF(Py_None);

   372 	_res = Py_None;

   373 	return _res;

   374 }

   375 

   376 static PyObject *ResObj_SetResourceSize(ResourceObject *_self, PyObject *_args)

   377 {

   378 	PyObject *_res = NULL;

   379 	long newSize;

   380 #ifndef SetResourceSize

   381 	PyMac_PRECHECK(SetResourceSize);

   382 #endif

   383 	if (!PyArg_ParseTuple(_args, "l",

   384 	                      &newSize))

   385 		return NULL;

   386 	SetResourceSize(_self->ob_itself,

   387 	                newSize);

   388 	{

   389 		OSErr _err = ResError();

   390 		if (_err != noErr) return PyMac_Error(_err);

   391 	}

   392 	Py_INCREF(Py_None);

   393 	_res = Py_None;

   394 	return _res;

   395 }

   396 

   397 static PyObject *ResObj_GetNextFOND(ResourceObject *_self, PyObject *_args)

   398 {

   399 	PyObject *_res = NULL;

   400 	Handle _rv;

   401 #ifndef GetNextFOND

   402 	PyMac_PRECHECK(GetNextFOND);

   403 #endif

   404 	if (!PyArg_ParseTuple(_args, ""))

   405 		return NULL;

   406 	_rv = GetNextFOND(_self->ob_itself);

   407 	{

   408 		OSErr _err = ResError();

   409 		if (_err != noErr) return PyMac_Error(_err);

   410 	}

   411 	_res = Py_BuildValue("O&",

   412 	                     ResObj_New, _rv);

   413 	return _res;

   414 }

   415 

   416 #ifndef __LP64__

   417 static PyObject *ResObj_as_Control(ResourceObject *_self, PyObject *_args)

   418 {

   419 	PyObject *_res = NULL;

   420 

   421 	_res = CtlObj_New((ControlHandle)_self->ob_itself);

   422 	return _res;

   423 

   424 }

   425 

   426 static PyObject *ResObj_as_Menu(ResourceObject *_self, PyObject *_args)

   427 {

   428 	PyObject *_res = NULL;

   429 

   430 	_res = MenuObj_New((MenuHandle)_self->ob_itself);

   431 	return _res;

   432 

   433 }

   434 #endif /* !__LP64__ */

   435 

   436 static PyObject *ResObj_LoadResource(ResourceObject *_self, PyObject *_args)

   437 {

   438 	PyObject *_res = NULL;

   439 #ifndef LoadResource

   440 	PyMac_PRECHECK(LoadResource);

   441 #endif

   442 	if (!PyArg_ParseTuple(_args, ""))

   443 		return NULL;

   444 	LoadResource(_self->ob_itself);

   445 	{

   446 		OSErr _err = ResError();

   447 		if (_err != noErr) return PyMac_Error(_err);

   448 	}

   449 	Py_INCREF(Py_None);

   450 	_res = Py_None;

   451 	return _res;

   452 }

   453 

   454 static PyObject *ResObj_AutoDispose(ResourceObject *_self, PyObject *_args)

   455 {

   456 	PyObject *_res = NULL;

   457 

   458 	int onoff, old = 0;

   459 	if (!PyArg_ParseTuple(_args, "i", &onoff))

   460 	        return NULL;

   461 	if ( _self->ob_freeit )

   462 	        old = 1;

   463 	if ( onoff )

   464 	        _self->ob_freeit = PyMac_AutoDisposeHandle;

   465 	else

   466 	        _self->ob_freeit = NULL;

   467 	_res = Py_BuildValue("i", old);

   468 	return _res;

   469 

   470 }

   471 

   472 static PyMethodDef ResObj_methods[] = {

   473 	{"HomeResFile", (PyCFunction)ResObj_HomeResFile, 1,

   474 	 PyDoc_STR("() -> (short _rv)")},

   475 	{"MacLoadResource", (PyCFunction)ResObj_MacLoadResource, 1,

   476 	 PyDoc_STR("() -> None")},

   477 	{"ReleaseResource", (PyCFunction)ResObj_ReleaseResource, 1,

   478 	 PyDoc_STR("() -> None")},

   479 	{"DetachResource", (PyCFunction)ResObj_DetachResource, 1,

   480 	 PyDoc_STR("() -> None")},

   481 	{"GetResAttrs", (PyCFunction)ResObj_GetResAttrs, 1,

   482 	 PyDoc_STR("() -> (short _rv)")},

   483 	{"GetResInfo", (PyCFunction)ResObj_GetResInfo, 1,

   484 	 PyDoc_STR("() -> (short theID, ResType theType, Str255 name)")},

   485 	{"SetResInfo", (PyCFunction)ResObj_SetResInfo, 1,

   486 	 PyDoc_STR("(short theID, Str255 name) -> None")},

   487 	{"AddResource", (PyCFunction)ResObj_AddResource, 1,

   488 	 PyDoc_STR("(ResType theType, short theID, Str255 name) -> None")},

   489 	{"GetResourceSizeOnDisk", (PyCFunction)ResObj_GetResourceSizeOnDisk, 1,

   490 	 PyDoc_STR("() -> (long _rv)")},

   491 	{"GetMaxResourceSize", (PyCFunction)ResObj_GetMaxResourceSize, 1,

   492 	 PyDoc_STR("() -> (long _rv)")},

   493 	{"SetResAttrs", (PyCFunction)ResObj_SetResAttrs, 1,

   494 	 PyDoc_STR("(short attrs) -> None")},

   495 	{"ChangedResource", (PyCFunction)ResObj_ChangedResource, 1,

   496 	 PyDoc_STR("() -> None")},

   497 	{"RemoveResource", (PyCFunction)ResObj_RemoveResource, 1,

   498 	 PyDoc_STR("() -> None")},

   499 	{"WriteResource", (PyCFunction)ResObj_WriteResource, 1,

   500 	 PyDoc_STR("() -> None")},

   501 	{"SetResourceSize", (PyCFunction)ResObj_SetResourceSize, 1,

   502 	 PyDoc_STR("(long newSize) -> None")},

   503 	{"GetNextFOND", (PyCFunction)ResObj_GetNextFOND, 1,

   504 	 PyDoc_STR("() -> (Handle _rv)")},

   505 #ifndef __LP64__

   506 	{"as_Control", (PyCFunction)ResObj_as_Control, 1,

   507 	 PyDoc_STR("Return this resource/handle as a Control")},

   508 	{"as_Menu", (PyCFunction)ResObj_as_Menu, 1,

   509 	 PyDoc_STR("Return this resource/handle as a Menu")},

   510 #endif /* !__LP64__ */

   511 	{"LoadResource", (PyCFunction)ResObj_LoadResource, 1,

   512 	 PyDoc_STR("() -> None")},

   513 	{"AutoDispose", (PyCFunction)ResObj_AutoDispose, 1,

   514 	 PyDoc_STR("(int)->int. Automatically DisposeHandle the object on Python object cleanup")},

   515 	{NULL, NULL, 0}

   516 };

   517 

   518 static PyObject *ResObj_get_data(ResourceObject *self, void *closure)

   519 {

   520 

   521 	            PyObject *res;

   522 	            char state;

   523 

   524 	            state = HGetState(self->ob_itself);

   525 	            HLock(self->ob_itself);

   526 	            res = PyString_FromStringAndSize(

   527 	                    *self->ob_itself,

   528 	                    GetHandleSize(self->ob_itself));

   529 	            HUnlock(self->ob_itself);

   530 	            HSetState(self->ob_itself, state);

   531 	            return res;

   532 	            

   533 }

   534 

   535 static int ResObj_set_data(ResourceObject *self, PyObject *v, void *closure)

   536 {

   537 

   538 	            char *data;

   539 	            long size;

   540 

   541 	            if ( v == NULL )

   542 	                    return -1;

   543 	            if ( !PyString_Check(v) )

   544 	                    return -1;

   545 	            size = PyString_Size(v);

   546 	            data = PyString_AsString(v);

   547 	            /* XXXX Do I need the GetState/SetState calls? */

   548 	            SetHandleSize(self->ob_itself, size);

   549 	            if ( MemError())

   550 	                    return -1;

   551 	            HLock(self->ob_itself);

   552 	            memcpy((char *)*self->ob_itself, data, size);

   553 	            HUnlock(self->ob_itself);

   554 	            /* XXXX Should I do the Changed call immedeately? */

   555 	            return 0;

   556 	            

   557 	return 0;

   558 }

   559 

   560 static PyObject *ResObj_get_size(ResourceObject *self, void *closure)

   561 {

   562 	return PyInt_FromLong(GetHandleSize(self->ob_itself));

   563 }

   564 

   565 #define ResObj_set_size NULL

   566 

   567 static PyGetSetDef ResObj_getsetlist[] = {

   568 	{"data", (getter)ResObj_get_data, (setter)ResObj_set_data, "The resource data"},

   569 	{"size", (getter)ResObj_get_size, (setter)ResObj_set_size, "The length of the resource data"},

   570 	{NULL, NULL, NULL, NULL},

   571 };

   572 

   573 

   574 #define ResObj_compare NULL

   575 

   576 #define ResObj_repr NULL

   577 

   578 #define ResObj_hash NULL

   579 static int ResObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)

   580 {

   581 	char *srcdata = NULL;

   582 	int srclen = 0;

   583 	Handle itself;

   584 	char *kw[] = {"itself", 0};

   585 

   586 	if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, ResObj_Convert, &itself))

   587 	{

   588 		((ResourceObject *)_self)->ob_itself = itself;

   589 		return 0;

   590 	}

   591 	PyErr_Clear();

   592 	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "|s#", kw, &srcdata, &srclen)) return -1;

   593 	if ((itself = NewHandle(srclen)) == NULL)

   594 	{

   595 		PyErr_NoMemory();

   596 		return 0;

   597 	}

   598 	((ResourceObject *)_self)->ob_itself = itself;

   599 	if (srclen && srcdata)

   600 	{

   601 		HLock(itself);

   602 		memcpy(*itself, srcdata, srclen);

   603 		HUnlock(itself);

   604 	}

   605 	return 0;

   606 }

   607 

   608 #define ResObj_tp_alloc PyType_GenericAlloc

   609 

   610 static PyObject *ResObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

   611 {

   612 	PyObject *self;

   613 	if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;

   614 	((ResourceObject *)self)->ob_itself = NULL;

   615 	((ResourceObject *)self)->ob_freeit = NULL;

   616 	return self;

   617 }

   618 

   619 #define ResObj_tp_free PyObject_Del

   620 

   621 

   622 PyTypeObject Resource_Type = {

   623 	PyObject_HEAD_INIT(NULL)

   624 	0, /*ob_size*/

   625 	"_Res.Resource", /*tp_name*/

   626 	sizeof(ResourceObject), /*tp_basicsize*/

   627 	0, /*tp_itemsize*/

   628 	/* methods */

   629 	(destructor) ResObj_dealloc, /*tp_dealloc*/

   630 	0, /*tp_print*/

   631 	(getattrfunc)0, /*tp_getattr*/

   632 	(setattrfunc)0, /*tp_setattr*/

   633 	(cmpfunc) ResObj_compare, /*tp_compare*/

   634 	(reprfunc) ResObj_repr, /*tp_repr*/

   635 	(PyNumberMethods *)0, /* tp_as_number */

   636 	(PySequenceMethods *)0, /* tp_as_sequence */

   637 	(PyMappingMethods *)0, /* tp_as_mapping */

   638 	(hashfunc) ResObj_hash, /*tp_hash*/

   639 	0, /*tp_call*/

   640 	0, /*tp_str*/

   641 	PyObject_GenericGetAttr, /*tp_getattro*/

   642 	PyObject_GenericSetAttr, /*tp_setattro */

   643 	0, /*tp_as_buffer*/

   644 	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

   645 	0, /*tp_doc*/

   646 	0, /*tp_traverse*/

   647 	0, /*tp_clear*/

   648 	0, /*tp_richcompare*/

   649 	0, /*tp_weaklistoffset*/

   650 	0, /*tp_iter*/

   651 	0, /*tp_iternext*/

   652 	ResObj_methods, /* tp_methods */

   653 	0, /*tp_members*/

   654 	ResObj_getsetlist, /*tp_getset*/

   655 	0, /*tp_base*/

   656 	0, /*tp_dict*/

   657 	0, /*tp_descr_get*/

   658 	0, /*tp_descr_set*/

   659 	0, /*tp_dictoffset*/

   660 	ResObj_tp_init, /* tp_init */

   661 	ResObj_tp_alloc, /* tp_alloc */

   662 	ResObj_tp_new, /* tp_new */

   663 	ResObj_tp_free, /* tp_free */

   664 };

   665 

   666 /* -------------------- End object type Resource -------------------- */

   667 

   668 

   669 static PyObject *Res_CloseResFile(PyObject *_self, PyObject *_args)

   670 {

   671 	PyObject *_res = NULL;

   672 	short refNum;

   673 #ifndef CloseResFile

   674 	PyMac_PRECHECK(CloseResFile);

   675 #endif

   676 	if (!PyArg_ParseTuple(_args, "h",

   677 	                      &refNum))

   678 		return NULL;

   679 	CloseResFile(refNum);

   680 	{

   681 		OSErr _err = ResError();

   682 		if (_err != noErr) return PyMac_Error(_err);

   683 	}

   684 	Py_INCREF(Py_None);

   685 	_res = Py_None;

   686 	return _res;

   687 }

   688 

   689 static PyObject *Res_ResError(PyObject *_self, PyObject *_args)

   690 {

   691 	PyObject *_res = NULL;

   692 	OSErr _err;

   693 #ifndef ResError

   694 	PyMac_PRECHECK(ResError);

   695 #endif

   696 	if (!PyArg_ParseTuple(_args, ""))

   697 		return NULL;

   698 	_err = ResError();

   699 	if (_err != noErr) return PyMac_Error(_err);

   700 	Py_INCREF(Py_None);

   701 	_res = Py_None;

   702 	return _res;

   703 }

   704 

   705 static PyObject *Res_CurResFile(PyObject *_self, PyObject *_args)

   706 {

   707 	PyObject *_res = NULL;

   708 	short _rv;

   709 #ifndef CurResFile

   710 	PyMac_PRECHECK(CurResFile);

   711 #endif

   712 	if (!PyArg_ParseTuple(_args, ""))

   713 		return NULL;

   714 	_rv = CurResFile();

   715 	{

   716 		OSErr _err = ResError();

   717 		if (_err != noErr) return PyMac_Error(_err);

   718 	}

   719 	_res = Py_BuildValue("h",

   720 	                     _rv);

   721 	return _res;

   722 }

   723 

   724 static PyObject *Res_UseResFile(PyObject *_self, PyObject *_args)

   725 {

   726 	PyObject *_res = NULL;

   727 	short refNum;

   728 #ifndef UseResFile

   729 	PyMac_PRECHECK(UseResFile);

   730 #endif

   731 	if (!PyArg_ParseTuple(_args, "h",

   732 	                      &refNum))

   733 		return NULL;

   734 	UseResFile(refNum);

   735 	{

   736 		OSErr _err = ResError();

   737 		if (_err != noErr) return PyMac_Error(_err);

   738 	}

   739 	Py_INCREF(Py_None);

   740 	_res = Py_None;

   741 	return _res;

   742 }

   743 

   744 static PyObject *Res_CountTypes(PyObject *_self, PyObject *_args)

   745 {

   746 	PyObject *_res = NULL;

   747 	short _rv;

   748 #ifndef CountTypes

   749 	PyMac_PRECHECK(CountTypes);

   750 #endif

   751 	if (!PyArg_ParseTuple(_args, ""))

   752 		return NULL;

   753 	_rv = CountTypes();

   754 	{

   755 		OSErr _err = ResError();

   756 		if (_err != noErr) return PyMac_Error(_err);

   757 	}

   758 	_res = Py_BuildValue("h",

   759 	                     _rv);

   760 	return _res;

   761 }

   762 

   763 static PyObject *Res_Count1Types(PyObject *_self, PyObject *_args)

   764 {

   765 	PyObject *_res = NULL;

   766 	short _rv;

   767 #ifndef Count1Types

   768 	PyMac_PRECHECK(Count1Types);

   769 #endif

   770 	if (!PyArg_ParseTuple(_args, ""))

   771 		return NULL;

   772 	_rv = Count1Types();

   773 	{

   774 		OSErr _err = ResError();

   775 		if (_err != noErr) return PyMac_Error(_err);

   776 	}

   777 	_res = Py_BuildValue("h",

   778 	                     _rv);

   779 	return _res;

   780 }

   781 

   782 static PyObject *Res_GetIndType(PyObject *_self, PyObject *_args)

   783 {

   784 	PyObject *_res = NULL;

   785 	ResType theType;

   786 	short index;

   787 #ifndef GetIndType

   788 	PyMac_PRECHECK(GetIndType);

   789 #endif

   790 	if (!PyArg_ParseTuple(_args, "h",

   791 	                      &index))

   792 		return NULL;

   793 	GetIndType(&theType,

   794 	           index);

   795 	{

   796 		OSErr _err = ResError();

   797 		if (_err != noErr) return PyMac_Error(_err);

   798 	}

   799 	_res = Py_BuildValue("O&",

   800 	                     PyMac_BuildOSType, theType);

   801 	return _res;

   802 }

   803 

   804 static PyObject *Res_Get1IndType(PyObject *_self, PyObject *_args)

   805 {

   806 	PyObject *_res = NULL;

   807 	ResType theType;

   808 	short index;

   809 #ifndef Get1IndType

   810 	PyMac_PRECHECK(Get1IndType);

   811 #endif

   812 	if (!PyArg_ParseTuple(_args, "h",

   813 	                      &index))

   814 		return NULL;

   815 	Get1IndType(&theType,

   816 	            index);

   817 	{

   818 		OSErr _err = ResError();

   819 		if (_err != noErr) return PyMac_Error(_err);

   820 	}

   821 	_res = Py_BuildValue("O&",

   822 	                     PyMac_BuildOSType, theType);

   823 	return _res;

   824 }

   825 

   826 static PyObject *Res_SetResLoad(PyObject *_self, PyObject *_args)

   827 {

   828 	PyObject *_res = NULL;

   829 	Boolean load;

   830 #ifndef SetResLoad

   831 	PyMac_PRECHECK(SetResLoad);

   832 #endif

   833 	if (!PyArg_ParseTuple(_args, "b",

   834 	                      &load))

   835 		return NULL;

   836 	SetResLoad(load);

   837 	{

   838 		OSErr _err = ResError();

   839 		if (_err != noErr) return PyMac_Error(_err);

   840 	}

   841 	Py_INCREF(Py_None);

   842 	_res = Py_None;

   843 	return _res;

   844 }

   845 

   846 static PyObject *Res_CountResources(PyObject *_self, PyObject *_args)

   847 {

   848 	PyObject *_res = NULL;

   849 	short _rv;

   850 	ResType theType;

   851 #ifndef CountResources

   852 	PyMac_PRECHECK(CountResources);

   853 #endif

   854 	if (!PyArg_ParseTuple(_args, "O&",

   855 	                      PyMac_GetOSType, &theType))

   856 		return NULL;

   857 	_rv = CountResources(theType);

   858 	{

   859 		OSErr _err = ResError();

   860 		if (_err != noErr) return PyMac_Error(_err);

   861 	}

   862 	_res = Py_BuildValue("h",

   863 	                     _rv);

   864 	return _res;

   865 }

   866 

   867 static PyObject *Res_Count1Resources(PyObject *_self, PyObject *_args)

   868 {

   869 	PyObject *_res = NULL;

   870 	short _rv;

   871 	ResType theType;

   872 #ifndef Count1Resources

   873 	PyMac_PRECHECK(Count1Resources);

   874 #endif

   875 	if (!PyArg_ParseTuple(_args, "O&",

   876 	                      PyMac_GetOSType, &theType))

   877 		return NULL;

   878 	_rv = Count1Resources(theType);

   879 	{

   880 		OSErr _err = ResError();

   881 		if (_err != noErr) return PyMac_Error(_err);

   882 	}

   883 	_res = Py_BuildValue("h",

   884 	                     _rv);

   885 	return _res;

   886 }

   887 

   888 static PyObject *Res_GetIndResource(PyObject *_self, PyObject *_args)

   889 {

   890 	PyObject *_res = NULL;

   891 	Handle _rv;

   892 	ResType theType;

   893 	short index;

   894 #ifndef GetIndResource

   895 	PyMac_PRECHECK(GetIndResource);

   896 #endif

   897 	if (!PyArg_ParseTuple(_args, "O&h",

   898 	                      PyMac_GetOSType, &theType,

   899 	                      &index))

   900 		return NULL;

   901 	_rv = GetIndResource(theType,

   902 	                     index);

   903 	{

   904 		OSErr _err = ResError();

   905 		if (_err != noErr) return PyMac_Error(_err);

   906 	}

   907 	_res = Py_BuildValue("O&",

   908 	                     ResObj_New, _rv);

   909 	return _res;

   910 }

   911 

   912 static PyObject *Res_Get1IndResource(PyObject *_self, PyObject *_args)

   913 {

   914 	PyObject *_res = NULL;

   915 	Handle _rv;

   916 	ResType theType;

   917 	short index;

   918 #ifndef Get1IndResource

   919 	PyMac_PRECHECK(Get1IndResource);

   920 #endif

   921 	if (!PyArg_ParseTuple(_args, "O&h",

   922 	                      PyMac_GetOSType, &theType,

   923 	                      &index))

   924 		return NULL;

   925 	_rv = Get1IndResource(theType,

   926 	                      index);

   927 	{

   928 		OSErr _err = ResError();

   929 		if (_err != noErr) return PyMac_Error(_err);

   930 	}

   931 	_res = Py_BuildValue("O&",

   932 	                     ResObj_New, _rv);

   933 	return _res;

   934 }

   935 

   936 static PyObject *Res_GetResource(PyObject *_self, PyObject *_args)

   937 {

   938 	PyObject *_res = NULL;

   939 	Handle _rv;

   940 	ResType theType;

   941 	short theID;

   942 #ifndef GetResource

   943 	PyMac_PRECHECK(GetResource);

   944 #endif

   945 	if (!PyArg_ParseTuple(_args, "O&h",

   946 	                      PyMac_GetOSType, &theType,

   947 	                      &theID))

   948 		return NULL;

   949 	_rv = GetResource(theType,

   950 	                  theID);

   951 	{

   952 		OSErr _err = ResError();

   953 		if (_err != noErr) return PyMac_Error(_err);

   954 	}

   955 	_res = Py_BuildValue("O&",

   956 	                     ResObj_New, _rv);

   957 	return _res;

   958 }

   959 

   960 static PyObject *Res_Get1Resource(PyObject *_self, PyObject *_args)

   961 {

   962 	PyObject *_res = NULL;

   963 	Handle _rv;

   964 	ResType theType;

   965 	short theID;

   966 #ifndef Get1Resource

   967 	PyMac_PRECHECK(Get1Resource);

   968 #endif

   969 	if (!PyArg_ParseTuple(_args, "O&h",

   970 	                      PyMac_GetOSType, &theType,

   971 	                      &theID))

   972 		return NULL;

   973 	_rv = Get1Resource(theType,

   974 	                   theID);

   975 	{

   976 		OSErr _err = ResError();

   977 		if (_err != noErr) return PyMac_Error(_err);

   978 	}

   979 	_res = Py_BuildValue("O&",

   980 	                     ResObj_New, _rv);

   981 	return _res;

   982 }

   983 

   984 static PyObject *Res_GetNamedResource(PyObject *_self, PyObject *_args)

   985 {

   986 	PyObject *_res = NULL;

   987 	Handle _rv;

   988 	ResType theType;

   989 	Str255 name;

   990 #ifndef GetNamedResource

   991 	PyMac_PRECHECK(GetNamedResource);

   992 #endif

   993 	if (!PyArg_ParseTuple(_args, "O&O&",

   994 	                      PyMac_GetOSType, &theType,

   995 	                      PyMac_GetStr255, name))

   996 		return NULL;

   997 	_rv = GetNamedResource(theType,

   998 	                       name);

   999 	{

  1000 		OSErr _err = ResError();

  1001 		if (_err != noErr) return PyMac_Error(_err);

  1002 	}

  1003 	_res = Py_BuildValue("O&",

  1004 	                     ResObj_New, _rv);

  1005 	return _res;

  1006 }

  1007 

  1008 static PyObject *Res_Get1NamedResource(PyObject *_self, PyObject *_args)

  1009 {

  1010 	PyObject *_res = NULL;

  1011 	Handle _rv;

  1012 	ResType theType;

  1013 	Str255 name;

  1014 #ifndef Get1NamedResource

  1015 	PyMac_PRECHECK(Get1NamedResource);

  1016 #endif

  1017 	if (!PyArg_ParseTuple(_args, "O&O&",

  1018 	                      PyMac_GetOSType, &theType,

  1019 	                      PyMac_GetStr255, name))

  1020 		return NULL;

  1021 	_rv = Get1NamedResource(theType,

  1022 	                        name);

  1023 	{

  1024 		OSErr _err = ResError();

  1025 		if (_err != noErr) return PyMac_Error(_err);

  1026 	}

  1027 	_res = Py_BuildValue("O&",

  1028 	                     ResObj_New, _rv);

  1029 	return _res;

  1030 }

  1031 

  1032 static PyObject *Res_UniqueID(PyObject *_self, PyObject *_args)

  1033 {

  1034 	PyObject *_res = NULL;

  1035 	short _rv;

  1036 	ResType theType;

  1037 #ifndef UniqueID

  1038 	PyMac_PRECHECK(UniqueID);

  1039 #endif

  1040 	if (!PyArg_ParseTuple(_args, "O&",

  1041 	                      PyMac_GetOSType, &theType))

  1042 		return NULL;

  1043 	_rv = UniqueID(theType);

  1044 	{

  1045 		OSErr _err = ResError();

  1046 		if (_err != noErr) return PyMac_Error(_err);

  1047 	}

  1048 	_res = Py_BuildValue("h",

  1049 	                     _rv);

  1050 	return _res;

  1051 }

  1052 

  1053 static PyObject *Res_Unique1ID(PyObject *_self, PyObject *_args)

  1054 {

  1055 	PyObject *_res = NULL;

  1056 	short _rv;

  1057 	ResType theType;

  1058 #ifndef Unique1ID

  1059 	PyMac_PRECHECK(Unique1ID);

  1060 #endif

  1061 	if (!PyArg_ParseTuple(_args, "O&",

  1062 	                      PyMac_GetOSType, &theType))

  1063 		return NULL;

  1064 	_rv = Unique1ID(theType);

  1065 	{

  1066 		OSErr _err = ResError();

  1067 		if (_err != noErr) return PyMac_Error(_err);

  1068 	}

  1069 	_res = Py_BuildValue("h",

  1070 	                     _rv);

  1071 	return _res;

  1072 }

  1073 

  1074 static PyObject *Res_UpdateResFile(PyObject *_self, PyObject *_args)

  1075 {

  1076 	PyObject *_res = NULL;

  1077 	short refNum;

  1078 #ifndef UpdateResFile

  1079 	PyMac_PRECHECK(UpdateResFile);

  1080 #endif

  1081 	if (!PyArg_ParseTuple(_args, "h",

  1082 	                      &refNum))

  1083 		return NULL;

  1084 	UpdateResFile(refNum);

  1085 	{

  1086 		OSErr _err = ResError();

  1087 		if (_err != noErr) return PyMac_Error(_err);

  1088 	}

  1089 	Py_INCREF(Py_None);

  1090 	_res = Py_None;

  1091 	return _res;

  1092 }

  1093 

  1094 static PyObject *Res_SetResPurge(PyObject *_self, PyObject *_args)

  1095 {

  1096 	PyObject *_res = NULL;

  1097 	Boolean install;

  1098 #ifndef SetResPurge

  1099 	PyMac_PRECHECK(SetResPurge);

  1100 #endif

  1101 	if (!PyArg_ParseTuple(_args, "b",

  1102 	                      &install))

  1103 		return NULL;

  1104 	SetResPurge(install);

  1105 	{

  1106 		OSErr _err = ResError();

  1107 		if (_err != noErr) return PyMac_Error(_err);

  1108 	}

  1109 	Py_INCREF(Py_None);

  1110 	_res = Py_None;

  1111 	return _res;

  1112 }

  1113 

  1114 static PyObject *Res_GetResFileAttrs(PyObject *_self, PyObject *_args)

  1115 {

  1116 	PyObject *_res = NULL;

  1117 	short _rv;

  1118 	short refNum;

  1119 #ifndef GetResFileAttrs

  1120 	PyMac_PRECHECK(GetResFileAttrs);

  1121 #endif

  1122 	if (!PyArg_ParseTuple(_args, "h",

  1123 	                      &refNum))

  1124 		return NULL;

  1125 	_rv = GetResFileAttrs(refNum);

  1126 	{

  1127 		OSErr _err = ResError();

  1128 		if (_err != noErr) return PyMac_Error(_err);

  1129 	}

  1130 	_res = Py_BuildValue("h",

  1131 	                     _rv);

  1132 	return _res;

  1133 }

  1134 

  1135 static PyObject *Res_SetResFileAttrs(PyObject *_self, PyObject *_args)