mirror of https://github.com/python/cpython.git
1417 lines
32 KiB
C
1417 lines
32 KiB
C
|
|
/* =========================== Module Res =========================== */
|
|
|
|
#include "Python.h"
|
|
|
|
|
|
|
|
#define SystemSevenOrLater 1
|
|
|
|
#include "macglue.h"
|
|
#include <Memory.h>
|
|
#include <Dialogs.h>
|
|
#include <Menus.h>
|
|
#include <Controls.h>
|
|
|
|
extern PyObject *ResObj_New(Handle);
|
|
extern int ResObj_Convert(PyObject *, Handle *);
|
|
extern PyObject *OptResObj_New(Handle);
|
|
extern int OptResObj_Convert(PyObject *, Handle *);
|
|
|
|
extern PyObject *WinObj_New(WindowPtr);
|
|
extern int WinObj_Convert(PyObject *, WindowPtr *);
|
|
extern PyTypeObject Window_Type;
|
|
#define WinObj_Check(x) ((x)->ob_type == &Window_Type)
|
|
|
|
extern PyObject *DlgObj_New(DialogPtr);
|
|
extern int DlgObj_Convert(PyObject *, DialogPtr *);
|
|
extern PyTypeObject Dialog_Type;
|
|
#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
|
|
|
|
extern PyObject *MenuObj_New(MenuHandle);
|
|
extern int MenuObj_Convert(PyObject *, MenuHandle *);
|
|
|
|
extern PyObject *CtlObj_New(ControlHandle);
|
|
extern int CtlObj_Convert(PyObject *, ControlHandle *);
|
|
|
|
extern PyObject *GrafObj_New(GrafPtr);
|
|
extern int GrafObj_Convert(PyObject *, GrafPtr *);
|
|
|
|
extern PyObject *BMObj_New(BitMapPtr);
|
|
extern int BMObj_Convert(PyObject *, BitMapPtr *);
|
|
|
|
extern PyObject *WinObj_WhichWindow(WindowPtr);
|
|
|
|
#include <Resources.h>
|
|
#include <string.h>
|
|
|
|
#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
|
|
|
|
static PyObject *Res_Error;
|
|
|
|
/* ---------------------- Object type Resource ---------------------- */
|
|
|
|
PyTypeObject Resource_Type;
|
|
|
|
#define ResObj_Check(x) ((x)->ob_type == &Resource_Type)
|
|
|
|
typedef struct ResourceObject {
|
|
PyObject_HEAD
|
|
Handle ob_itself;
|
|
} ResourceObject;
|
|
|
|
PyObject *ResObj_New(itself)
|
|
Handle itself;
|
|
{
|
|
ResourceObject *it;
|
|
if (itself == NULL) return PyMac_Error(resNotFound);
|
|
it = PyObject_NEW(ResourceObject, &Resource_Type);
|
|
if (it == NULL) return NULL;
|
|
it->ob_itself = itself;
|
|
return (PyObject *)it;
|
|
}
|
|
ResObj_Convert(v, p_itself)
|
|
PyObject *v;
|
|
Handle *p_itself;
|
|
{
|
|
if (!ResObj_Check(v))
|
|
{
|
|
PyErr_SetString(PyExc_TypeError, "Resource required");
|
|
return 0;
|
|
}
|
|
*p_itself = ((ResourceObject *)v)->ob_itself;
|
|
return 1;
|
|
}
|
|
|
|
static void ResObj_dealloc(self)
|
|
ResourceObject *self;
|
|
{
|
|
/* Cleanup of self->ob_itself goes here */
|
|
PyMem_DEL(self);
|
|
}
|
|
|
|
static PyObject *ResObj_HomeResFile(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = HomeResFile(_self->ob_itself);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_MacLoadResource(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
MacLoadResource(_self->ob_itself);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_ReleaseResource(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
ReleaseResource(_self->ob_itself);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_DetachResource(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
DetachResource(_self->ob_itself);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_GetResAttrs(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetResAttrs(_self->ob_itself);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_GetResInfo(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short theID;
|
|
ResType theType;
|
|
Str255 name;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
GetResInfo(_self->ob_itself,
|
|
&theID,
|
|
&theType,
|
|
name);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("hO&O&",
|
|
theID,
|
|
PyMac_BuildOSType, theType,
|
|
PyMac_BuildStr255, name);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_SetResInfo(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short theID;
|
|
Str255 name;
|
|
if (!PyArg_ParseTuple(_args, "hO&",
|
|
&theID,
|
|
PyMac_GetStr255, name))
|
|
return NULL;
|
|
SetResInfo(_self->ob_itself,
|
|
theID,
|
|
name);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_AddResource(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
ResType theType;
|
|
short theID;
|
|
Str255 name;
|
|
if (!PyArg_ParseTuple(_args, "O&hO&",
|
|
PyMac_GetOSType, &theType,
|
|
&theID,
|
|
PyMac_GetStr255, name))
|
|
return NULL;
|
|
AddResource(_self->ob_itself,
|
|
theType,
|
|
theID,
|
|
name);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_GetResourceSizeOnDisk(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
long _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetResourceSizeOnDisk(_self->ob_itself);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("l",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_GetMaxResourceSize(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
long _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetMaxResourceSize(_self->ob_itself);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("l",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_RsrcMapEntry(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
long _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = RsrcMapEntry(_self->ob_itself);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("l",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_SetResAttrs(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short attrs;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&attrs))
|
|
return NULL;
|
|
SetResAttrs(_self->ob_itself,
|
|
attrs);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_ChangedResource(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
ChangedResource(_self->ob_itself);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_RemoveResource(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
RemoveResource(_self->ob_itself);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_WriteResource(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
WriteResource(_self->ob_itself);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_SetResourceSize(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
long newSize;
|
|
if (!PyArg_ParseTuple(_args, "l",
|
|
&newSize))
|
|
return NULL;
|
|
SetResourceSize(_self->ob_itself,
|
|
newSize);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_GetNextFOND(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Handle _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetNextFOND(_self->ob_itself);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("O&",
|
|
ResObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *ResObj_as_Control(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
|
|
return CtlObj_New((ControlHandle)_self->ob_itself);
|
|
|
|
}
|
|
|
|
static PyObject *ResObj_as_Menu(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
|
|
return MenuObj_New((MenuHandle)_self->ob_itself);
|
|
|
|
}
|
|
|
|
static PyObject *ResObj_LoadResource(_self, _args)
|
|
ResourceObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
LoadResource(_self->ob_itself);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyMethodDef ResObj_methods[] = {
|
|
{"HomeResFile", (PyCFunction)ResObj_HomeResFile, 1,
|
|
"() -> (short _rv)"},
|
|
{"MacLoadResource", (PyCFunction)ResObj_MacLoadResource, 1,
|
|
"() -> None"},
|
|
{"ReleaseResource", (PyCFunction)ResObj_ReleaseResource, 1,
|
|
"() -> None"},
|
|
{"DetachResource", (PyCFunction)ResObj_DetachResource, 1,
|
|
"() -> None"},
|
|
{"GetResAttrs", (PyCFunction)ResObj_GetResAttrs, 1,
|
|
"() -> (short _rv)"},
|
|
{"GetResInfo", (PyCFunction)ResObj_GetResInfo, 1,
|
|
"() -> (short theID, ResType theType, Str255 name)"},
|
|
{"SetResInfo", (PyCFunction)ResObj_SetResInfo, 1,
|
|
"(short theID, Str255 name) -> None"},
|
|
{"AddResource", (PyCFunction)ResObj_AddResource, 1,
|
|
"(ResType theType, short theID, Str255 name) -> None"},
|
|
{"GetResourceSizeOnDisk", (PyCFunction)ResObj_GetResourceSizeOnDisk, 1,
|
|
"() -> (long _rv)"},
|
|
{"GetMaxResourceSize", (PyCFunction)ResObj_GetMaxResourceSize, 1,
|
|
"() -> (long _rv)"},
|
|
{"RsrcMapEntry", (PyCFunction)ResObj_RsrcMapEntry, 1,
|
|
"() -> (long _rv)"},
|
|
{"SetResAttrs", (PyCFunction)ResObj_SetResAttrs, 1,
|
|
"(short attrs) -> None"},
|
|
{"ChangedResource", (PyCFunction)ResObj_ChangedResource, 1,
|
|
"() -> None"},
|
|
{"RemoveResource", (PyCFunction)ResObj_RemoveResource, 1,
|
|
"() -> None"},
|
|
{"WriteResource", (PyCFunction)ResObj_WriteResource, 1,
|
|
"() -> None"},
|
|
{"SetResourceSize", (PyCFunction)ResObj_SetResourceSize, 1,
|
|
"(long newSize) -> None"},
|
|
{"GetNextFOND", (PyCFunction)ResObj_GetNextFOND, 1,
|
|
"() -> (Handle _rv)"},
|
|
{"as_Control", (PyCFunction)ResObj_as_Control, 1,
|
|
"Return this resource/handle as a Control"},
|
|
{"as_Menu", (PyCFunction)ResObj_as_Menu, 1,
|
|
"Return this resource/handle as a Menu"},
|
|
{"LoadResource", (PyCFunction)ResObj_LoadResource, 1,
|
|
"() -> None"},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
PyMethodChain ResObj_chain = { ResObj_methods, NULL };
|
|
|
|
static PyObject *ResObj_getattr(self, name)
|
|
ResourceObject *self;
|
|
char *name;
|
|
{
|
|
|
|
if (strcmp(name, "size") == 0)
|
|
return PyInt_FromLong(GetHandleSize(self->ob_itself));
|
|
if (strcmp(name, "data") == 0) {
|
|
PyObject *res;
|
|
char state;
|
|
state = HGetState(self->ob_itself);
|
|
HLock(self->ob_itself);
|
|
res = PyString_FromStringAndSize(
|
|
*self->ob_itself,
|
|
GetHandleSize(self->ob_itself));
|
|
HUnlock(self->ob_itself);
|
|
HSetState(self->ob_itself, state);
|
|
return res;
|
|
}
|
|
if (strcmp(name, "__members__") == 0)
|
|
return Py_BuildValue("[ss]", "data", "size");
|
|
|
|
return Py_FindMethodInChain(&ResObj_chain, (PyObject *)self, name);
|
|
}
|
|
|
|
static int
|
|
ResObj_setattr(self, name, value)
|
|
ResourceObject *self;
|
|
char *name;
|
|
PyObject *value;
|
|
{
|
|
char *data;
|
|
long size;
|
|
|
|
if (strcmp(name, "data") != 0 || value == NULL )
|
|
return -1;
|
|
if ( !PyString_Check(value) )
|
|
return -1;
|
|
size = PyString_Size(value);
|
|
data = PyString_AsString(value);
|
|
/* XXXX Do I need the GetState/SetState calls? */
|
|
SetHandleSize(self->ob_itself, size);
|
|
if ( MemError())
|
|
return -1;
|
|
HLock(self->ob_itself);
|
|
memcpy((char *)*self->ob_itself, data, size);
|
|
HUnlock(self->ob_itself);
|
|
/* XXXX Should I do the Changed call immedeately? */
|
|
return 0;
|
|
}
|
|
|
|
|
|
PyTypeObject Resource_Type = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"Resource", /*tp_name*/
|
|
sizeof(ResourceObject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
(destructor) ResObj_dealloc, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
(getattrfunc) ResObj_getattr, /*tp_getattr*/
|
|
(setattrfunc) ResObj_setattr, /*tp_setattr*/
|
|
};
|
|
|
|
/* -------------------- End object type Resource -------------------- */
|
|
|
|
|
|
static PyObject *Res_InitResources(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = InitResources();
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_RsrcZoneInit(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
RsrcZoneInit();
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_CloseResFile(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short refNum;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&refNum))
|
|
return NULL;
|
|
CloseResFile(refNum);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_ResError(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = ResError();
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_CurResFile(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = CurResFile();
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_CreateResFile(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Str255 fileName;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetStr255, fileName))
|
|
return NULL;
|
|
CreateResFile(fileName);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_OpenResFile(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
Str255 fileName;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetStr255, fileName))
|
|
return NULL;
|
|
_rv = OpenResFile(fileName);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_UseResFile(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short refNum;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&refNum))
|
|
return NULL;
|
|
UseResFile(refNum);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_CountTypes(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = CountTypes();
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_Count1Types(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = Count1Types();
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_GetIndType(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
ResType theType;
|
|
short index;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&index))
|
|
return NULL;
|
|
GetIndType(&theType,
|
|
index);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("O&",
|
|
PyMac_BuildOSType, theType);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_Get1IndType(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
ResType theType;
|
|
short index;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&index))
|
|
return NULL;
|
|
Get1IndType(&theType,
|
|
index);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("O&",
|
|
PyMac_BuildOSType, theType);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_SetResLoad(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean load;
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
&load))
|
|
return NULL;
|
|
SetResLoad(load);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_CountResources(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
ResType theType;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetOSType, &theType))
|
|
return NULL;
|
|
_rv = CountResources(theType);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_Count1Resources(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
ResType theType;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetOSType, &theType))
|
|
return NULL;
|
|
_rv = Count1Resources(theType);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_GetIndResource(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Handle _rv;
|
|
ResType theType;
|
|
short index;
|
|
if (!PyArg_ParseTuple(_args, "O&h",
|
|
PyMac_GetOSType, &theType,
|
|
&index))
|
|
return NULL;
|
|
_rv = GetIndResource(theType,
|
|
index);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("O&",
|
|
ResObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_Get1IndResource(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Handle _rv;
|
|
ResType theType;
|
|
short index;
|
|
if (!PyArg_ParseTuple(_args, "O&h",
|
|
PyMac_GetOSType, &theType,
|
|
&index))
|
|
return NULL;
|
|
_rv = Get1IndResource(theType,
|
|
index);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("O&",
|
|
ResObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_GetResource(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Handle _rv;
|
|
ResType theType;
|
|
short theID;
|
|
if (!PyArg_ParseTuple(_args, "O&h",
|
|
PyMac_GetOSType, &theType,
|
|
&theID))
|
|
return NULL;
|
|
_rv = GetResource(theType,
|
|
theID);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("O&",
|
|
ResObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_Get1Resource(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Handle _rv;
|
|
ResType theType;
|
|
short theID;
|
|
if (!PyArg_ParseTuple(_args, "O&h",
|
|
PyMac_GetOSType, &theType,
|
|
&theID))
|
|
return NULL;
|
|
_rv = Get1Resource(theType,
|
|
theID);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("O&",
|
|
ResObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_GetNamedResource(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Handle _rv;
|
|
ResType theType;
|
|
Str255 name;
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
PyMac_GetOSType, &theType,
|
|
PyMac_GetStr255, name))
|
|
return NULL;
|
|
_rv = GetNamedResource(theType,
|
|
name);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("O&",
|
|
ResObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_Get1NamedResource(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Handle _rv;
|
|
ResType theType;
|
|
Str255 name;
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
PyMac_GetOSType, &theType,
|
|
PyMac_GetStr255, name))
|
|
return NULL;
|
|
_rv = Get1NamedResource(theType,
|
|
name);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("O&",
|
|
ResObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_UniqueID(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
ResType theType;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetOSType, &theType))
|
|
return NULL;
|
|
_rv = UniqueID(theType);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_Unique1ID(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
ResType theType;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetOSType, &theType))
|
|
return NULL;
|
|
_rv = Unique1ID(theType);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_UpdateResFile(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short refNum;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&refNum))
|
|
return NULL;
|
|
UpdateResFile(refNum);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_SetResPurge(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean install;
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
&install))
|
|
return NULL;
|
|
SetResPurge(install);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_GetResFileAttrs(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
short refNum;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&refNum))
|
|
return NULL;
|
|
_rv = GetResFileAttrs(refNum);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_SetResFileAttrs(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short refNum;
|
|
short attrs;
|
|
if (!PyArg_ParseTuple(_args, "hh",
|
|
&refNum,
|
|
&attrs))
|
|
return NULL;
|
|
SetResFileAttrs(refNum,
|
|
attrs);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_OpenRFPerm(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
Str255 fileName;
|
|
short vRefNum;
|
|
SignedByte permission;
|
|
if (!PyArg_ParseTuple(_args, "O&hb",
|
|
PyMac_GetStr255, fileName,
|
|
&vRefNum,
|
|
&permission))
|
|
return NULL;
|
|
_rv = OpenRFPerm(fileName,
|
|
vRefNum,
|
|
permission);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_RGetResource(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Handle _rv;
|
|
ResType theType;
|
|
short theID;
|
|
if (!PyArg_ParseTuple(_args, "O&h",
|
|
PyMac_GetOSType, &theType,
|
|
&theID))
|
|
return NULL;
|
|
_rv = RGetResource(theType,
|
|
theID);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("O&",
|
|
ResObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_HOpenResFile(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
short vRefNum;
|
|
long dirID;
|
|
Str255 fileName;
|
|
SignedByte permission;
|
|
if (!PyArg_ParseTuple(_args, "hlO&b",
|
|
&vRefNum,
|
|
&dirID,
|
|
PyMac_GetStr255, fileName,
|
|
&permission))
|
|
return NULL;
|
|
_rv = HOpenResFile(vRefNum,
|
|
dirID,
|
|
fileName,
|
|
permission);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_HCreateResFile(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short vRefNum;
|
|
long dirID;
|
|
Str255 fileName;
|
|
if (!PyArg_ParseTuple(_args, "hlO&",
|
|
&vRefNum,
|
|
&dirID,
|
|
PyMac_GetStr255, fileName))
|
|
return NULL;
|
|
HCreateResFile(vRefNum,
|
|
dirID,
|
|
fileName);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_FSpOpenResFile(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
FSSpec spec;
|
|
SignedByte permission;
|
|
if (!PyArg_ParseTuple(_args, "O&b",
|
|
PyMac_GetFSSpec, &spec,
|
|
&permission))
|
|
return NULL;
|
|
_rv = FSpOpenResFile(&spec,
|
|
permission);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_FSpCreateResFile(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
FSSpec spec;
|
|
OSType creator;
|
|
OSType fileType;
|
|
ScriptCode scriptTag;
|
|
if (!PyArg_ParseTuple(_args, "O&O&O&h",
|
|
PyMac_GetFSSpec, &spec,
|
|
PyMac_GetOSType, &creator,
|
|
PyMac_GetOSType, &fileType,
|
|
&scriptTag))
|
|
return NULL;
|
|
FSpCreateResFile(&spec,
|
|
creator,
|
|
fileType,
|
|
scriptTag);
|
|
{
|
|
OSErr _err = ResError();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
}
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Res_Resource(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
|
|
char *buf;
|
|
int len;
|
|
Handle h;
|
|
|
|
if (!PyArg_ParseTuple(_args, "s#", &buf, &len))
|
|
return NULL;
|
|
h = NewHandle(len);
|
|
if ( h == NULL ) {
|
|
PyErr_NoMemory();
|
|
return NULL;
|
|
}
|
|
HLock(h);
|
|
memcpy(*h, buf, len);
|
|
HUnlock(h);
|
|
return (PyObject *)ResObj_New(h);
|
|
|
|
}
|
|
|
|
static PyMethodDef Res_methods[] = {
|
|
{"InitResources", (PyCFunction)Res_InitResources, 1,
|
|
"() -> (short _rv)"},
|
|
{"RsrcZoneInit", (PyCFunction)Res_RsrcZoneInit, 1,
|
|
"() -> None"},
|
|
{"CloseResFile", (PyCFunction)Res_CloseResFile, 1,
|
|
"(short refNum) -> None"},
|
|
{"ResError", (PyCFunction)Res_ResError, 1,
|
|
"() -> (OSErr _rv)"},
|
|
{"CurResFile", (PyCFunction)Res_CurResFile, 1,
|
|
"() -> (short _rv)"},
|
|
{"CreateResFile", (PyCFunction)Res_CreateResFile, 1,
|
|
"(Str255 fileName) -> None"},
|
|
{"OpenResFile", (PyCFunction)Res_OpenResFile, 1,
|
|
"(Str255 fileName) -> (short _rv)"},
|
|
{"UseResFile", (PyCFunction)Res_UseResFile, 1,
|
|
"(short refNum) -> None"},
|
|
{"CountTypes", (PyCFunction)Res_CountTypes, 1,
|
|
"() -> (short _rv)"},
|
|
{"Count1Types", (PyCFunction)Res_Count1Types, 1,
|
|
"() -> (short _rv)"},
|
|
{"GetIndType", (PyCFunction)Res_GetIndType, 1,
|
|
"(short index) -> (ResType theType)"},
|
|
{"Get1IndType", (PyCFunction)Res_Get1IndType, 1,
|
|
"(short index) -> (ResType theType)"},
|
|
{"SetResLoad", (PyCFunction)Res_SetResLoad, 1,
|
|
"(Boolean load) -> None"},
|
|
{"CountResources", (PyCFunction)Res_CountResources, 1,
|
|
"(ResType theType) -> (short _rv)"},
|
|
{"Count1Resources", (PyCFunction)Res_Count1Resources, 1,
|
|
"(ResType theType) -> (short _rv)"},
|
|
{"GetIndResource", (PyCFunction)Res_GetIndResource, 1,
|
|
"(ResType theType, short index) -> (Handle _rv)"},
|
|
{"Get1IndResource", (PyCFunction)Res_Get1IndResource, 1,
|
|
"(ResType theType, short index) -> (Handle _rv)"},
|
|
{"GetResource", (PyCFunction)Res_GetResource, 1,
|
|
"(ResType theType, short theID) -> (Handle _rv)"},
|
|
{"Get1Resource", (PyCFunction)Res_Get1Resource, 1,
|
|
"(ResType theType, short theID) -> (Handle _rv)"},
|
|
{"GetNamedResource", (PyCFunction)Res_GetNamedResource, 1,
|
|
"(ResType theType, Str255 name) -> (Handle _rv)"},
|
|
{"Get1NamedResource", (PyCFunction)Res_Get1NamedResource, 1,
|
|
"(ResType theType, Str255 name) -> (Handle _rv)"},
|
|
{"UniqueID", (PyCFunction)Res_UniqueID, 1,
|
|
"(ResType theType) -> (short _rv)"},
|
|
{"Unique1ID", (PyCFunction)Res_Unique1ID, 1,
|
|
"(ResType theType) -> (short _rv)"},
|
|
{"UpdateResFile", (PyCFunction)Res_UpdateResFile, 1,
|
|
"(short refNum) -> None"},
|
|
{"SetResPurge", (PyCFunction)Res_SetResPurge, 1,
|
|
"(Boolean install) -> None"},
|
|
{"GetResFileAttrs", (PyCFunction)Res_GetResFileAttrs, 1,
|
|
"(short refNum) -> (short _rv)"},
|
|
{"SetResFileAttrs", (PyCFunction)Res_SetResFileAttrs, 1,
|
|
"(short refNum, short attrs) -> None"},
|
|
{"OpenRFPerm", (PyCFunction)Res_OpenRFPerm, 1,
|
|
"(Str255 fileName, short vRefNum, SignedByte permission) -> (short _rv)"},
|
|
{"RGetResource", (PyCFunction)Res_RGetResource, 1,
|
|
"(ResType theType, short theID) -> (Handle _rv)"},
|
|
{"HOpenResFile", (PyCFunction)Res_HOpenResFile, 1,
|
|
"(short vRefNum, long dirID, Str255 fileName, SignedByte permission) -> (short _rv)"},
|
|
{"HCreateResFile", (PyCFunction)Res_HCreateResFile, 1,
|
|
"(short vRefNum, long dirID, Str255 fileName) -> None"},
|
|
{"FSpOpenResFile", (PyCFunction)Res_FSpOpenResFile, 1,
|
|
"(FSSpec spec, SignedByte permission) -> (short _rv)"},
|
|
{"FSpCreateResFile", (PyCFunction)Res_FSpCreateResFile, 1,
|
|
"(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None"},
|
|
{"Resource", (PyCFunction)Res_Resource, 1,
|
|
"Convert a string to a resource object.\n\nThe created resource object is actually just a handle.\nApply AddResource() to write it to a resource file.\n"},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Alternative version of ResObj_New, which returns None for null argument */
|
|
PyObject *OptResObj_New(itself)
|
|
Handle itself;
|
|
{
|
|
if (itself == NULL) {
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
return ResObj_New(itself);
|
|
}
|
|
|
|
OptResObj_Convert(v, p_itself)
|
|
PyObject *v;
|
|
Handle *p_itself;
|
|
{
|
|
if ( v == Py_None ) {
|
|
*p_itself = NULL;
|
|
return 1;
|
|
}
|
|
if (!ResObj_Check(v))
|
|
{
|
|
PyErr_SetString(PyExc_TypeError, "Resource required");
|
|
return 0;
|
|
}
|
|
*p_itself = ((ResourceObject *)v)->ob_itself;
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
void initRes()
|
|
{
|
|
PyObject *m;
|
|
PyObject *d;
|
|
|
|
|
|
|
|
|
|
|
|
m = Py_InitModule("Res", Res_methods);
|
|
d = PyModule_GetDict(m);
|
|
Res_Error = PyMac_GetOSErrException();
|
|
if (Res_Error == NULL ||
|
|
PyDict_SetItemString(d, "Error", Res_Error) != 0)
|
|
Py_FatalError("can't initialize Res.Error");
|
|
Resource_Type.ob_type = &PyType_Type;
|
|
Py_INCREF(&Resource_Type);
|
|
if (PyDict_SetItemString(d, "ResourceType", (PyObject *)&Resource_Type) != 0)
|
|
Py_FatalError("can't initialize ResourceType");
|
|
}
|
|
|
|
/* ========================= End module Res ========================= */
|
|
|