PageRenderTime 721ms CodeModel.GetById 182ms app.highlight 432ms RepoModel.GetById 91ms app.codeStats 1ms

/Mac/Modules/res/_Resmodule.c

http://unladen-swallow.googlecode.com/
C | 1760 lines | 1621 code | 127 blank | 12 comment | 209 complexity | fbbe81d7b48ea18dc2e2ec5b6c033f91 MD5 | raw file
   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
  20extern PyObject *_ResObj_New(Handle);
  21extern int _ResObj_Convert(PyObject *, Handle *);
  22extern PyObject *_OptResObj_New(Handle);
  23extern 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 */
  31static void
  32PyMac_AutoDisposeHandle(Handle h)
  33{
  34        DisposeHandle(h);
  35}
  36
  37static PyObject *Res_Error;
  38
  39/* ---------------------- Object type Resource ---------------------- */
  40
  41PyTypeObject Resource_Type;
  42
  43#define ResObj_Check(x) ((x)->ob_type == &Resource_Type || PyObject_TypeCheck((x), &Resource_Type))
  44
  45typedef struct ResourceObject {
  46	PyObject_HEAD
  47	Handle ob_itself;
  48	void (*ob_freeit)(Handle ptr);
  49} ResourceObject;
  50
  51PyObject *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
  62int 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
  84static 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
  94static 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
 113static 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
 131static 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
 149static 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
 167static 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
 186static 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
 212static 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
 236static 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
 263static 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
 282static 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
 301static 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
 322static 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
 340static 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
 358static 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
 376static 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
 397static 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__
 417static 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
 426static 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
 436static 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
 454static 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
 472static 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
 518static 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
 535static 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
 560static 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
 567static 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
 579static 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
 610static 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
 622PyTypeObject 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
 669static 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
 689static 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
 705static 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
 724static 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
 744static 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
 763static 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
 782static 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
 804static 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
 826static 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
 846static 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
 867static 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
 888static 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
 912static 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
 936static 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
 960static 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
 984static 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
