| |
| /* ========================== Module _Dlg =========================== */ |
| |
| #include "Python.h" |
| |
| #ifndef __LP64__ |
| |
| |
| #include "pymactoolbox.h" |
| |
| /* Macro to test whether a weak-loaded CFM function exists */ |
| #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\ |
| PyErr_SetString(PyExc_NotImplementedError, \ |
| "Not available in this shared library/OS version"); \ |
| return NULL; \ |
| }} while(0) |
| |
| |
| #include <Carbon/Carbon.h> |
| |
| #ifdef USE_TOOLBOX_OBJECT_GLUE |
| extern PyObject *_DlgObj_New(DialogRef); |
| extern PyObject *_DlgObj_WhichDialog(DialogRef); |
| extern int _DlgObj_Convert(PyObject *, DialogRef *); |
| |
| #define DlgObj_New _DlgObj_New |
| #define DlgObj_WhichDialog _DlgObj_WhichDialog |
| #define DlgObj_Convert _DlgObj_Convert |
| #endif |
| |
| /* XXX Shouldn't this be a stack? */ |
| static PyObject *Dlg_FilterProc_callback = NULL; |
| |
| 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&", DlgObj_WhichDialog, 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 ModalFilterUPP |
| Dlg_PassFilterProc(PyObject *callback) |
| { |
| PyObject *tmp = Dlg_FilterProc_callback; |
| static ModalFilterUPP UnivFilterUpp = NULL; |
| |
| Dlg_FilterProc_callback = NULL; |
| if (callback == Py_None) { |
| Py_XDECREF(tmp); |
| return NULL; |
| } |
| Py_INCREF(callback); |
| Dlg_FilterProc_callback = callback; |
| Py_XDECREF(tmp); |
| if ( UnivFilterUpp == NULL ) |
| UnivFilterUpp = NewModalFilterUPP(&Dlg_UnivFilterProc); |
| return UnivFilterUpp; |
| } |
| |
| 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", DlgObj_WhichDialog, 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; |
| } |
| |
| #if 0 |
| /* |
| ** Treating DialogObjects as WindowObjects is (I think) illegal under Carbon. |
| ** However, as they are still identical under MacOS9 Carbon this is a problem, even |
| ** if we neatly call GetDialogWindow() at the right places: there's one refcon field |
| ** and it points to the DialogObject, so WinObj_WhichWindow will smartly return the |
| ** dialog object, and therefore we still don't have a WindowObject. |
| ** I'll leave the chaining code in place for now, with this comment to warn the |
| ** unsuspecting victims (i.e. me, probably, in a few weeks:-) |
| */ |
| extern PyMethodChain WinObj_chain; |
| #endif |
| |
| static PyObject *Dlg_Error; |
| |
| /* ----------------------- Object type Dialog ----------------------- */ |
| |
| PyTypeObject Dialog_Type; |
| |
| #define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type || PyObject_TypeCheck((x), &Dialog_Type)) |
| |
| typedef struct DialogObject { |
| PyObject_HEAD |
| DialogPtr ob_itself; |
| } DialogObject; |
| |
| PyObject *DlgObj_New(DialogPtr itself) |
| { |
| DialogObject *it; |
| if (itself == NULL) { Py_INCREF(Py_None); return Py_None; } |
| it = PyObject_NEW(DialogObject, &Dialog_Type); |
| if (it == NULL) return NULL; |
| it->ob_itself = itself; |
| SetWRefCon(GetDialogWindow(itself), (long)it); |
| return (PyObject *)it; |
| } |
| |
| int DlgObj_Convert(PyObject *v, DialogPtr *p_itself) |
| { |
| if (v == Py_None) { *p_itself = NULL; return 1; } |
| if (PyInt_Check(v)) { *p_itself = (DialogPtr)PyInt_AsLong(v); |
| return 1; } |
| if (!DlgObj_Check(v)) |
| { |
| PyErr_SetString(PyExc_TypeError, "Dialog required"); |
| return 0; |
| } |
| *p_itself = ((DialogObject *)v)->ob_itself; |
| return 1; |
| } |
| |
| static void DlgObj_dealloc(DialogObject *self) |
| { |
| DisposeDialog(self->ob_itself); |
| self->ob_type->tp_free((PyObject *)self); |
| } |
| |
| static PyObject *DlgObj_DrawDialog(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef DrawDialog |
| PyMac_PRECHECK(DrawDialog); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| DrawDialog(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_UpdateDialog(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle updateRgn; |
| #ifndef UpdateDialog |
| PyMac_PRECHECK(UpdateDialog); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &updateRgn)) |
| return NULL; |
| UpdateDialog(_self->ob_itself, |
| updateRgn); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_HideDialogItem(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogItemIndex itemNo; |
| #ifndef HideDialogItem |
| PyMac_PRECHECK(HideDialogItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &itemNo)) |
| return NULL; |
| HideDialogItem(_self->ob_itself, |
| itemNo); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_ShowDialogItem(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogItemIndex itemNo; |
| #ifndef ShowDialogItem |
| PyMac_PRECHECK(ShowDialogItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &itemNo)) |
| return NULL; |
| ShowDialogItem(_self->ob_itself, |
| itemNo); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_FindDialogItem(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogItemIndexZeroBased _rv; |
| Point thePt; |
| #ifndef FindDialogItem |
| PyMac_PRECHECK(FindDialogItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetPoint, &thePt)) |
| return NULL; |
| _rv = FindDialogItem(_self->ob_itself, |
| thePt); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *DlgObj_DialogCut(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef DialogCut |
| PyMac_PRECHECK(DialogCut); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| DialogCut(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_DialogPaste(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef DialogPaste |
| PyMac_PRECHECK(DialogPaste); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| DialogPaste(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_DialogCopy(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef DialogCopy |
| PyMac_PRECHECK(DialogCopy); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| DialogCopy(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_DialogDelete(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef DialogDelete |
| PyMac_PRECHECK(DialogDelete); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| DialogDelete(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_GetDialogItem(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogItemIndex itemNo; |
| DialogItemType itemType; |
| Handle item; |
| Rect box; |
| #ifndef GetDialogItem |
| PyMac_PRECHECK(GetDialogItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &itemNo)) |
| return NULL; |
| GetDialogItem(_self->ob_itself, |
| itemNo, |
| &itemType, |
| &item, |
| &box); |
| _res = Py_BuildValue("hO&O&", |
| itemType, |
| OptResObj_New, item, |
| PyMac_BuildRect, &box); |
| return _res; |
| } |
| |
| static PyObject *DlgObj_SetDialogItem(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogItemIndex itemNo; |
| DialogItemType itemType; |
| Handle item; |
| Rect box; |
| #ifndef SetDialogItem |
| PyMac_PRECHECK(SetDialogItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hhO&O&", |
| &itemNo, |
| &itemType, |
| ResObj_Convert, &item, |
| PyMac_GetRect, &box)) |
| return NULL; |
| SetDialogItem(_self->ob_itself, |
| itemNo, |
| itemType, |
| item, |
| &box); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_SelectDialogItemText(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogItemIndex itemNo; |
| SInt16 strtSel; |
| SInt16 endSel; |
| #ifndef SelectDialogItemText |
| PyMac_PRECHECK(SelectDialogItemText); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hhh", |
| &itemNo, |
| &strtSel, |
| &endSel)) |
| return NULL; |
| SelectDialogItemText(_self->ob_itself, |
| itemNo, |
| strtSel, |
| endSel); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_AppendDITL(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Handle theHandle; |
| DITLMethod method; |
| #ifndef AppendDITL |
| PyMac_PRECHECK(AppendDITL); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&h", |
| ResObj_Convert, &theHandle, |
| &method)) |
| return NULL; |
| AppendDITL(_self->ob_itself, |
| theHandle, |
| method); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_CountDITL(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogItemIndex _rv; |
| #ifndef CountDITL |
| PyMac_PRECHECK(CountDITL); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = CountDITL(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *DlgObj_ShortenDITL(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogItemIndex numberItems; |
| #ifndef ShortenDITL |
| PyMac_PRECHECK(ShortenDITL); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &numberItems)) |
| return NULL; |
| ShortenDITL(_self->ob_itself, |
| numberItems); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_InsertDialogItem(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| DialogItemIndex afterItem; |
| DialogItemType itemType; |
| Handle itemHandle; |
| Rect box; |
| #ifndef InsertDialogItem |
| PyMac_PRECHECK(InsertDialogItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hhO&O&", |
| &afterItem, |
| &itemType, |
| ResObj_Convert, &itemHandle, |
| PyMac_GetRect, &box)) |
| return NULL; |
| _err = InsertDialogItem(_self->ob_itself, |
| afterItem, |
| itemType, |
| itemHandle, |
| &box); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_RemoveDialogItems(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| DialogItemIndex itemNo; |
| DialogItemIndex amountToRemove; |
| Boolean disposeItemData; |
| #ifndef RemoveDialogItems |
| PyMac_PRECHECK(RemoveDialogItems); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hhb", |
| &itemNo, |
| &amountToRemove, |
| &disposeItemData)) |
| return NULL; |
| _err = RemoveDialogItems(_self->ob_itself, |
| itemNo, |
| amountToRemove, |
| disposeItemData); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_StdFilterProc(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| EventRecord event; |
| DialogItemIndex itemHit; |
| #ifndef StdFilterProc |
| PyMac_PRECHECK(StdFilterProc); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&h", |
| PyMac_GetEventRecord, &event, |
| &itemHit)) |
| return NULL; |
| _rv = StdFilterProc(_self->ob_itself, |
| &event, |
| &itemHit); |
| _res = Py_BuildValue("bO&h", |
| _rv, |
| PyMac_BuildEventRecord, &event, |
| itemHit); |
| return _res; |
| } |
| |
| static PyObject *DlgObj_SetDialogDefaultItem(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| DialogItemIndex newItem; |
| #ifndef SetDialogDefaultItem |
| PyMac_PRECHECK(SetDialogDefaultItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &newItem)) |
| return NULL; |
| _err = SetDialogDefaultItem(_self->ob_itself, |
| newItem); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_SetDialogCancelItem(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| DialogItemIndex newItem; |
| #ifndef SetDialogCancelItem |
| PyMac_PRECHECK(SetDialogCancelItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &newItem)) |
| return NULL; |
| _err = SetDialogCancelItem(_self->ob_itself, |
| newItem); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_SetDialogTracksCursor(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Boolean tracks; |
| #ifndef SetDialogTracksCursor |
| PyMac_PRECHECK(SetDialogTracksCursor); |
| #endif |
| if (!PyArg_ParseTuple(_args, "b", |
| &tracks)) |
| return NULL; |
| _err = SetDialogTracksCursor(_self->ob_itself, |
| tracks); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_AutoSizeDialog(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| #ifndef AutoSizeDialog |
| PyMac_PRECHECK(AutoSizeDialog); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = AutoSizeDialog(_self->ob_itself); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_GetDialogItemAsControl(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 inItemNo; |
| ControlHandle outControl; |
| #ifndef GetDialogItemAsControl |
| PyMac_PRECHECK(GetDialogItemAsControl); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &inItemNo)) |
| return NULL; |
| _err = GetDialogItemAsControl(_self->ob_itself, |
| inItemNo, |
| &outControl); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CtlObj_New, outControl); |
| return _res; |
| } |
| |
| static PyObject *DlgObj_MoveDialogItem(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 inItemNo; |
| SInt16 inHoriz; |
| SInt16 inVert; |
| #ifndef MoveDialogItem |
| PyMac_PRECHECK(MoveDialogItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hhh", |
| &inItemNo, |
| &inHoriz, |
| &inVert)) |
| return NULL; |
| _err = MoveDialogItem(_self->ob_itself, |
| inItemNo, |
| inHoriz, |
| inVert); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_SizeDialogItem(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 inItemNo; |
| SInt16 inWidth; |
| SInt16 inHeight; |
| #ifndef SizeDialogItem |
| PyMac_PRECHECK(SizeDialogItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hhh", |
| &inItemNo, |
| &inWidth, |
| &inHeight)) |
| return NULL; |
| _err = SizeDialogItem(_self->ob_itself, |
| inItemNo, |
| inWidth, |
| inHeight); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_AppendDialogItemList(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 ditlID; |
| DITLMethod method; |
| #ifndef AppendDialogItemList |
| PyMac_PRECHECK(AppendDialogItemList); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hh", |
| &ditlID, |
| &method)) |
| return NULL; |
| _err = AppendDialogItemList(_self->ob_itself, |
| ditlID, |
| method); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_SetDialogTimeout(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| SInt16 inButtonToPress; |
| UInt32 inSecondsToWait; |
| #ifndef SetDialogTimeout |
| PyMac_PRECHECK(SetDialogTimeout); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hl", |
| &inButtonToPress, |
| &inSecondsToWait)) |
| return NULL; |
| _err = SetDialogTimeout(_self->ob_itself, |
| inButtonToPress, |
| inSecondsToWait); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_GetDialogTimeout(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| SInt16 outButtonToPress; |
| UInt32 outSecondsToWait; |
| UInt32 outSecondsRemaining; |
| #ifndef GetDialogTimeout |
| PyMac_PRECHECK(GetDialogTimeout); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetDialogTimeout(_self->ob_itself, |
| &outButtonToPress, |
| &outSecondsToWait, |
| &outSecondsRemaining); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("hll", |
| outButtonToPress, |
| outSecondsToWait, |
| outSecondsRemaining); |
| return _res; |
| } |
| |
| static PyObject *DlgObj_SetModalDialogEventMask(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| EventMask inMask; |
| #ifndef SetModalDialogEventMask |
| PyMac_PRECHECK(SetModalDialogEventMask); |
| #endif |
| if (!PyArg_ParseTuple(_args, "H", |
| &inMask)) |
| return NULL; |
| _err = SetModalDialogEventMask(_self->ob_itself, |
| inMask); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_GetModalDialogEventMask(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| EventMask outMask; |
| #ifndef GetModalDialogEventMask |
| PyMac_PRECHECK(GetModalDialogEventMask); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetModalDialogEventMask(_self->ob_itself, |
| &outMask); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("H", |
| outMask); |
| return _res; |
| } |
| |
| static PyObject *DlgObj_GetDialogWindow(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| WindowPtr _rv; |
| #ifndef GetDialogWindow |
| PyMac_PRECHECK(GetDialogWindow); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetDialogWindow(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| WinObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *DlgObj_GetDialogTextEditHandle(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TEHandle _rv; |
| #ifndef GetDialogTextEditHandle |
| PyMac_PRECHECK(GetDialogTextEditHandle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetDialogTextEditHandle(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *DlgObj_GetDialogDefaultItem(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt16 _rv; |
| #ifndef GetDialogDefaultItem |
| PyMac_PRECHECK(GetDialogDefaultItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetDialogDefaultItem(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *DlgObj_GetDialogCancelItem(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt16 _rv; |
| #ifndef GetDialogCancelItem |
| PyMac_PRECHECK(GetDialogCancelItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetDialogCancelItem(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *DlgObj_GetDialogKeyboardFocusItem(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt16 _rv; |
| #ifndef GetDialogKeyboardFocusItem |
| PyMac_PRECHECK(GetDialogKeyboardFocusItem); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetDialogKeyboardFocusItem(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *DlgObj_SetPortDialogPort(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef SetPortDialogPort |
| PyMac_PRECHECK(SetPortDialogPort); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| SetPortDialogPort(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *DlgObj_GetDialogPort(DialogObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| CGrafPtr _rv; |
| #ifndef GetDialogPort |
| PyMac_PRECHECK(GetDialogPort); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetDialogPort(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| GrafObj_New, _rv); |
| return _res; |
| } |
| |
| static PyMethodDef DlgObj_methods[] = { |
| {"DrawDialog", (PyCFunction)DlgObj_DrawDialog, 1, |
| PyDoc_STR("() -> None")}, |
| {"UpdateDialog", (PyCFunction)DlgObj_UpdateDialog, 1, |
| PyDoc_STR("(RgnHandle updateRgn) -> None")}, |
| {"HideDialogItem", (PyCFunction)DlgObj_HideDialogItem, 1, |
| PyDoc_STR("(DialogItemIndex itemNo) -> None")}, |
| {"ShowDialogItem", (PyCFunction)DlgObj_ShowDialogItem, 1, |
| PyDoc_STR("(DialogItemIndex itemNo) -> None")}, |
| {"FindDialogItem", (PyCFunction)DlgObj_FindDialogItem, 1, |
| PyDoc_STR("(Point thePt) -> (DialogItemIndexZeroBased _rv)")}, |
| {"DialogCut", (PyCFunction)DlgObj_DialogCut, 1, |
| PyDoc_STR("() -> None")}, |
| {"DialogPaste", (PyCFunction)DlgObj_DialogPaste, 1, |
| PyDoc_STR("() -> None")}, |
| {"DialogCopy", (PyCFunction)DlgObj_DialogCopy, 1, |
| PyDoc_STR("() -> None")}, |
| {"DialogDelete", (PyCFunction)DlgObj_DialogDelete, 1, |
| PyDoc_STR("() -> None")}, |
| {"GetDialogItem", (PyCFunction)DlgObj_GetDialogItem, 1, |
| PyDoc_STR("(DialogItemIndex itemNo) -> (DialogItemType itemType, Handle item, Rect box)")}, |
| {"SetDialogItem", (PyCFunction)DlgObj_SetDialogItem, 1, |
| PyDoc_STR("(DialogItemIndex itemNo, DialogItemType itemType, Handle item, Rect box) -> None")}, |
| {"SelectDialogItemText", (PyCFunction)DlgObj_SelectDialogItemText, 1, |
| PyDoc_STR("(DialogItemIndex itemNo, SInt16 strtSel, SInt16 endSel) -> None")}, |
| {"AppendDITL", (PyCFunction)DlgObj_AppendDITL, 1, |
| PyDoc_STR("(Handle theHandle, DITLMethod method) -> None")}, |
| {"CountDITL", (PyCFunction)DlgObj_CountDITL, 1, |
| PyDoc_STR("() -> (DialogItemIndex _rv)")}, |
| {"ShortenDITL", (PyCFunction)DlgObj_ShortenDITL, 1, |
| PyDoc_STR("(DialogItemIndex numberItems) -> None")}, |
| {"InsertDialogItem", (PyCFunction)DlgObj_InsertDialogItem, 1, |
| PyDoc_STR("(DialogItemIndex afterItem, DialogItemType itemType, Handle itemHandle, Rect box) -> None")}, |
| {"RemoveDialogItems", (PyCFunction)DlgObj_RemoveDialogItems, 1, |
| PyDoc_STR("(DialogItemIndex itemNo, DialogItemIndex amountToRemove, Boolean disposeItemData) -> None")}, |
| {"StdFilterProc", (PyCFunction)DlgObj_StdFilterProc, 1, |
| PyDoc_STR("(EventRecord event, DialogItemIndex itemHit) -> (Boolean _rv, EventRecord event, DialogItemIndex itemHit)")}, |
| {"SetDialogDefaultItem", (PyCFunction)DlgObj_SetDialogDefaultItem, 1, |
| PyDoc_STR("(DialogItemIndex newItem) -> None")}, |
| {"SetDialogCancelItem", (PyCFunction)DlgObj_SetDialogCancelItem, 1, |
| PyDoc_STR("(DialogItemIndex newItem) -> None")}, |
| {"SetDialogTracksCursor", (PyCFunction)DlgObj_SetDialogTracksCursor, 1, |
| PyDoc_STR("(Boolean tracks) -> None")}, |
| {"AutoSizeDialog", (PyCFunction)DlgObj_AutoSizeDialog, 1, |
| PyDoc_STR("() -> None")}, |
| {"GetDialogItemAsControl", (PyCFunction)DlgObj_GetDialogItemAsControl, 1, |
| PyDoc_STR("(SInt16 inItemNo) -> (ControlHandle outControl)")}, |
| {"MoveDialogItem", (PyCFunction)DlgObj_MoveDialogItem, 1, |
| PyDoc_STR("(SInt16 inItemNo, SInt16 inHoriz, SInt16 inVert) -> None")}, |
| {"SizeDialogItem", (PyCFunction)DlgObj_SizeDialogItem, 1, |
| PyDoc_STR("(SInt16 inItemNo, SInt16 inWidth, SInt16 inHeight) -> None")}, |
| {"AppendDialogItemList", (PyCFunction)DlgObj_AppendDialogItemList, 1, |
| PyDoc_STR("(SInt16 ditlID, DITLMethod method) -> None")}, |
| {"SetDialogTimeout", (PyCFunction)DlgObj_SetDialogTimeout, 1, |
| PyDoc_STR("(SInt16 inButtonToPress, UInt32 inSecondsToWait) -> None")}, |
| {"GetDialogTimeout", (PyCFunction)DlgObj_GetDialogTimeout, 1, |
| PyDoc_STR("() -> (SInt16 outButtonToPress, UInt32 outSecondsToWait, UInt32 outSecondsRemaining)")}, |
| {"SetModalDialogEventMask", (PyCFunction)DlgObj_SetModalDialogEventMask, 1, |
| PyDoc_STR("(EventMask inMask) -> None")}, |
| {"GetModalDialogEventMask", (PyCFunction)DlgObj_GetModalDialogEventMask, 1, |
| PyDoc_STR("() -> (EventMask outMask)")}, |
| {"GetDialogWindow", (PyCFunction)DlgObj_GetDialogWindow, 1, |
| PyDoc_STR("() -> (WindowPtr _rv)")}, |
| {"GetDialogTextEditHandle", (PyCFunction)DlgObj_GetDialogTextEditHandle, 1, |
| PyDoc_STR("() -> (TEHandle _rv)")}, |
| {"GetDialogDefaultItem", (PyCFunction)DlgObj_GetDialogDefaultItem, 1, |
| PyDoc_STR("() -> (SInt16 _rv)")}, |
| {"GetDialogCancelItem", (PyCFunction)DlgObj_GetDialogCancelItem, 1, |
| PyDoc_STR("() -> (SInt16 _rv)")}, |
| {"GetDialogKeyboardFocusItem", (PyCFunction)DlgObj_GetDialogKeyboardFocusItem, 1, |
| PyDoc_STR("() -> (SInt16 _rv)")}, |
| {"SetPortDialogPort", (PyCFunction)DlgObj_SetPortDialogPort, 1, |
| PyDoc_STR("() -> None")}, |
| {"GetDialogPort", (PyCFunction)DlgObj_GetDialogPort, 1, |
| PyDoc_STR("() -> (CGrafPtr _rv)")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define DlgObj_getsetlist NULL |
| |
| |
| static int DlgObj_compare(DialogObject *self, DialogObject *other) |
| { |
| if ( self->ob_itself > other->ob_itself ) return 1; |
| if ( self->ob_itself < other->ob_itself ) return -1; |
| return 0; |
| } |
| |
| #define DlgObj_repr NULL |
| |
| static int DlgObj_hash(DialogObject *self) |
| { |
| return (int)self->ob_itself; |
| } |
| #define DlgObj_tp_init 0 |
| |
| #define DlgObj_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *DlgObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) |
| { |
| PyObject *_self; |
| DialogPtr itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, DlgObj_Convert, &itself)) return NULL; |
| if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((DialogObject *)_self)->ob_itself = itself; |
| return _self; |
| } |
| |
| #define DlgObj_tp_free PyObject_Del |
| |
| |
| PyTypeObject Dialog_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_Dlg.Dialog", /*tp_name*/ |
| sizeof(DialogObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) DlgObj_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*tp_setattr*/ |
| (cmpfunc) DlgObj_compare, /*tp_compare*/ |
| (reprfunc) DlgObj_repr, /*tp_repr*/ |
| (PyNumberMethods *)0, /* tp_as_number */ |
| (PySequenceMethods *)0, /* tp_as_sequence */ |
| (PyMappingMethods *)0, /* tp_as_mapping */ |
| (hashfunc) DlgObj_hash, /*tp_hash*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| DlgObj_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| DlgObj_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| DlgObj_tp_init, /* tp_init */ |
| DlgObj_tp_alloc, /* tp_alloc */ |
| DlgObj_tp_new, /* tp_new */ |
| DlgObj_tp_free, /* tp_free */ |
| }; |
| |
| /* --------------------- End object type Dialog --------------------- */ |
| |
| |
| static PyObject *Dlg_NewDialog(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogPtr _rv; |
| Rect boundsRect; |
| Str255 title; |
| Boolean visible; |
| SInt16 procID; |
| WindowPtr behind; |
| Boolean goAwayFlag; |
| SInt32 refCon; |
| Handle items; |
| #ifndef NewDialog |
| PyMac_PRECHECK(NewDialog); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&", |
| PyMac_GetRect, &boundsRect, |
| PyMac_GetStr255, title, |
| &visible, |
| &procID, |
| WinObj_Convert, &behind, |
| &goAwayFlag, |
| &refCon, |
| ResObj_Convert, &items)) |
| return NULL; |
| _rv = NewDialog((void *)0, |
| &boundsRect, |
| title, |
| visible, |
| procID, |
| behind, |
| goAwayFlag, |
| refCon, |
| items); |
| _res = Py_BuildValue("O&", |
| DlgObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Dlg_GetNewDialog(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogPtr _rv; |
| SInt16 dialogID; |
| WindowPtr behind; |
| #ifndef GetNewDialog |
| PyMac_PRECHECK(GetNewDialog); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hO&", |
| &dialogID, |
| WinObj_Convert, &behind)) |
| return NULL; |
| _rv = GetNewDialog(dialogID, |
| (void *)0, |
| behind); |
| _res = Py_BuildValue("O&", |
| DlgObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Dlg_NewColorDialog(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogPtr _rv; |
| Rect boundsRect; |
| Str255 title; |
| Boolean visible; |
| SInt16 procID; |
| WindowPtr behind; |
| Boolean goAwayFlag; |
| SInt32 refCon; |
| Handle items; |
| #ifndef NewColorDialog |
| PyMac_PRECHECK(NewColorDialog); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&", |
| PyMac_GetRect, &boundsRect, |
| PyMac_GetStr255, title, |
| &visible, |
| &procID, |
| WinObj_Convert, &behind, |
| &goAwayFlag, |
| &refCon, |
| ResObj_Convert, &items)) |
| return NULL; |
| _rv = NewColorDialog((void *)0, |
| &boundsRect, |
| title, |
| visible, |
| procID, |
| behind, |
| goAwayFlag, |
| refCon, |
| items); |
| _res = Py_BuildValue("O&", |
| DlgObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Dlg_ModalDialog(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| PyObject* modalFilter; |
| DialogItemIndex itemHit; |
| #ifndef ModalDialog |
| PyMac_PRECHECK(ModalDialog); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O", |
| &modalFilter)) |
| return NULL; |
| ModalDialog(Dlg_PassFilterProc(modalFilter), |
| &itemHit); |
| _res = Py_BuildValue("h", |
| itemHit); |
| return _res; |
| } |
| |
| static PyObject *Dlg_IsDialogEvent(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| EventRecord theEvent; |
| #ifndef IsDialogEvent |
| PyMac_PRECHECK(IsDialogEvent); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetEventRecord, &theEvent)) |
| return NULL; |
| _rv = IsDialogEvent(&theEvent); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Dlg_DialogSelect(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| EventRecord theEvent; |
| DialogPtr theDialog; |
| DialogItemIndex itemHit; |
| #ifndef DialogSelect |
| PyMac_PRECHECK(DialogSelect); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetEventRecord, &theEvent)) |
| return NULL; |
| _rv = DialogSelect(&theEvent, |
| &theDialog, |
| &itemHit); |
| _res = Py_BuildValue("bO&h", |
| _rv, |
| DlgObj_WhichDialog, theDialog, |
| itemHit); |
| return _res; |
| } |
| |
| static PyObject *Dlg_Alert(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogItemIndex _rv; |
| SInt16 alertID; |
| PyObject* modalFilter; |
| #ifndef Alert |
| PyMac_PRECHECK(Alert); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hO", |
| &alertID, |
| &modalFilter)) |
| return NULL; |
| _rv = Alert(alertID, |
| Dlg_PassFilterProc(modalFilter)); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Dlg_StopAlert(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogItemIndex _rv; |
| SInt16 alertID; |
| PyObject* modalFilter; |
| #ifndef StopAlert |
| PyMac_PRECHECK(StopAlert); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hO", |
| &alertID, |
| &modalFilter)) |
| return NULL; |
| _rv = StopAlert(alertID, |
| Dlg_PassFilterProc(modalFilter)); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Dlg_NoteAlert(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogItemIndex _rv; |
| SInt16 alertID; |
| PyObject* modalFilter; |
| #ifndef NoteAlert |
| PyMac_PRECHECK(NoteAlert); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hO", |
| &alertID, |
| &modalFilter)) |
| return NULL; |
| _rv = NoteAlert(alertID, |
| Dlg_PassFilterProc(modalFilter)); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Dlg_CautionAlert(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogItemIndex _rv; |
| SInt16 alertID; |
| PyObject* modalFilter; |
| #ifndef CautionAlert |
| PyMac_PRECHECK(CautionAlert); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hO", |
| &alertID, |
| &modalFilter)) |
| return NULL; |
| _rv = CautionAlert(alertID, |
| Dlg_PassFilterProc(modalFilter)); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Dlg_ParamText(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Str255 param0; |
| Str255 param1; |
| Str255 param2; |
| Str255 param3; |
| #ifndef ParamText |
| PyMac_PRECHECK(ParamText); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&O&", |
| PyMac_GetStr255, param0, |
| PyMac_GetStr255, param1, |
| PyMac_GetStr255, param2, |
| PyMac_GetStr255, param3)) |
| return NULL; |
| ParamText(param0, |
| param1, |
| param2, |
| param3); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Dlg_GetDialogItemText(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Handle item; |
| Str255 text; |
| #ifndef GetDialogItemText |
| PyMac_PRECHECK(GetDialogItemText); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &item)) |
| return NULL; |
| GetDialogItemText(item, |
| text); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildStr255, text); |
| return _res; |
| } |
| |
| static PyObject *Dlg_SetDialogItemText(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Handle item; |
| Str255 text; |
| #ifndef SetDialogItemText |
| PyMac_PRECHECK(SetDialogItemText); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| ResObj_Convert, &item, |
| PyMac_GetStr255, text)) |
| return NULL; |
| SetDialogItemText(item, |
| text); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Dlg_GetAlertStage(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt16 _rv; |
| #ifndef GetAlertStage |
| PyMac_PRECHECK(GetAlertStage); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetAlertStage(); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Dlg_SetDialogFont(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| SInt16 fontNum; |
| #ifndef SetDialogFont |
| PyMac_PRECHECK(SetDialogFont); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &fontNum)) |
| return NULL; |
| SetDialogFont(fontNum); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Dlg_ResetAlertStage(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef ResetAlertStage |
| PyMac_PRECHECK(ResetAlertStage); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| ResetAlertStage(); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Dlg_GetParamText(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Str255 param0; |
| Str255 param1; |
| Str255 param2; |
| Str255 param3; |
| #ifndef GetParamText |
| PyMac_PRECHECK(GetParamText); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&O&", |
| PyMac_GetStr255, param0, |
| PyMac_GetStr255, param1, |
| PyMac_GetStr255, param2, |
| PyMac_GetStr255, param3)) |
| return NULL; |
| GetParamText(param0, |
| param1, |
| param2, |
| param3); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Dlg_NewFeaturesDialog(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogPtr _rv; |
| Rect inBoundsRect; |
| Str255 inTitle; |
| Boolean inIsVisible; |
| SInt16 inProcID; |
| WindowPtr inBehind; |
| Boolean inGoAwayFlag; |
| SInt32 inRefCon; |
| Handle inItemListHandle; |
| UInt32 inFlags; |
| #ifndef NewFeaturesDialog |
| PyMac_PRECHECK(NewFeaturesDialog); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&l", |
| PyMac_GetRect, &inBoundsRect, |
| PyMac_GetStr255, inTitle, |
| &inIsVisible, |
| &inProcID, |
| WinObj_Convert, &inBehind, |
| &inGoAwayFlag, |
| &inRefCon, |
| ResObj_Convert, &inItemListHandle, |
| &inFlags)) |
| return NULL; |
| _rv = NewFeaturesDialog((void *)0, |
| &inBoundsRect, |
| inTitle, |
| inIsVisible, |
| inProcID, |
| inBehind, |
| inGoAwayFlag, |
| inRefCon, |
| inItemListHandle, |
| inFlags); |
| _res = Py_BuildValue("O&", |
| DlgObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Dlg_GetDialogFromWindow(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DialogPtr _rv; |
| WindowPtr window; |
| #ifndef GetDialogFromWindow |
| PyMac_PRECHECK(GetDialogFromWindow); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &window)) |
| return NULL; |
| _rv = GetDialogFromWindow(window); |
| _res = Py_BuildValue("O&", |
| DlgObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Dlg_SetUserItemHandler(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| |
| 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 == NULL || new == Py_None) { |
| new = NULL; |
| _res = Py_None; |
| Py_INCREF(Py_None); |
| } else { |
| Py_INCREF(new); |
| _res = Py_BuildValue("O&", ResObj_New, (Handle)NewUserItemUPP(Dlg_UnivUserItemProc)); |
| } |
| |
| Dlg_UserItemProc_callback = new; |
| return _res; |
| |
| } |
| |
| static PyMethodDef Dlg_methods[] = { |
| {"NewDialog", (PyCFunction)Dlg_NewDialog, 1, |
| PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)")}, |
| {"GetNewDialog", (PyCFunction)Dlg_GetNewDialog, 1, |
| PyDoc_STR("(SInt16 dialogID, WindowPtr behind) -> (DialogPtr _rv)")}, |
| {"NewColorDialog", (PyCFunction)Dlg_NewColorDialog, 1, |
| PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)")}, |
| {"ModalDialog", (PyCFunction)Dlg_ModalDialog, 1, |
| PyDoc_STR("(PyObject* modalFilter) -> (DialogItemIndex itemHit)")}, |
| {"IsDialogEvent", (PyCFunction)Dlg_IsDialogEvent, 1, |
| PyDoc_STR("(EventRecord theEvent) -> (Boolean _rv)")}, |
| {"DialogSelect", (PyCFunction)Dlg_DialogSelect, 1, |
| PyDoc_STR("(EventRecord theEvent) -> (Boolean _rv, DialogPtr theDialog, DialogItemIndex itemHit)")}, |
| {"Alert", (PyCFunction)Dlg_Alert, 1, |
| PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")}, |
| {"StopAlert", (PyCFunction)Dlg_StopAlert, 1, |
| PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")}, |
| {"NoteAlert", (PyCFunction)Dlg_NoteAlert, 1, |
| PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")}, |
| {"CautionAlert", (PyCFunction)Dlg_CautionAlert, 1, |
| PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")}, |
| {"ParamText", (PyCFunction)Dlg_ParamText, 1, |
| PyDoc_STR("(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None")}, |
| {"GetDialogItemText", (PyCFunction)Dlg_GetDialogItemText, 1, |
| PyDoc_STR("(Handle item) -> (Str255 text)")}, |
| {"SetDialogItemText", (PyCFunction)Dlg_SetDialogItemText, 1, |
| PyDoc_STR("(Handle item, Str255 text) -> None")}, |
| {"GetAlertStage", (PyCFunction)Dlg_GetAlertStage, 1, |
| PyDoc_STR("() -> (SInt16 _rv)")}, |
| {"SetDialogFont", (PyCFunction)Dlg_SetDialogFont, 1, |
| PyDoc_STR("(SInt16 fontNum) -> None")}, |
| {"ResetAlertStage", (PyCFunction)Dlg_ResetAlertStage, 1, |
| PyDoc_STR("() -> None")}, |
| {"GetParamText", (PyCFunction)Dlg_GetParamText, 1, |
| PyDoc_STR("(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None")}, |
| {"NewFeaturesDialog", (PyCFunction)Dlg_NewFeaturesDialog, 1, |
| PyDoc_STR("(Rect inBoundsRect, Str255 inTitle, Boolean inIsVisible, SInt16 inProcID, WindowPtr inBehind, Boolean inGoAwayFlag, SInt32 inRefCon, Handle inItemListHandle, UInt32 inFlags) -> (DialogPtr _rv)")}, |
| {"GetDialogFromWindow", (PyCFunction)Dlg_GetDialogFromWindow, 1, |
| PyDoc_STR("(WindowPtr window) -> (DialogPtr _rv)")}, |
| {"SetUserItemHandler", (PyCFunction)Dlg_SetUserItemHandler, 1, |
| PyDoc_STR(NULL)}, |
| {NULL, NULL, 0} |
| }; |
| |
| |
| |
| /* Return the WindowPtr corresponding to a DialogObject */ |
| #if 0 |
| WindowPtr |
| DlgObj_ConvertToWindow(PyObject *self) |
| { |
| if ( DlgObj_Check(self) ) |
| return GetDialogWindow(((DialogObject *)self)->ob_itself); |
| return NULL; |
| } |
| #endif |
| /* Return the object corresponding to the dialog, or None */ |
| |
| PyObject * |
| DlgObj_WhichDialog(DialogPtr d) |
| { |
| PyObject *it; |
| |
| if (d == NULL) { |
| it = Py_None; |
| Py_INCREF(it); |
| } else { |
| WindowPtr w = GetDialogWindow(d); |
| |
| it = (PyObject *) GetWRefCon(w); |
| if (it == NULL || ((DialogObject *)it)->ob_itself != d || !DlgObj_Check(it)) { |
| #if 0 |
| /* Should do this, but we don't have an ob_freeit for dialogs yet. */ |
| it = WinObj_New(w); |
| ((WindowObject *)it)->ob_freeit = NULL; |
| #else |
| it = Py_None; |
| Py_INCREF(it); |
| #endif |
| } else { |
| Py_INCREF(it); |
| } |
| } |
| return it; |
| } |
| |
| #else /* __LP64__ */ |
| |
| static PyMethodDef Dlg_methods[] = { |
| {NULL, NULL, 0} |
| }; |
| |
| #endif /* __LP64__ */ |
| |
| |
| void init_Dlg(void) |
| { |
| PyObject *m; |
| #ifndef __LP64__ |
| PyObject *d; |
| |
| |
| |
| PyMac_INIT_TOOLBOX_OBJECT_NEW(DialogPtr, DlgObj_New); |
| PyMac_INIT_TOOLBOX_OBJECT_NEW(DialogPtr, DlgObj_WhichDialog); |
| PyMac_INIT_TOOLBOX_OBJECT_CONVERT(DialogPtr, DlgObj_Convert); |
| #endif /* !__LP64__ */ |
| |
| m = Py_InitModule("_Dlg", Dlg_methods); |
| |
| #ifndef __LP64__ |
| d = PyModule_GetDict(m); |
| Dlg_Error = PyMac_GetOSErrException(); |
| if (Dlg_Error == NULL || |
| PyDict_SetItemString(d, "Error", Dlg_Error) != 0) |
| return; |
| Dialog_Type.ob_type = &PyType_Type; |
| if (PyType_Ready(&Dialog_Type) < 0) return; |
| Py_INCREF(&Dialog_Type); |
| PyModule_AddObject(m, "Dialog", (PyObject *)&Dialog_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&Dialog_Type); |
| PyModule_AddObject(m, "DialogType", (PyObject *)&Dialog_Type); |
| #endif /* !__LP64__ */ |
| } |
| |
| /* ======================== End module _Dlg ========================= */ |
| |