From ebd0106c77802586adca7cec286b7437a66deb3c Mon Sep 17 00:00:00 2001 From: Jack Jansen Date: Sun, 14 May 2000 22:05:36 +0000 Subject: [PATCH] Interface to macOS 9 HTMLRenderingLib. Not yet functional. --- Mac/Build/HtmlRender.prj | Bin 0 -> 42130 bytes Mac/Build/HtmlRender.prj.exp | 1 + Mac/Modules/htmlrender/HtmlRendermodule.c | 802 ++++++++++++++++++++++ Mac/Modules/htmlrender/htmlscan.py | 61 ++ Mac/Modules/htmlrender/htmlsupport.py | 210 ++++++ 5 files changed, 1074 insertions(+) create mode 100644 Mac/Build/HtmlRender.prj create mode 100644 Mac/Build/HtmlRender.prj.exp create mode 100644 Mac/Modules/htmlrender/HtmlRendermodule.c create mode 100644 Mac/Modules/htmlrender/htmlscan.py create mode 100644 Mac/Modules/htmlrender/htmlsupport.py diff --git a/Mac/Build/HtmlRender.prj b/Mac/Build/HtmlRender.prj new file mode 100644 index 0000000000000000000000000000000000000000..eb57b129c64a975b15a2811ad440a512b0fde25c GIT binary patch literal 42130 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 +#include +#include +#include + +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 + +static PyObject *Html_Error; + +/* --------------------- Object type HtmlObject --------------------- */ + +PyTypeObject HtmlObject_Type; + +#define HtmlObj_Check(x) ((x)->ob_type == &HtmlObject_Type) + +typedef struct HtmlObjectObject { + PyObject_HEAD + HRReference ob_itself; +} HtmlObjectObject; + +PyObject *HtmlObj_New(itself) + HRReference itself; +{ + HtmlObjectObject *it; + it = PyObject_NEW(HtmlObjectObject, &HtmlObject_Type); + if (it == NULL) return NULL; + it->ob_itself = itself; + return (PyObject *)it; +} +HtmlObj_Convert(v, p_itself) + PyObject *v; + HRReference *p_itself; +{ + if (!HtmlObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "HtmlObject required"); + return 0; + } + *p_itself = ((HtmlObjectObject *)v)->ob_itself; + return 1; +} + +static void HtmlObj_dealloc(self) + HtmlObjectObject *self; +{ + /* Cleanup of self->ob_itself goes here */ + PyMem_DEL(self); +} + +static PyObject *HtmlObj_HRDisposeReference(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = HRDisposeReference(_self->ob_itself); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRSetGrafPtr(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + GrafPtr grafPtr; + if (!PyArg_ParseTuple(_args, "O&", + GrafObj_Convert, &grafPtr)) + return NULL; + _err = HRSetGrafPtr(_self->ob_itself, + grafPtr); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRActivate(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = HRActivate(_self->ob_itself); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRDeactivate(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = HRDeactivate(_self->ob_itself); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRDraw(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + RgnHandle updateRgnH; + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &updateRgnH)) + return NULL; + _err = HRDraw(_self->ob_itself, + updateRgnH); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRSetRenderingRect(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + Rect renderingRect; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetRect, &renderingRect)) + return NULL; + _err = HRSetRenderingRect(_self->ob_itself, + &renderingRect); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRGetRenderedImageSize(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + Point renderingSize; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = HRGetRenderedImageSize(_self->ob_itself, + &renderingSize); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildPoint, renderingSize); + return _res; +} + +static PyObject *HtmlObj_HRScrollToLocation(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + Point location; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = HRScrollToLocation(_self->ob_itself, + &location); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildPoint, location); + return _res; +} + +static PyObject *HtmlObj_HRForceQuickdraw(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + Boolean forceQuickdraw; + if (!PyArg_ParseTuple(_args, "b", + &forceQuickdraw)) + return NULL; + _err = HRForceQuickdraw(_self->ob_itself, + forceQuickdraw); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRSetScrollbarState(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + HRScrollbarState hScrollbarState; + HRScrollbarState vScrollbarState; + if (!PyArg_ParseTuple(_args, "hh", + &hScrollbarState, + &vScrollbarState)) + return NULL; + _err = HRSetScrollbarState(_self->ob_itself, + hScrollbarState, + vScrollbarState); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRSetDrawBorder(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + Boolean drawBorder; + if (!PyArg_ParseTuple(_args, "b", + &drawBorder)) + return NULL; + _err = HRSetDrawBorder(_self->ob_itself, + drawBorder); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRSetGrowboxCutout(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + Boolean allowCutout; + if (!PyArg_ParseTuple(_args, "b", + &allowCutout)) + return NULL; + _err = HRSetGrowboxCutout(_self->ob_itself, + allowCutout); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRGoToFile(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + FSSpec fsspec; + Boolean addToHistory; + Boolean forceRefresh; + if (!PyArg_ParseTuple(_args, "O&bb", + PyMac_GetFSSpec, &fsspec, + &addToHistory, + &forceRefresh)) + return NULL; + _err = HRGoToFile(_self->ob_itself, + &fsspec, + addToHistory, + forceRefresh); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRGoToURL(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + char * url; + Boolean addToHistory; + Boolean forceRefresh; + if (!PyArg_ParseTuple(_args, "sbb", + &url, + &addToHistory, + &forceRefresh)) + return NULL; + _err = HRGoToURL(_self->ob_itself, + url, + addToHistory, + forceRefresh); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRGoToAnchor(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + char * anchorName; + if (!PyArg_ParseTuple(_args, "s", + &anchorName)) + return NULL; + _err = HRGoToAnchor(_self->ob_itself, + anchorName); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRGoToPtr(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + char *buffer__in__; + long buffer__len__; + int buffer__in_len__; + Boolean addToHistory; + Boolean forceRefresh; + if (!PyArg_ParseTuple(_args, "s#bb", + &buffer__in__, &buffer__in_len__, + &addToHistory, + &forceRefresh)) + return NULL; + buffer__len__ = buffer__in_len__; + _err = HRGoToPtr(_self->ob_itself, + buffer__in__, buffer__len__, + addToHistory, + forceRefresh); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + buffer__error__: ; + return _res; +} + +static PyObject *HtmlObj_HRGetRootURL(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + Handle rootURLH; + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &rootURLH)) + return NULL; + _err = HRGetRootURL(_self->ob_itself, + rootURLH); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRGetBaseURL(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + Handle baseURLH; + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &baseURLH)) + return NULL; + _err = HRGetBaseURL(_self->ob_itself, + baseURLH); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRGetHTMLURL(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + Handle HTMLURLH; + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &HTMLURLH)) + return NULL; + _err = HRGetHTMLURL(_self->ob_itself, + HTMLURLH); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRGetTitle(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + StringPtr title; + if (!PyArg_ParseTuple(_args, "s", + &title)) + return NULL; + _err = HRGetTitle(_self->ob_itself, + title); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRGetHTMLFile(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + FSSpec fsspec; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = HRGetHTMLFile(_self->ob_itself, + &fsspec); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildFSSpec, fsspec); + return _res; +} + +static PyObject *HtmlObj_HRUnregisterWasURLVisitedUPP(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + HRUnregisterWasURLVisitedUPP(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRUnregisterNewURLUPP(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + HRUnregisterNewURLUPP(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *HtmlObj_HRUnregisterURLToFSSpecUPP(_self, _args) + HtmlObjectObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + HRUnregisterURLToFSSpecUPP(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyMethodDef HtmlObj_methods[] = { + {"HRDisposeReference", (PyCFunction)HtmlObj_HRDisposeReference, 1, + "() -> None"}, + {"HRSetGrafPtr", (PyCFunction)HtmlObj_HRSetGrafPtr, 1, + "(GrafPtr grafPtr) -> None"}, + {"HRActivate", (PyCFunction)HtmlObj_HRActivate, 1, + "() -> None"}, + {"HRDeactivate", (PyCFunction)HtmlObj_HRDeactivate, 1, + "() -> None"}, + {"HRDraw", (PyCFunction)HtmlObj_HRDraw, 1, + "(RgnHandle updateRgnH) -> None"}, + {"HRSetRenderingRect", (PyCFunction)HtmlObj_HRSetRenderingRect, 1, + "(Rect renderingRect) -> None"}, + {"HRGetRenderedImageSize", (PyCFunction)HtmlObj_HRGetRenderedImageSize, 1, + "() -> (Point renderingSize)"}, + {"HRScrollToLocation", (PyCFunction)HtmlObj_HRScrollToLocation, 1, + "() -> (Point location)"}, + {"HRForceQuickdraw", (PyCFunction)HtmlObj_HRForceQuickdraw, 1, + "(Boolean forceQuickdraw) -> None"}, + {"HRSetScrollbarState", (PyCFunction)HtmlObj_HRSetScrollbarState, 1, + "(HRScrollbarState hScrollbarState, HRScrollbarState vScrollbarState) -> None"}, + {"HRSetDrawBorder", (PyCFunction)HtmlObj_HRSetDrawBorder, 1, + "(Boolean drawBorder) -> None"}, + {"HRSetGrowboxCutout", (PyCFunction)HtmlObj_HRSetGrowboxCutout, 1, + "(Boolean allowCutout) -> None"}, + {"HRGoToFile", (PyCFunction)HtmlObj_HRGoToFile, 1, + "(FSSpec fsspec, Boolean addToHistory, Boolean forceRefresh) -> None"}, + {"HRGoToURL", (PyCFunction)HtmlObj_HRGoToURL, 1, + "(char * url, Boolean addToHistory, Boolean forceRefresh) -> None"}, + {"HRGoToAnchor", (PyCFunction)HtmlObj_HRGoToAnchor, 1, + "(char * anchorName) -> None"}, + {"HRGoToPtr", (PyCFunction)HtmlObj_HRGoToPtr, 1, + "(Buffer buffer, Boolean addToHistory, Boolean forceRefresh) -> None"}, + {"HRGetRootURL", (PyCFunction)HtmlObj_HRGetRootURL, 1, + "(Handle rootURLH) -> None"}, + {"HRGetBaseURL", (PyCFunction)HtmlObj_HRGetBaseURL, 1, + "(Handle baseURLH) -> None"}, + {"HRGetHTMLURL", (PyCFunction)HtmlObj_HRGetHTMLURL, 1, + "(Handle HTMLURLH) -> None"}, + {"HRGetTitle", (PyCFunction)HtmlObj_HRGetTitle, 1, + "(StringPtr title) -> None"}, + {"HRGetHTMLFile", (PyCFunction)HtmlObj_HRGetHTMLFile, 1, + "() -> (FSSpec fsspec)"}, + {"HRUnregisterWasURLVisitedUPP", (PyCFunction)HtmlObj_HRUnregisterWasURLVisitedUPP, 1, + "() -> None"}, + {"HRUnregisterNewURLUPP", (PyCFunction)HtmlObj_HRUnregisterNewURLUPP, 1, + "() -> None"}, + {"HRUnregisterURLToFSSpecUPP", (PyCFunction)HtmlObj_HRUnregisterURLToFSSpecUPP, 1, + "() -> None"}, + {NULL, NULL, 0} +}; + +PyMethodChain HtmlObj_chain = { HtmlObj_methods, NULL }; + +static PyObject *HtmlObj_getattr(self, name) + HtmlObjectObject *self; + char *name; +{ + return Py_FindMethodInChain(&HtmlObj_chain, (PyObject *)self, name); +} + +#define HtmlObj_setattr NULL + +#define HtmlObj_compare NULL + +#define HtmlObj_repr NULL + +#define HtmlObj_hash NULL + +PyTypeObject HtmlObject_Type = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "HtmlObject", /*tp_name*/ + sizeof(HtmlObjectObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) HtmlObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc) HtmlObj_getattr, /*tp_getattr*/ + (setattrfunc) HtmlObj_setattr, /*tp_setattr*/ + (cmpfunc) HtmlObj_compare, /*tp_compare*/ + (reprfunc) HtmlObj_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) HtmlObj_hash, /*tp_hash*/ +}; + +/* ------------------- End object type HtmlObject ------------------- */ + + +static PyObject *Html_HRGetHTMLRenderingLibVersion(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + NumVersion returnVers; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = HRGetHTMLRenderingLibVersion(&returnVers); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildNumVersion, returnVers); + return _res; +} + +static PyObject *Html_HRNewReference(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + HRReference hrRef; + OSType rendererType; + GrafPtr grafPtr; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetOSType, &rendererType, + GrafObj_Convert, &grafPtr)) + return NULL; + _err = HRNewReference(&hrRef, + rendererType, + grafPtr); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + HtmlObj_New, hrRef); + return _res; +} + +static PyObject *Html_HRFreeMemory(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + SInt32 _rv; + Size inBytesNeeded; + if (!PyArg_ParseTuple(_args, "l", + &inBytesNeeded)) + return NULL; + _rv = HRFreeMemory(inBytesNeeded); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Html_HRScreenConfigurationChanged(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + HRScreenConfigurationChanged(); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Html_HRIsHREvent(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Boolean _rv; + EventRecord eventRecord; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetEventRecord, &eventRecord)) + return NULL; + _rv = HRIsHREvent(&eventRecord); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *Html_HRUtilCreateFullURL(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + char * rootURL; + char * linkURL; + Handle fullURLH; + if (!PyArg_ParseTuple(_args, "ssO&", + &rootURL, + &linkURL, + ResObj_Convert, &fullURLH)) + return NULL; + _err = HRUtilCreateFullURL(rootURL, + linkURL, + fullURLH); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Html_HRUtilGetFSSpecFromURL(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + char * rootURL; + char * linkURL; + FSSpec destSpec; + if (!PyArg_ParseTuple(_args, "ss", + &rootURL, + &linkURL)) + return NULL; + _err = HRUtilGetFSSpecFromURL(rootURL, + linkURL, + &destSpec); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildFSSpec, destSpec); + return _res; +} + +static PyObject *Html_HRUtilGetURLFromFSSpec(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSStatus _err; + FSSpec fsspec; + Handle urlHandle; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetFSSpec, &fsspec, + ResObj_Convert, &urlHandle)) + return NULL; + _err = HRUtilGetURLFromFSSpec(&fsspec, + urlHandle); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyMethodDef Html_methods[] = { + {"HRGetHTMLRenderingLibVersion", (PyCFunction)Html_HRGetHTMLRenderingLibVersion, 1, + "() -> (NumVersion returnVers)"}, + {"HRNewReference", (PyCFunction)Html_HRNewReference, 1, + "(OSType rendererType, GrafPtr grafPtr) -> (HRReference hrRef)"}, + {"HRFreeMemory", (PyCFunction)Html_HRFreeMemory, 1, + "(Size inBytesNeeded) -> (SInt32 _rv)"}, + {"HRScreenConfigurationChanged", (PyCFunction)Html_HRScreenConfigurationChanged, 1, + "() -> None"}, + {"HRIsHREvent", (PyCFunction)Html_HRIsHREvent, 1, + "(EventRecord eventRecord) -> (Boolean _rv)"}, + {"HRUtilCreateFullURL", (PyCFunction)Html_HRUtilCreateFullURL, 1, + "(char * rootURL, char * linkURL, Handle fullURLH) -> None"}, + {"HRUtilGetFSSpecFromURL", (PyCFunction)Html_HRUtilGetFSSpecFromURL, 1, + "(char * rootURL, char * linkURL) -> (FSSpec destSpec)"}, + {"HRUtilGetURLFromFSSpec", (PyCFunction)Html_HRUtilGetURLFromFSSpec, 1, + "(FSSpec fsspec, Handle urlHandle) -> None"}, + {NULL, NULL, 0} +}; + + + + +void initHtmlRender() +{ + PyObject *m; + PyObject *d; + + + + + m = Py_InitModule("HtmlRender", Html_methods); + d = PyModule_GetDict(m); + Html_Error = PyMac_GetOSErrException(); + if (Html_Error == NULL || + PyDict_SetItemString(d, "Error", Html_Error) != 0) + Py_FatalError("can't initialize HtmlRender.Error"); + HtmlObject_Type.ob_type = &PyType_Type; + Py_INCREF(&HtmlObject_Type); + if (PyDict_SetItemString(d, "HtmlObjectType", (PyObject *)&HtmlObject_Type) != 0) + Py_FatalError("can't initialize HtmlObjectType"); +} + +/* ===================== End module HtmlRender ====================== */ + diff --git a/Mac/Modules/htmlrender/htmlscan.py b/Mac/Modules/htmlrender/htmlscan.py new file mode 100644 index 0000000000..ae31c37750 --- /dev/null +++ b/Mac/Modules/htmlrender/htmlscan.py @@ -0,0 +1,61 @@ +# Scan an Apple header file, generating a Python file of generator calls. + +import sys +import os +BGENDIR=os.path.join(sys.prefix, ':Tools:bgen:bgen') +sys.path.append(BGENDIR) + +from scantools import Scanner +from bgenlocations import TOOLBOXDIR + +LONG = "HtmlRendering" +SHORT = "html" +OBJECT = "HRReference" + +def main(): +## input = LONG + ".h" + input = "Macintosh HD:SWdev:Jack:Universal:Interfaces:CIncludes:HTMLRendering.h" + output = SHORT + "gen.py" + defsoutput = TOOLBOXDIR + LONG + ".py" + scanner = MyScanner(input, output, defsoutput) + scanner.scan() + scanner.close() + print "=== Done scanning and generating, now importing the generated code... ===" + exec "import " + SHORT + "support" + print "=== Done. It's up to you to compile it now! ===" + +class MyScanner(Scanner): + + def destination(self, type, name, arglist): + classname = "Function" + listname = "functions" + if arglist: + t, n, m = arglist[0] + if t == OBJECT and m == "InMode": + classname = "Method" + listname = "methods" + return classname, listname + + def makeblacklistnames(self): + return [ + ] + + def makeblacklisttypes(self): + return [ + "HRNewURLUPP", + "HRURLToFSSpecUPP", + "HRWasURLVisitedUPP", + ] + + def makerepairinstructions(self): + return [ + ([('char', '*', 'OutMode'), ('UInt32', '*', 'InMode')], + [('InBuffer', '*', 'InMode')]), + ] + + def writeinitialdefs(self): + self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n") + + +if __name__ == "__main__": + main() diff --git a/Mac/Modules/htmlrender/htmlsupport.py b/Mac/Modules/htmlrender/htmlsupport.py new file mode 100644 index 0000000000..d4547ca92e --- /dev/null +++ b/Mac/Modules/htmlrender/htmlsupport.py @@ -0,0 +1,210 @@ +# This script generates the Dialogs interface for Python. +# It uses the "bgen" package to generate C code. +# It execs the file dlggen.py which contain the function definitions +# (dlggen.py was generated by dlgscan.py, scanning the header file). + +from macsupport import * + +# Create the type objects + +HRReference = OpaqueByValueType("HRReference", "HtmlObj") + +HRScrollbarState = Type("HRScrollbarState", "h") +URLSourceType = Type("URLSourceType", "h") +GrafPtr = OpaqueByValueType("GrafPtr", "GrafObj") +RgnHandle = OpaqueByValueType("RgnHandle", "ResObj") +char_ptr = Type("char *", "s") +StringPtr = Type("StringPtr", "s") + +### An OptHandle is either a handle or None (in case NULL is passed in). +### This is needed for GetDialogItem(). +##OptHandle = OpaqueByValueType("Handle", "OptResObj") +## +##ModalFilterProcPtr = InputOnlyType("PyObject*", "O") +##ModalFilterProcPtr.passInput = lambda name: "NewModalFilterProc(Dlg_PassFilterProc(%s))" % name +##ModalFilterUPP = ModalFilterProcPtr +## +## +##DITLMethod = Type("DITLMethod", "h") +##DialogItemIndex = Type("DialogItemIndex", "h") +##DialogItemType = Type("DialogItemType", "h") +##DialogItemIndexZeroBased = Type("DialogItemIndexZeroBased", "h") +##AlertType = Type("AlertType", "h") +##StringPtr = Str255 +##EventMask = Type("EventMask", "h") +## +includestuff = includestuff + """ +#include +""" +## +###ifndef HAVE_UNIVERSAL_HEADERS +###define NewModalFilterProc(x) (x) +###endif +## +###define resNotFound -192 /* Can't include because of Python's "errors.h" */ +## +##/* XXX Shouldn't this be a stack? */ +##static PyObject *Dlg_FilterProc_callback = NULL; +## +##static PyObject *DlgObj_New(DialogPtr); /* Forward */ +## +##static pascal Boolean Dlg_UnivFilterProc(DialogPtr dialog, +## EventRecord *event, +## short *itemHit) +##{ +## Boolean rv; +## PyObject *args, *res; +## PyObject *callback = Dlg_FilterProc_callback; +## if (callback == NULL) +## return 0; /* Default behavior */ +## Dlg_FilterProc_callback = NULL; /* We'll restore it when call successful */ +## args = Py_BuildValue("O&O&", WinObj_WhichWindow, dialog, PyMac_BuildEventRecord, event); +## if (args == NULL) +## res = NULL; +## else { +## res = PyEval_CallObject(callback, args); +## Py_DECREF(args); +## } +## if (res == NULL) { +## PySys_WriteStderr("Exception in Dialog Filter\\n"); +## PyErr_Print(); +## *itemHit = -1; /* Fake return item */ +## return 1; /* We handled it */ +## } +## else { +## Dlg_FilterProc_callback = callback; +## if (PyInt_Check(res)) { +## *itemHit = PyInt_AsLong(res); +## rv = 1; +## } +## else +## rv = PyObject_IsTrue(res); +## } +## Py_DECREF(res); +## return rv; +##} +## +##static ModalFilterProcPtr +##Dlg_PassFilterProc(PyObject *callback) +##{ +## PyObject *tmp = Dlg_FilterProc_callback; +## Dlg_FilterProc_callback = NULL; +## if (callback == Py_None) { +## Py_XDECREF(tmp); +## return NULL; +## } +## Py_INCREF(callback); +## Dlg_FilterProc_callback = callback; +## Py_XDECREF(tmp); +## return &Dlg_UnivFilterProc; +##} +## +##static PyObject *Dlg_UserItemProc_callback = NULL; +## +##static pascal void Dlg_UnivUserItemProc(DialogPtr dialog, +## short item) +##{ +## PyObject *args, *res; +## +## if (Dlg_UserItemProc_callback == NULL) +## return; /* Default behavior */ +## Dlg_FilterProc_callback = NULL; /* We'll restore it when call successful */ +## args = Py_BuildValue("O&h", WinObj_WhichWindow, dialog, item); +## if (args == NULL) +## res = NULL; +## else { +## res = PyEval_CallObject(Dlg_UserItemProc_callback, args); +## Py_DECREF(args); +## } +## if (res == NULL) { +## PySys_WriteStderr("Exception in Dialog UserItem proc\\n"); +## PyErr_Print(); +## } +## Py_XDECREF(res); +## return; +##} +## +##extern PyMethodChain WinObj_chain; +##""" +## + +# Define a class which specializes our object definition +class MyObjectDefinition(GlobalObjectDefinition): + pass +## def __init__(self, name, prefix = None, itselftype = None): +## GlobalObjectDefinition.__init__(self, name, prefix, itselftype) +## self.basechain = "&WinObj_chain" +## def outputInitStructMembers(self): +## GlobalObjectDefinition.outputInitStructMembers(self) +## Output("SetWRefCon(itself, (long)it);") +## def outputCheckNewArg(self): +## Output("if (itself == NULL) return Py_None;") +## def outputCheckConvertArg(self): +## Output("if (v == Py_None) { *p_itself = NULL; return 1; }") +## Output("if (PyInt_Check(v)) { *p_itself = (DialogPtr)PyInt_AsLong(v);") +## Output(" return 1; }") +## def outputFreeIt(self, itselfname): +## Output("DisposeDialog(%s);", itselfname) + +# Create the generator groups and link them +module = MacModule('HtmlRender', 'Html', includestuff, finalstuff, initstuff) +object = MyObjectDefinition('HtmlObject', 'HtmlObj', 'HRReference') +module.addobject(object) + +# Create the generator classes used to populate the lists +Function = OSErrFunctionGenerator +Method = OSErrMethodGenerator + +# Create and populate the lists +functions = [] +methods = [] +execfile("htmlgen.py") + +# add the populated lists to the generator groups +for f in functions: module.add(f) +for f in methods: object.add(f) + +### Some methods that are currently macro's in C, but will be real routines +### in MacOS 8. +## +##f = Method(ExistingDialogPtr, 'GetDialogWindow', (DialogRef, 'dialog', InMode)) +##object.add(f) +##f = Method(SInt16, 'GetDialogDefaultItem', (DialogRef, 'dialog', InMode)) +##object.add(f) +##f = Method(SInt16, 'GetDialogCancelItem', (DialogRef, 'dialog', InMode)) +##object.add(f) +##f = Method(SInt16, 'GetDialogKeyboardFocusItem', (DialogRef, 'dialog', InMode)) +##object.add(f) +##f = Method(void, 'SetGrafPortOfDialog', (DialogRef, 'dialog', InMode)) +##object.add(f) +## +##setuseritembody = """ +## PyObject *new = NULL; +## +## +## if (!PyArg_ParseTuple(_args, "|O", &new)) +## return NULL; +## +## if (Dlg_UserItemProc_callback && new && new != Py_None) { +## PyErr_SetString(Dlg_Error, "Another UserItemProc is already installed"); +## return NULL; +## } +## +## if (new == Py_None) { +## new = NULL; +## _res = Py_None; +## Py_INCREF(Py_None); +## } else { +## Py_INCREF(new); +## _res = Py_BuildValue("O&", ResObj_New, (Handle)NewUserItemProc(Dlg_UnivUserItemProc)); +## } +## +## Dlg_UserItemProc_callback = new; +## return _res; +##""" +##f = ManualGenerator("SetUserItemHandler", setuseritembody) +##module.add(f) + +# generate output +SetOutputFileName('HtmlRendermodule.c') +module.generate() -- 2.50.0