1008static 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
1032static 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
1053static 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
1074static 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
1094static 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
1114static 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
1135static PyObject *Res_SetResFileAttrs(PyObject *_self, PyObject *_args)
1136{
1137	PyObject *_res = NULL;
1138	short refNum;
1139	short attrs;
1140#ifndef SetResFileAttrs
1141	PyMac_PRECHECK(SetResFileAttrs);
1142#endif
1143	if (!PyArg_ParseTuple(_args, "hh",
1144	                      &refNum,
1145	                      &attrs))
1146		return NULL;
1147	SetResFileAttrs(refNum,
1148	                attrs);
1149	{
1150		OSErr _err = ResError();
1151		if (_err != noErr) return PyMac_Error(_err);
1152	}
1153	Py_INCREF(Py_None);
1154	_res = Py_None;
1155	return _res;
1156}
1157
1158#ifndef __LP64__
1159static PyObject *Res_OpenRFPerm(PyObject *_self, PyObject *_args)
1160{
1161	PyObject *_res = NULL;
1162	short _rv;
1163	Str255 fileName;
1164	short vRefNum;
1165	SignedByte permission;
1166#ifndef OpenRFPerm
1167	PyMac_PRECHECK(OpenRFPerm);
1168#endif
1169	if (!PyArg_ParseTuple(_args, "O&hb",
1170	                      PyMac_GetStr255, fileName,
1171	                      &vRefNum,
1172	                      &permission))
1173		return NULL;
1174	_rv = OpenRFPerm(fileName,
1175	                 vRefNum,
1176	                 permission);
1177	{
1178		OSErr _err = ResError();
1179		if (_err != noErr) return PyMac_Error(_err);
1180	}
1181	_res = Py_BuildValue("h",
1182	                     _rv);
1183	return _res;
1184}
1185
1186static PyObject *Res_HOpenResFile(PyObject *_self, PyObject *_args)
1187{
1188	PyObject *_res = NULL;
1189	short _rv;
1190	short vRefNum;
1191	long dirID;
1192	Str255 fileName;
1193	SignedByte permission;
1194#ifndef HOpenResFile
1195	PyMac_PRECHECK(HOpenResFile);
1196#endif
1197	if (!PyArg_ParseTuple(_args, "hlO&b",
1198	                      &vRefNum,
1199	                      &dirID,
1200	                      PyMac_GetStr255, fileName,
1201	                      &permission))
1202		return NULL;
1203	_rv = HOpenResFile(vRefNum,
1204	                   dirID,
1205	                   fileName,
1206	                   permission);
1207	{
1208		OSErr _err = ResError();
1209		if (_err != noErr) return PyMac_Error(_err);
1210	}
1211	_res = Py_BuildValue("h",
1212	                     _rv);
1213	return _res;
1214}
1215
1216static PyObject *Res_HCreateResFile(PyObject *_self, PyObject *_args)
1217{
1218	PyObject *_res = NULL;
1219	short vRefNum;
1220	long dirID;
1221	Str255 fileName;
1222#ifndef HCreateResFile
1223	PyMac_PRECHECK(HCreateResFile);
1224#endif
1225	if (!PyArg_ParseTuple(_args, "hlO&",
1226	                      &vRefNum,
1227	                      &dirID,
1228	                      PyMac_GetStr255, fileName))
1229		return NULL;
1230	HCreateResFile(vRefNum,
1231	               dirID,
1232	               fileName);
1233	{
1234		OSErr _err = ResError();
1235		if (_err != noErr) return PyMac_Error(_err);
1236	}
1237	Py_INCREF(Py_None);
1238	_res = Py_None;
1239	return _res;
1240}
1241
1242static PyObject *Res_FSpOpenResFile(PyObject *_self, PyObject *_args)
1243{
1244	PyObject *_res = NULL;
1245	short _rv;
1246	FSSpec spec;
1247	SignedByte permission;
1248#ifndef FSpOpenResFile
1249	PyMac_PRECHECK(FSpOpenResFile);
1250#endif
1251	if (!PyArg_ParseTuple(_args, "O&b",
1252	                      PyMac_GetFSSpec, &spec,
1253	                      &permission))
1254		return NULL;
1255	_rv = FSpOpenResFile(&spec,
1256	                     permission);
1257	{
1258		OSErr _err = ResError();
1259		if (_err != noErr) return PyMac_Error(_err);
1260	}
1261	_res = Py_BuildValue("h",
1262	                     _rv);
1263	return _res;
1264}
1265
1266static PyObject *Res_FSpCreateResFile(PyObject *_self, PyObject *_args)
1267{
1268	PyObject *_res = NULL;
1269	FSSpec spec;
1270	OSType creator;
1271	OSType fileType;
1272	ScriptCode scriptTag;
1273#ifndef FSpCreateResFile
1274	PyMac_PRECHECK(FSpCreateResFile);
1275#endif
1276	if (!PyArg_ParseTuple(_args, "O&O&O&h",
1277	                      PyMac_GetFSSpec, &spec,
1278	                      PyMac_GetOSType, &creator,
1279	                      PyMac_GetOSType, &fileType,
1280	                      &scriptTag))
1281		return NULL;
1282	FSpCreateResFile(&spec,
1283	                 creator,
1284	                 fileType,
1285	                 scriptTag);
1286	{
1287		OSErr _err = ResError();
1288		if (_err != noErr) return PyMac_Error(_err);
1289	}
1290	Py_INCREF(Py_None);
1291	_res = Py_None;
1292	return _res;
1293}
1294#endif /* !__LP64__ */
1295
1296static PyObject *Res_InsertResourceFile(PyObject *_self, PyObject *_args)
1297{
1298	PyObject *_res = NULL;
1299	OSErr _err;
1300	SInt16 refNum;
1301	RsrcChainLocation where;
1302#ifndef InsertResourceFile
1303	PyMac_PRECHECK(InsertResourceFile);
1304#endif
1305	if (!PyArg_ParseTuple(_args, "hh",
1306	                      &refNum,
1307	                      &where))
1308		return NULL;
1309	_err = InsertResourceFile(refNum,
1310	                          where);
1311	if (_err != noErr) return PyMac_Error(_err);
1312	Py_INCREF(Py_None);
1313	_res = Py_None;
1314	return _res;
1315}
1316
1317static PyObject *Res_DetachResourceFile(PyObject *_self, PyObject *_args)
1318{
1319	PyObject *_res = NULL;
1320	OSErr _err;
1321	SInt16 refNum;
1322#ifndef DetachResourceFile
1323	PyMac_PRECHECK(DetachResourceFile);
1324#endif
1325	if (!PyArg_ParseTuple(_args, "h",
1326	                      &refNum))
1327		return NULL;
1328	_err = DetachResourceFile(refNum);
1329	if (_err != noErr) return PyMac_Error(_err);
1330	Py_INCREF(Py_None);
1331	_res = Py_None;
1332	return _res;
1333}
1334
1335#ifndef __LP64__
1336static PyObject *Res_FSpResourceFileAlreadyOpen(PyObject *_self, PyObject *_args)
1337{
1338	PyObject *_res = NULL;
1339	Boolean _rv;
1340	FSSpec resourceFile;
1341	Boolean inChain;
1342	SInt16 refNum;
1343#ifndef FSpResourceFileAlreadyOpen
1344	PyMac_PRECHECK(FSpResourceFileAlreadyOpen);
1345#endif
1346	if (!PyArg_ParseTuple(_args, "O&",
1347	                      PyMac_GetFSSpec, &resourceFile))
1348		return NULL;
1349	_rv = FSpResourceFileAlreadyOpen(&resourceFile,
1350	                                 &inChain,
1351	                                 &refNum);
1352	{
1353		OSErr _err = ResError();
1354		if (_err != noErr) return PyMac_Error(_err);
1355	}
1356	_res = Py_BuildValue("bbh",
1357	                     _rv,
1358	                     inChain,
1359	                     refNum);
1360	return _res;
1361}
1362
1363static PyObject *Res_FSpOpenOrphanResFile(PyObject *_self, PyObject *_args)
1364{
1365	PyObject *_res = NULL;
1366	OSErr _err;
1367	FSSpec spec;
1368	SignedByte permission;
1369	SInt16 refNum;
1370#ifndef FSpOpenOrphanResFile
1371	PyMac_PRECHECK(FSpOpenOrphanResFile);
1372#endif
1373	if (!PyArg_ParseTuple(_args, "O&b",
1374	                      PyMac_GetFSSpec, &spec,
1375	                      &permission))
1376		return NULL;
1377	_err = FSpOpenOrphanResFile(&spec,
1378	                            permission,
1379	                            &refNum);
1380	if (_err != noErr) return PyMac_Error(_err);
1381	_res = Py_BuildValue("h",
1382	                     refNum);
1383	return _res;
1384}
1385
1386static PyObject *Res_GetTopResourceFile(PyObject *_self, PyObject *_args)
1387{
1388	PyObject *_res = NULL;
1389	OSErr _err;
1390	SInt16 refNum;
1391#ifndef GetTopResourceFile
1392	PyMac_PRECHECK(GetTopResourceFile);
1393#endif
1394	if (!PyArg_ParseTuple(_args, ""))
1395		return NULL;
1396	_err = GetTopResourceFile(&refNum);
1397	if (_err != noErr) return PyMac_Error(_err);
1398	_res = Py_BuildValue("h",
1399	                     refNum);
1400	return _res;
1401}
1402
1403
1404static PyObject *Res_GetNextResourceFile(PyObject *_self, PyObject *_args)
1405{
1406	PyObject *_res = NULL;
1407	OSErr _err;
1408	SInt16 curRefNum;
1409	SInt16 nextRefNum;
1410#ifndef GetNextResourceFile
1411	PyMac_PRECHECK(GetNextResourceFile);
1412#endif
1413	if (!PyArg_ParseTuple(_args, "h",
1414	                      &curRefNum))
1415		return NULL;
1416	_err = GetNextResourceFile(curRefNum,
1417	                           &nextRefNum);
1418	if (_err != noErr) return PyMac_Error(_err);
1419	_res = Py_BuildValue("h",
1420	                     nextRefNum);
1421	return _res;
1422}
1423#endif /* !__LP64__ */
1424
1425static PyObject *Res_FSOpenResFile(PyObject *_self, PyObject *_args)
1426{
1427	PyObject *_res = NULL;
1428	short _rv;
1429	FSRef ref;
1430	SignedByte permission;
1431#ifndef FSOpenResFile
1432	PyMac_PRECHECK(FSOpenResFile);
1433#endif
1434	if (!PyArg_ParseTuple(_args, "O&b",
1435	                      PyMac_GetFSRef, &ref,
1436	                      &permission))
1437		return NULL;
1438	_rv = FSOpenResFile(&ref,
1439	                    permission);
1440	{
1441		OSErr _err = ResError();
1442		if (_err != noErr) return PyMac_Error(_err);
1443	}
1444	_res = Py_BuildValue("h",
1445	                     _rv);
1446	return _res;
1447}
1448
1449
1450#ifndef __LP64__
1451static PyObject *Res_FSCreateResFile(PyObject *_self, PyObject *_args)
1452{
1453	PyObject *_res = NULL;
1454	FSRef parentRef;
1455	UniChar *nameLength__in__;
1456	UniCharCount nameLength__len__;
1457	int nameLength__in_len__;
1458	FSRef newRef;
1459	FSSpec newSpec;
1460#ifndef FSCreateResFile
1461	PyMac_PRECHECK(FSCreateResFile);
1462#endif
1463	if (!PyArg_ParseTuple(_args, "O&u#",
1464	                      PyMac_GetFSRef, &parentRef,
1465	                      &nameLength__in__, &nameLength__in_len__))
1466		return NULL;
1467	nameLength__len__ = nameLength__in_len__;
1468	FSCreateResFile(&parentRef,
1469	                nameLength__len__, nameLength__in__,
1470	                0,
1471	                (FSCatalogInfo *)0,
1472	                &newRef,
1473	                &newSpec);
1474	{
1475		OSErr _err = ResError();
1476		if (_err != noErr) return PyMac_Error(_err);
1477	}
1478	_res = Py_BuildValue("O&O&",
1479	                     PyMac_BuildFSRef, &newRef,
1480	                     PyMac_BuildFSSpec, &newSpec);
1481	return _res;
1482}
1483
1484static PyObject *Res_FSResourceFileAlreadyOpen(PyObject *_self, PyObject *_args)
1485{
1486	PyObject *_res = NULL;
1487	Boolean _rv;
1488	FSRef resourceFileRef;
1489	Boolean inChain;
1490	SInt16 refNum;
1491#ifndef FSResourceFileAlreadyOpen
1492	PyMac_PRECHECK(FSResourceFileAlreadyOpen);
1493#endif
1494	if (!PyArg_ParseTuple(_args, "O&",
1495	                      PyMac_GetFSRef, &resourceFileRef))
1496		return NULL;
1497	_rv = FSResourceFileAlreadyOpen(&resourceFileRef,
1498	                                &inChain,
1499	                                &refNum);
1500	{
1501		OSErr _err = ResError();
1502		if (_err != noErr) return PyMac_Error(_err);
1503	}
1504	_res = Py_BuildValue("bbh",
1505	                     _rv,
1506	                     inChain,
1507	                     refNum);
1508	return _res;
1509}
1510
1511static PyObject *Res_FSCreateResourceFile(PyObject *_self, PyObject *_args)
1512{
1513	PyObject *_res = NULL;
1514	OSErr _err;
1515	FSRef parentRef;
1516	UniChar *nameLength__in__;
1517	UniCharCount nameLength__len__;
1518	int nameLength__in_len__;
1519	UniChar *forkNameLength__in__;
1520	UniCharCount forkNameLength__len__;
1521	int forkNameLength__in_len__;
1522	FSRef newRef;
1523	FSSpec newSpec;
1524#ifndef FSCreateResourceFile
1525	PyMac_PRECHECK(FSCreateResourceFile);
1526#endif
1527	if (!PyArg_ParseTuple(_args, "O&u#u#",
1528	                      PyMac_GetFSRef, &parentRef,
1529	                      &nameLength__in__, &nameLength__in_len__,
1530	                      &forkNameLength__in__, &forkNameLength__in_len__))
1531		return NULL;
1532	nameLength__len__ = nameLength__in_len__;
1533	forkNameLength__len__ = forkNameLength__in_len__;
1534	_err = FSCreateResourceFile(&parentRef,
1535	                            nameLength__len__, nameLength__in__,
1536	                            0,
1537	                            (FSCatalogInfo *)0,
1538	                            forkNameLength__len__, forkNameLength__in__,
1539	                            &newRef,
1540	                            &newSpec);
1541	if (_err != noErr) return PyMac_Error(_err);
1542	_res = Py_BuildValue("O&O&",
1543	                     PyMac_BuildFSRef, &newRef,
1544	                     PyMac_BuildFSSpec, &newSpec);
1545	return _res;
1546}
1547#endif /* __LP64__ */
1548
1549static PyObject *Res_FSOpenResourceFile(PyObject *_self, PyObject *_args)
1550{
1551	PyObject *_res = NULL;
1552	OSErr _err;
1553	FSRef ref;
1554	UniChar *forkNameLength__in__;
1555	UniCharCount forkNameLength__len__;
1556	int forkNameLength__in_len__;
1557	SignedByte permissions;
1558	ResFileRefNum refNum;
1559#ifndef FSOpenResourceFile
1560	PyMac_PRECHECK(FSOpenResourceFile);
1561#endif
1562	if (!PyArg_ParseTuple(_args, "O&u#b",
1563	                      PyMac_GetFSRef, &ref,
1564	                      &forkNameLength__in__, &forkNameLength__in_len__,
1565	                      &permissions))
1566		return NULL;
1567	forkNameLength__len__ = forkNameLength__in_len__;
1568	_err = FSOpenResourceFile(&ref,
1569	                          forkNameLength__len__, forkNameLength__in__,
1570	                          permissions,
1571	                          &refNum);
1572	if (_err != noErr) return PyMac_Error(_err);
1573	_res = Py_BuildValue("h",
1574	                     refNum);
1575	return _res;
1576}
1577
1578static PyObject *Res_Handle(PyObject *_self, PyObject *_args)
1579{
1580	PyObject *_res = NULL;
1581
1582	char *buf;
1583	int len;
1584	Handle h;
1585	ResourceObject *rv;
1586
1587	if (!PyArg_ParseTuple(_args, "s#", &buf, &len))
1588	        return NULL;
1589	h = NewHandle(len);
1590	if ( h == NULL ) {
1591	        PyErr_NoMemory();
1592	        return NULL;
1593	}
1594	HLock(h);
1595	memcpy(*h, buf, len);
1596	HUnlock(h);
1597	rv = (ResourceObject *)ResObj_New(h);
1598	rv->ob_freeit = PyMac_AutoDisposeHandle;
1599	_res = (PyObject *)rv;
1600	return _res;
1601
1602}
1603
1604static PyMethodDef Res_methods[] = {
1605	{"CloseResFile", (PyCFunction)Res_CloseResFile, 1,
1606	 PyDoc_STR("(short refNum) -> None")},
1607	{"ResError", (PyCFunction)Res_ResError, 1,
1608	 PyDoc_STR("() -> None")},
1609	{"CurResFile", (PyCFunction)Res_CurResFile, 1,
1610	 PyDoc_STR("() -> (short _rv)")},
1611	{"UseResFile", (PyCFunction)Res_UseResFile, 1,
1612	 PyDoc_STR("(short refNum) -> None")},
1613	{"CountTypes", (PyCFunction)Res_CountTypes, 1,
1614	 PyDoc_STR("() -> (short _rv)")},
1615	{"Count1Types", (PyCFunction)Res_Count1Types, 1,
1616	 PyDoc_STR("() -> (short _rv)")},
1617	{"GetIndType", (PyCFunction)Res_GetIndType, 1,
1618	 PyDoc_STR("(short index) -> (ResType theType)")},
1619	{"Get1IndType", (PyCFunction)Res_Get1IndType, 1,
1620	 PyDoc_STR("(short index) -> (ResType theType)")},
1621	{"SetResLoad", (PyCFunction)Res_SetResLoad, 1,
1622	 PyDoc_STR("(Boolean load) -> None")},
1623	{"CountResources", (PyCFunction)Res_CountResources, 1,
1624	 PyDoc_STR("(ResType theType) -> (short _rv)")},
1625	{"Count1Resources", (PyCFunction)Res_Count1Resources, 1,
1626	 PyDoc_STR("(ResType theType) -> (short _rv)")},
1627	{"GetIndResource", (PyCFunction)Res_GetIndResource, 1,
1628	 PyDoc_STR("(ResType theType, short index) -> (Handle _rv)")},
1629	{"Get1IndResource", (PyCFunction)Res_Get1IndResource, 1,
1630	 PyDoc_STR("(ResType theType, short index) -> (Handle _rv)")},
1631	{"GetResource", (PyCFunction)Res_GetResource, 1,
1632	 PyDoc_STR("(ResType theType, short theID) -> (Handle _rv)")},
1633	{"Get1Resource", (PyCFunction)Res_Get1Resource, 1,
1634	 PyDoc_STR("(ResType theType, short theID) -> (Handle _rv)")},
1635	{"GetNamedResource", (PyCFunction)Res_GetNamedResource, 1,
1636	 PyDoc_STR("(ResType theType, Str255 name) -> (Handle _rv)")},
1637	{"Get1NamedResource", (PyCFunction)Res_Get1NamedResource, 1,
1638	 PyDoc_STR("(ResType theType, Str255 name) -> (Handle _rv)")},
1639	{"UniqueID", (PyCFunction)Res_UniqueID, 1,
1640	 PyDoc_STR("(ResType theType) -> (short _rv)")},
1641	{"Unique1ID", (PyCFunction)Res_Unique1ID, 1,
1642	 PyDoc_STR("(ResType theType) -> (short _rv)")},
1643	{"UpdateResFile", (PyCFunction)Res_UpdateResFile, 1,
1644	 PyDoc_STR("(short refNum) -> None")},
1645	{"SetResPurge", (PyCFunction)Res_SetResPurge, 1,
1646	 PyDoc_STR("(Boolean install) -> None")},
1647	{"GetResFileAttrs", (PyCFunction)Res_GetResFileAttrs, 1,
1648	 PyDoc_STR("(short refNum) -> (short _rv)")},
1649	{"SetResFileAttrs", (PyCFunction)Res_SetResFileAttrs, 1,
1650	 PyDoc_STR("(short refNum, short attrs) -> None")},
1651#ifndef __LP64__
1652	{"OpenRFPerm", (PyCFunction)Res_OpenRFPerm, 1,
1653	 PyDoc_STR("(Str255 fileName, short vRefNum, SignedByte permission) -> (short _rv)")},
1654	{"HOpenResFile", (PyCFunction)Res_HOpenResFile, 1,
1655	 PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SignedByte permission) -> (short _rv)")},
1656	{"HCreateResFile", (PyCFunction)Res_HCreateResFile, 1,
1657	 PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")},
1658	{"FSpOpenResFile", (PyCFunction)Res_FSpOpenResFile, 1,
1659	 PyDoc_STR("(FSSpec spec, SignedByte permission) -> (short _rv)")},
1660	{"FSpCreateResFile", (PyCFunction)Res_FSpCreateResFile, 1,
1661	 PyDoc_STR("(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None")},
1662#endif /* !__LP64__ */
1663	{"InsertResourceFile", (PyCFunction)Res_InsertResourceFile, 1,
1664	 PyDoc_STR("(SInt16 refNum, RsrcChainLocation where) -> None")},
1665	{"DetachResourceFile", (PyCFunction)Res_DetachResourceFile, 1,
1666	 PyDoc_STR("(SInt16 refNum) -> None")},
1667#ifndef __LP64__
1668	{"FSpResourceFileAlreadyOpen", (PyCFunction)Res_FSpResourceFileAlreadyOpen, 1,
1669	 PyDoc_STR("(FSSpec resourceFile) -> (Boolean _rv, Boolean inChain, SInt16 refNum)")},
1670	{"FSpOpenOrphanResFile", (PyCFunction)Res_FSpOpenOrphanResFile, 1,
1671	 PyDoc_STR("(FSSpec spec, SignedByte permission) -> (SInt16 refNum)")},
1672	{"GetTopResourceFile", (PyCFunction)Res_GetTopResourceFile, 1,
1673	 PyDoc_STR("() -> (SInt16 refNum)")},
1674	{"GetNextResourceFile", (PyCFunction)Res_GetNextResourceFile, 1,
1675	 PyDoc_STR("(SInt16 curRefNum) -> (SInt16 nextRefNum)")},
1676#endif /* __LP64__ */
1677	{"FSOpenResFile", (PyCFunction)Res_FSOpenResFile, 1,
1678	 PyDoc_STR("(FSRef ref, SignedByte permission) -> (short _rv)")},
1679#ifndef __LP64__
1680	{"FSCreateResFile", (PyCFunction)Res_FSCreateResFile, 1,
1681	 PyDoc_STR("(FSRef parentRef, Buffer nameLength) -> (FSRef newRef, FSSpec newSpec)")},
1682	{"FSResourceFileAlreadyOpen", (PyCFunction)Res_FSResourceFileAlreadyOpen, 1,
1683	 PyDoc_STR("(FSRef resourceFileRef) -> (Boolean _rv, Boolean inChain, SInt16 refNum)")},
1684	{"FSCreateResourceFile", (PyCFunction)Res_FSCreateResourceFile, 1,
1685	 PyDoc_STR("(FSRef parentRef, Buffer nameLength, Buffer forkNameLength) -> (FSRef newRef, FSSpec newSpec)")},
1686#endif /* __LP64__ */
1687	{"FSOpenResourceFile", (PyCFunction)Res_FSOpenResourceFile, 1,
1688	 PyDoc_STR("(FSRef ref, Buffer forkNameLength, SignedByte permissions) -> (SInt16 refNum)")},
1689	{"Handle", (PyCFunction)Res_Handle, 1,
1690	 PyDoc_STR("Convert a string to a Handle object.\n\nResource() and Handle() are very similar, but objects created with Handle() are\nby default automatically DisposeHandle()d upon object cleanup. Use AutoDispose()\nto change this.\n")},
1691	{NULL, NULL, 0}
1692};
1693
1694
1695
1696/* Alternative version of ResObj_New, which returns None for null argument */
1697PyObject *OptResObj_New(Handle itself)
1698{
1699        if (itself == NULL) {
1700                Py_INCREF(Py_None);
1701                return Py_None;
1702        }
1703        return ResObj_New(itself);
1704}
1705
1706int OptResObj_Convert(PyObject *v, Handle *p_itself)
1707{
1708        PyObject *tmp;
1709
1710        if ( v == Py_None ) {
1711                *p_itself = NULL;
1712                return 1;
1713        }
1714        if (ResObj_Check(v))
1715        {
1716                *p_itself = ((ResourceObject *)v)->ob_itself;
1717                return 1;
1718        }
1719        /* If it isn't a resource yet see whether it is convertible */
1720        if ( (tmp=PyObject_CallMethod(v, "as_Resource", "")) ) {
1721                *p_itself = ((ResourceObject *)tmp)->ob_itself;
1722                Py_DECREF(tmp);
1723                return 1;
1724        }
1725        PyErr_Clear();
1726        PyErr_SetString(PyExc_TypeError, "Resource required");
1727        return 0;
1728}
1729
1730
1731void init_Res(void)
1732{
1733	PyObject *m;
1734	PyObject *d;
1735
1736
1737
1738	        PyMac_INIT_TOOLBOX_OBJECT_NEW(Handle, ResObj_New);
1739	        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Handle, ResObj_Convert);
1740	        PyMac_INIT_TOOLBOX_OBJECT_NEW(Handle, OptResObj_New);
1741	        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Handle, OptResObj_Convert);
1742
1743
1744	m = Py_InitModule("_Res", Res_methods);
1745	d = PyModule_GetDict(m);
1746	Res_Error = PyMac_GetOSErrException();
1747	if (Res_Error == NULL ||
1748	    PyDict_SetItemString(d, "Error", Res_Error) != 0)
1749		return;
1750	Resource_Type.ob_type = &PyType_Type;
1751	if (PyType_Ready(&Resource_Type) < 0) return;
1752	Py_INCREF(&Resource_Type);
1753	PyModule_AddObject(m, "Resource", (PyObject *)&Resource_Type);
1754	/* Backward-compatible name */
1755	Py_INCREF(&Resource_Type);
1756	PyModule_AddObject(m, "ResourceType", (PyObject *)&Resource_Type);
1757}
1758
1759/* ======================== End module _Res ========================= */
1760