2497 lines
62 KiB
C
2497 lines
62 KiB
C
|
|
/* =========================== Module Win =========================== */
|
|
|
|
#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 <Windows.h>
|
|
|
|
extern PyObject *QdRGB_New(RGBColor *);
|
|
extern int QdRGB_Convert(PyObject *, RGBColor *);
|
|
|
|
#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
|
|
|
|
|
|
static PyObject *Win_Error;
|
|
|
|
/* ----------------------- Object type Window ----------------------- */
|
|
|
|
PyTypeObject Window_Type;
|
|
|
|
#define WinObj_Check(x) ((x)->ob_type == &Window_Type)
|
|
|
|
typedef struct WindowObject {
|
|
PyObject_HEAD
|
|
WindowPtr ob_itself;
|
|
} WindowObject;
|
|
|
|
PyObject *WinObj_New(itself)
|
|
WindowPtr itself;
|
|
{
|
|
WindowObject *it;
|
|
if (itself == NULL) return PyMac_Error(resNotFound);
|
|
it = PyObject_NEW(WindowObject, &Window_Type);
|
|
if (it == NULL) return NULL;
|
|
it->ob_itself = itself;
|
|
SetWRefCon(itself, (long)it);
|
|
return (PyObject *)it;
|
|
}
|
|
WinObj_Convert(v, p_itself)
|
|
PyObject *v;
|
|
WindowPtr *p_itself;
|
|
{
|
|
if (DlgObj_Check(v)) {
|
|
*p_itself = ((WindowObject *)v)->ob_itself;
|
|
return 1;
|
|
}
|
|
|
|
if (v == Py_None) { *p_itself = NULL; return 1; }
|
|
if (PyInt_Check(v)) { *p_itself = (WindowPtr)PyInt_AsLong(v); return 1; }
|
|
|
|
if (!WinObj_Check(v))
|
|
{
|
|
PyErr_SetString(PyExc_TypeError, "Window required");
|
|
return 0;
|
|
}
|
|
*p_itself = ((WindowObject *)v)->ob_itself;
|
|
return 1;
|
|
}
|
|
|
|
static void WinObj_dealloc(self)
|
|
WindowObject *self;
|
|
{
|
|
DisposeWindow(self->ob_itself);
|
|
PyMem_DEL(self);
|
|
}
|
|
|
|
static PyObject *WinObj_MacCloseWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
MacCloseWindow(_self->ob_itself);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowOwnerCount(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
UInt32 outCount;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = GetWindowOwnerCount(_self->ob_itself,
|
|
&outCount);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("l",
|
|
outCount);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_CloneWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = CloneWindow(_self->ob_itself);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowClass(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
WindowClass outClass;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = GetWindowClass(_self->ob_itself,
|
|
&outClass);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("l",
|
|
outClass);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowAttributes(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
WindowAttributes outAttributes;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = GetWindowAttributes(_self->ob_itself,
|
|
&outAttributes);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("l",
|
|
outAttributes);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWinColor(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
WCTabHandle newColorTable;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &newColorTable))
|
|
return NULL;
|
|
SetWinColor(_self->ob_itself,
|
|
newColorTable);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWindowContentColor(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
RGBColor color;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = SetWindowContentColor(_self->ob_itself,
|
|
&color);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
QdRGB_New, &color);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowContentColor(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
RGBColor color;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = GetWindowContentColor(_self->ob_itself,
|
|
&color);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
QdRGB_New, &color);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowContentPattern(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
PixPatHandle outPixPat;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &outPixPat))
|
|
return NULL;
|
|
_err = GetWindowContentPattern(_self->ob_itself,
|
|
outPixPat);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWindowContentPattern(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
PixPatHandle pixPat;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &pixPat))
|
|
return NULL;
|
|
_err = SetWindowContentPattern(_self->ob_itself,
|
|
pixPat);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_ClipAbove(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
ClipAbove(_self->ob_itself);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SaveOld(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
SaveOld(_self->ob_itself);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_DrawNew(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean update;
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
&update))
|
|
return NULL;
|
|
DrawNew(_self->ob_itself,
|
|
update);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_PaintOne(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
RgnHandle clobberedRgn;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &clobberedRgn))
|
|
return NULL;
|
|
PaintOne(_self->ob_itself,
|
|
clobberedRgn);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_PaintBehind(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
RgnHandle clobberedRgn;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &clobberedRgn))
|
|
return NULL;
|
|
PaintBehind(_self->ob_itself,
|
|
clobberedRgn);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_CalcVis(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
CalcVis(_self->ob_itself);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_CalcVisBehind(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
RgnHandle clobberedRgn;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &clobberedRgn))
|
|
return NULL;
|
|
CalcVisBehind(_self->ob_itself,
|
|
clobberedRgn);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_BringToFront(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
BringToFront(_self->ob_itself);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SendBehind(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
WindowPtr behindWindow;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
WinObj_Convert, &behindWindow))
|
|
return NULL;
|
|
SendBehind(_self->ob_itself,
|
|
behindWindow);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SelectWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
SelectWindow(_self->ob_itself);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_HiliteWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean fHilite;
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
&fHilite))
|
|
return NULL;
|
|
HiliteWindow(_self->ob_itself,
|
|
fHilite);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWRefCon(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
long data;
|
|
if (!PyArg_ParseTuple(_args, "l",
|
|
&data))
|
|
return NULL;
|
|
SetWRefCon(_self->ob_itself,
|
|
data);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWRefCon(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
long _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetWRefCon(_self->ob_itself);
|
|
_res = Py_BuildValue("l",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWindowPic(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
PicHandle pic;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &pic))
|
|
return NULL;
|
|
SetWindowPic(_self->ob_itself,
|
|
pic);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowPic(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
PicHandle _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetWindowPic(_self->ob_itself);
|
|
_res = Py_BuildValue("O&",
|
|
ResObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWVariant(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetWVariant(_self->ob_itself);
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowFeatures(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
UInt32 outFeatures;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = GetWindowFeatures(_self->ob_itself,
|
|
&outFeatures);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("l",
|
|
outFeatures);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowRegion(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
WindowRegionCode inRegionCode;
|
|
RgnHandle ioWinRgn;
|
|
if (!PyArg_ParseTuple(_args, "hO&",
|
|
&inRegionCode,
|
|
ResObj_Convert, &ioWinRgn))
|
|
return NULL;
|
|
_err = GetWindowRegion(_self->ob_itself,
|
|
inRegionCode,
|
|
ioWinRgn);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_BeginUpdate(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
BeginUpdate(_self->ob_itself);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_EndUpdate(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
EndUpdate(_self->ob_itself);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_InvalWindowRgn(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
RgnHandle region;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, ®ion))
|
|
return NULL;
|
|
_err = InvalWindowRgn(_self->ob_itself,
|
|
region);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_InvalWindowRect(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
Rect bounds;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetRect, &bounds))
|
|
return NULL;
|
|
_err = InvalWindowRect(_self->ob_itself,
|
|
&bounds);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_ValidWindowRgn(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
RgnHandle region;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, ®ion))
|
|
return NULL;
|
|
_err = ValidWindowRgn(_self->ob_itself,
|
|
region);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_ValidWindowRect(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
Rect bounds;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetRect, &bounds))
|
|
return NULL;
|
|
_err = ValidWindowRect(_self->ob_itself,
|
|
&bounds);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_DrawGrowIcon(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
DrawGrowIcon(_self->ob_itself);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWTitle(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Str255 title;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetStr255, title))
|
|
return NULL;
|
|
SetWTitle(_self->ob_itself,
|
|
title);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWTitle(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Str255 title;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
GetWTitle(_self->ob_itself,
|
|
title);
|
|
_res = Py_BuildValue("O&",
|
|
PyMac_BuildStr255, title);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWindowProxyFSSpec(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
FSSpec inFile;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetFSSpec, &inFile))
|
|
return NULL;
|
|
_err = SetWindowProxyFSSpec(_self->ob_itself,
|
|
&inFile);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowProxyFSSpec(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
FSSpec outFile;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = GetWindowProxyFSSpec(_self->ob_itself,
|
|
&outFile);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
PyMac_BuildFSSpec, &outFile);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWindowProxyAlias(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
AliasHandle alias;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &alias))
|
|
return NULL;
|
|
_err = SetWindowProxyAlias(_self->ob_itself,
|
|
alias);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowProxyAlias(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
AliasHandle alias;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = GetWindowProxyAlias(_self->ob_itself,
|
|
&alias);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
ResObj_New, alias);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWindowProxyCreatorAndType(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
OSType fileCreator;
|
|
OSType fileType;
|
|
SInt16 vRefNum;
|
|
if (!PyArg_ParseTuple(_args, "O&O&h",
|
|
PyMac_GetOSType, &fileCreator,
|
|
PyMac_GetOSType, &fileType,
|
|
&vRefNum))
|
|
return NULL;
|
|
_err = SetWindowProxyCreatorAndType(_self->ob_itself,
|
|
fileCreator,
|
|
fileType,
|
|
vRefNum);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowProxyIcon(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
IconRef outIcon;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = GetWindowProxyIcon(_self->ob_itself,
|
|
&outIcon);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
ResObj_New, outIcon);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWindowProxyIcon(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
IconRef icon;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &icon))
|
|
return NULL;
|
|
_err = SetWindowProxyIcon(_self->ob_itself,
|
|
icon);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_RemoveWindowProxy(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = RemoveWindowProxy(_self->ob_itself);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_TrackWindowProxyDrag(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
Point startPt;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetPoint, &startPt))
|
|
return NULL;
|
|
_err = TrackWindowProxyDrag(_self->ob_itself,
|
|
startPt);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_IsWindowModified(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = IsWindowModified(_self->ob_itself);
|
|
_res = Py_BuildValue("b",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWindowModified(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
Boolean modified;
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
&modified))
|
|
return NULL;
|
|
_err = SetWindowModified(_self->ob_itself,
|
|
modified);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_IsWindowPathSelectClick(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean _rv;
|
|
EventRecord event;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = IsWindowPathSelectClick(_self->ob_itself,
|
|
&event);
|
|
_res = Py_BuildValue("bO&",
|
|
_rv,
|
|
PyMac_BuildEventRecord, &event);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_HiliteWindowFrameForDrag(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
Boolean hilited;
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
&hilited))
|
|
return NULL;
|
|
_err = HiliteWindowFrameForDrag(_self->ob_itself,
|
|
hilited);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_TransitionWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
WindowTransitionEffect effect;
|
|
WindowTransitionAction action;
|
|
Rect rect;
|
|
if (!PyArg_ParseTuple(_args, "llO&",
|
|
&effect,
|
|
&action,
|
|
PyMac_GetRect, &rect))
|
|
return NULL;
|
|
_err = TransitionWindow(_self->ob_itself,
|
|
effect,
|
|
action,
|
|
&rect);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_MacMoveWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short hGlobal;
|
|
short vGlobal;
|
|
Boolean front;
|
|
if (!PyArg_ParseTuple(_args, "hhb",
|
|
&hGlobal,
|
|
&vGlobal,
|
|
&front))
|
|
return NULL;
|
|
MacMoveWindow(_self->ob_itself,
|
|
hGlobal,
|
|
vGlobal,
|
|
front);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SizeWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short w;
|
|
short h;
|
|
Boolean fUpdate;
|
|
if (!PyArg_ParseTuple(_args, "hhb",
|
|
&w,
|
|
&h,
|
|
&fUpdate))
|
|
return NULL;
|
|
SizeWindow(_self->ob_itself,
|
|
w,
|
|
h,
|
|
fUpdate);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GrowWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
long _rv;
|
|
Point startPt;
|
|
Rect bBox;
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
PyMac_GetPoint, &startPt,
|
|
PyMac_GetRect, &bBox))
|
|
return NULL;
|
|
_rv = GrowWindow(_self->ob_itself,
|
|
startPt,
|
|
&bBox);
|
|
_res = Py_BuildValue("l",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_DragWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Point startPt;
|
|
Rect boundsRect;
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
PyMac_GetPoint, &startPt,
|
|
PyMac_GetRect, &boundsRect))
|
|
return NULL;
|
|
DragWindow(_self->ob_itself,
|
|
startPt,
|
|
&boundsRect);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_ZoomWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short partCode;
|
|
Boolean front;
|
|
if (!PyArg_ParseTuple(_args, "hb",
|
|
&partCode,
|
|
&front))
|
|
return NULL;
|
|
ZoomWindow(_self->ob_itself,
|
|
partCode,
|
|
front);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_IsWindowCollapsable(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = IsWindowCollapsable(_self->ob_itself);
|
|
_res = Py_BuildValue("b",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_IsWindowCollapsed(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = IsWindowCollapsed(_self->ob_itself);
|
|
_res = Py_BuildValue("b",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_CollapseWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
Boolean collapse;
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
&collapse))
|
|
return NULL;
|
|
_err = CollapseWindow(_self->ob_itself,
|
|
collapse);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_RepositionWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
WindowPtr parentWindow;
|
|
WindowPositionMethod method;
|
|
if (!PyArg_ParseTuple(_args, "O&l",
|
|
WinObj_Convert, &parentWindow,
|
|
&method))
|
|
return NULL;
|
|
_err = RepositionWindow(_self->ob_itself,
|
|
parentWindow,
|
|
method);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWindowBounds(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
WindowRegionCode regionCode;
|
|
Rect globalBounds;
|
|
if (!PyArg_ParseTuple(_args, "hO&",
|
|
®ionCode,
|
|
PyMac_GetRect, &globalBounds))
|
|
return NULL;
|
|
_err = SetWindowBounds(_self->ob_itself,
|
|
regionCode,
|
|
&globalBounds);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowBounds(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
WindowRegionCode regionCode;
|
|
Rect globalBounds;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
®ionCode))
|
|
return NULL;
|
|
_err = GetWindowBounds(_self->ob_itself,
|
|
regionCode,
|
|
&globalBounds);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
PyMac_BuildRect, &globalBounds);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_MoveWindowStructure(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
short hGlobal;
|
|
short vGlobal;
|
|
if (!PyArg_ParseTuple(_args, "hh",
|
|
&hGlobal,
|
|
&vGlobal))
|
|
return NULL;
|
|
_err = MoveWindowStructure(_self->ob_itself,
|
|
hGlobal,
|
|
vGlobal);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_IsWindowInStandardState(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean _rv;
|
|
Point idealSize;
|
|
Rect idealStandardState;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = IsWindowInStandardState(_self->ob_itself,
|
|
&idealSize,
|
|
&idealStandardState);
|
|
_res = Py_BuildValue("bO&O&",
|
|
_rv,
|
|
PyMac_BuildPoint, idealSize,
|
|
PyMac_BuildRect, &idealStandardState);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_ZoomWindowIdeal(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
SInt16 partCode;
|
|
Point ioIdealSize;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&partCode))
|
|
return NULL;
|
|
_err = ZoomWindowIdeal(_self->ob_itself,
|
|
partCode,
|
|
&ioIdealSize);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
PyMac_BuildPoint, ioIdealSize);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowIdealUserState(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
Rect userState;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = GetWindowIdealUserState(_self->ob_itself,
|
|
&userState);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
PyMac_BuildRect, &userState);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWindowIdealUserState(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
Rect userState;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = SetWindowIdealUserState(_self->ob_itself,
|
|
&userState);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
PyMac_BuildRect, &userState);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_HideWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
HideWindow(_self->ob_itself);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_MacShowWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
MacShowWindow(_self->ob_itself);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_ShowHide(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean showFlag;
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
&showFlag))
|
|
return NULL;
|
|
ShowHide(_self->ob_itself,
|
|
showFlag);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_TrackBox(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean _rv;
|
|
Point thePt;
|
|
short partCode;
|
|
if (!PyArg_ParseTuple(_args, "O&h",
|
|
PyMac_GetPoint, &thePt,
|
|
&partCode))
|
|
return NULL;
|
|
_rv = TrackBox(_self->ob_itself,
|
|
thePt,
|
|
partCode);
|
|
_res = Py_BuildValue("b",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_TrackGoAway(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean _rv;
|
|
Point thePt;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetPoint, &thePt))
|
|
return NULL;
|
|
_rv = TrackGoAway(_self->ob_itself,
|
|
thePt);
|
|
_res = Py_BuildValue("b",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetAuxWin(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean _rv;
|
|
AuxWinHandle awHndl;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetAuxWin(_self->ob_itself,
|
|
&awHndl);
|
|
_res = Py_BuildValue("bO&",
|
|
_rv,
|
|
ResObj_New, awHndl);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowPort(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
CGrafPtr _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetWindowPort(_self->ob_itself);
|
|
_res = Py_BuildValue("O&",
|
|
GrafObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetPortWindowPort(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
SetPortWindowPort(_self->ob_itself);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowKind(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetWindowKind(_self->ob_itself);
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWindowKind(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short wKind;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&wKind))
|
|
return NULL;
|
|
SetWindowKind(_self->ob_itself,
|
|
wKind);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_IsWindowVisible(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = IsWindowVisible(_self->ob_itself);
|
|
_res = Py_BuildValue("b",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_IsWindowHilited(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = IsWindowHilited(_self->ob_itself);
|
|
_res = Py_BuildValue("b",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowGoAwayFlag(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetWindowGoAwayFlag(_self->ob_itself);
|
|
_res = Py_BuildValue("b",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowZoomFlag(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetWindowZoomFlag(_self->ob_itself);
|
|
_res = Py_BuildValue("b",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowStructureRgn(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
RgnHandle r;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &r))
|
|
return NULL;
|
|
GetWindowStructureRgn(_self->ob_itself,
|
|
r);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowContentRgn(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
RgnHandle r;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &r))
|
|
return NULL;
|
|
GetWindowContentRgn(_self->ob_itself,
|
|
r);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowUpdateRgn(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
RgnHandle r;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &r))
|
|
return NULL;
|
|
GetWindowUpdateRgn(_self->ob_itself,
|
|
r);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowTitleWidth(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetWindowTitleWidth(_self->ob_itself);
|
|
_res = Py_BuildValue("h",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetNextWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
WindowPtr _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetNextWindow(_self->ob_itself);
|
|
_res = Py_BuildValue("O&",
|
|
WinObj_WhichWindow, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowStandardState(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Rect r;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
GetWindowStandardState(_self->ob_itself,
|
|
&r);
|
|
_res = Py_BuildValue("O&",
|
|
PyMac_BuildRect, &r);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowUserState(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Rect r;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
GetWindowUserState(_self->ob_itself,
|
|
&r);
|
|
_res = Py_BuildValue("O&",
|
|
PyMac_BuildRect, &r);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWindowStandardState(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Rect r;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetRect, &r))
|
|
return NULL;
|
|
SetWindowStandardState(_self->ob_itself,
|
|
&r);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWindowUserState(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Rect r;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetRect, &r))
|
|
return NULL;
|
|
SetWindowUserState(_self->ob_itself,
|
|
&r);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_GetWindowDataHandle(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Handle _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetWindowDataHandle(_self->ob_itself);
|
|
_res = Py_BuildValue("O&",
|
|
ResObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_SetWindowDataHandle(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Handle data;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &data))
|
|
return NULL;
|
|
SetWindowDataHandle(_self->ob_itself,
|
|
data);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_CloseWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
CloseWindow(_self->ob_itself);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_MoveWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short hGlobal;
|
|
short vGlobal;
|
|
Boolean front;
|
|
if (!PyArg_ParseTuple(_args, "hhb",
|
|
&hGlobal,
|
|
&vGlobal,
|
|
&front))
|
|
return NULL;
|
|
MoveWindow(_self->ob_itself,
|
|
hGlobal,
|
|
vGlobal,
|
|
front);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *WinObj_ShowWindow(_self, _args)
|
|
WindowObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
ShowWindow(_self->ob_itself);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyMethodDef WinObj_methods[] = {
|
|
{"MacCloseWindow", (PyCFunction)WinObj_MacCloseWindow, 1,
|
|
"() -> None"},
|
|
{"GetWindowOwnerCount", (PyCFunction)WinObj_GetWindowOwnerCount, 1,
|
|
"() -> (UInt32 outCount)"},
|
|
{"CloneWindow", (PyCFunction)WinObj_CloneWindow, 1,
|
|
"() -> None"},
|
|
{"GetWindowClass", (PyCFunction)WinObj_GetWindowClass, 1,
|
|
"() -> (WindowClass outClass)"},
|
|
{"GetWindowAttributes", (PyCFunction)WinObj_GetWindowAttributes, 1,
|
|
"() -> (WindowAttributes outAttributes)"},
|
|
{"SetWinColor", (PyCFunction)WinObj_SetWinColor, 1,
|
|
"(WCTabHandle newColorTable) -> None"},
|
|
{"SetWindowContentColor", (PyCFunction)WinObj_SetWindowContentColor, 1,
|
|
"() -> (RGBColor color)"},
|
|
{"GetWindowContentColor", (PyCFunction)WinObj_GetWindowContentColor, 1,
|
|
"() -> (RGBColor color)"},
|
|
{"GetWindowContentPattern", (PyCFunction)WinObj_GetWindowContentPattern, 1,
|
|
"(PixPatHandle outPixPat) -> None"},
|
|
{"SetWindowContentPattern", (PyCFunction)WinObj_SetWindowContentPattern, 1,
|
|
"(PixPatHandle pixPat) -> None"},
|
|
{"ClipAbove", (PyCFunction)WinObj_ClipAbove, 1,
|
|
"() -> None"},
|
|
{"SaveOld", (PyCFunction)WinObj_SaveOld, 1,
|
|
"() -> None"},
|
|
{"DrawNew", (PyCFunction)WinObj_DrawNew, 1,
|
|
"(Boolean update) -> None"},
|
|
{"PaintOne", (PyCFunction)WinObj_PaintOne, 1,
|
|
"(RgnHandle clobberedRgn) -> None"},
|
|
{"PaintBehind", (PyCFunction)WinObj_PaintBehind, 1,
|
|
"(RgnHandle clobberedRgn) -> None"},
|
|
{"CalcVis", (PyCFunction)WinObj_CalcVis, 1,
|
|
"() -> None"},
|
|
{"CalcVisBehind", (PyCFunction)WinObj_CalcVisBehind, 1,
|
|
"(RgnHandle clobberedRgn) -> None"},
|
|
{"BringToFront", (PyCFunction)WinObj_BringToFront, 1,
|
|
"() -> None"},
|
|
{"SendBehind", (PyCFunction)WinObj_SendBehind, 1,
|
|
"(WindowPtr behindWindow) -> None"},
|
|
{"SelectWindow", (PyCFunction)WinObj_SelectWindow, 1,
|
|
"() -> None"},
|
|
{"HiliteWindow", (PyCFunction)WinObj_HiliteWindow, 1,
|
|
"(Boolean fHilite) -> None"},
|
|
{"SetWRefCon", (PyCFunction)WinObj_SetWRefCon, 1,
|
|
"(long data) -> None"},
|
|
{"GetWRefCon", (PyCFunction)WinObj_GetWRefCon, 1,
|
|
"() -> (long _rv)"},
|
|
{"SetWindowPic", (PyCFunction)WinObj_SetWindowPic, 1,
|
|
"(PicHandle pic) -> None"},
|
|
{"GetWindowPic", (PyCFunction)WinObj_GetWindowPic, 1,
|
|
"() -> (PicHandle _rv)"},
|
|
{"GetWVariant", (PyCFunction)WinObj_GetWVariant, 1,
|
|
"() -> (short _rv)"},
|
|
{"GetWindowFeatures", (PyCFunction)WinObj_GetWindowFeatures, 1,
|
|
"() -> (UInt32 outFeatures)"},
|
|
{"GetWindowRegion", (PyCFunction)WinObj_GetWindowRegion, 1,
|
|
"(WindowRegionCode inRegionCode, RgnHandle ioWinRgn) -> None"},
|
|
{"BeginUpdate", (PyCFunction)WinObj_BeginUpdate, 1,
|
|
"() -> None"},
|
|
{"EndUpdate", (PyCFunction)WinObj_EndUpdate, 1,
|
|
"() -> None"},
|
|
{"InvalWindowRgn", (PyCFunction)WinObj_InvalWindowRgn, 1,
|
|
"(RgnHandle region) -> None"},
|
|
{"InvalWindowRect", (PyCFunction)WinObj_InvalWindowRect, 1,
|
|
"(Rect bounds) -> None"},
|
|
{"ValidWindowRgn", (PyCFunction)WinObj_ValidWindowRgn, 1,
|
|
"(RgnHandle region) -> None"},
|
|
{"ValidWindowRect", (PyCFunction)WinObj_ValidWindowRect, 1,
|
|
"(Rect bounds) -> None"},
|
|
{"DrawGrowIcon", (PyCFunction)WinObj_DrawGrowIcon, 1,
|
|
"() -> None"},
|
|
{"SetWTitle", (PyCFunction)WinObj_SetWTitle, 1,
|
|
"(Str255 title) -> None"},
|
|
{"GetWTitle", (PyCFunction)WinObj_GetWTitle, 1,
|
|
"() -> (Str255 title)"},
|
|
{"SetWindowProxyFSSpec", (PyCFunction)WinObj_SetWindowProxyFSSpec, 1,
|
|
"(FSSpec inFile) -> None"},
|
|
{"GetWindowProxyFSSpec", (PyCFunction)WinObj_GetWindowProxyFSSpec, 1,
|
|
"() -> (FSSpec outFile)"},
|
|
{"SetWindowProxyAlias", (PyCFunction)WinObj_SetWindowProxyAlias, 1,
|
|
"(AliasHandle alias) -> None"},
|
|
{"GetWindowProxyAlias", (PyCFunction)WinObj_GetWindowProxyAlias, 1,
|
|
"() -> (AliasHandle alias)"},
|
|
{"SetWindowProxyCreatorAndType", (PyCFunction)WinObj_SetWindowProxyCreatorAndType, 1,
|
|
"(OSType fileCreator, OSType fileType, SInt16 vRefNum) -> None"},
|
|
{"GetWindowProxyIcon", (PyCFunction)WinObj_GetWindowProxyIcon, 1,
|
|
"() -> (IconRef outIcon)"},
|
|
{"SetWindowProxyIcon", (PyCFunction)WinObj_SetWindowProxyIcon, 1,
|
|
"(IconRef icon) -> None"},
|
|
{"RemoveWindowProxy", (PyCFunction)WinObj_RemoveWindowProxy, 1,
|
|
"() -> None"},
|
|
{"TrackWindowProxyDrag", (PyCFunction)WinObj_TrackWindowProxyDrag, 1,
|
|
"(Point startPt) -> None"},
|
|
{"IsWindowModified", (PyCFunction)WinObj_IsWindowModified, 1,
|
|
"() -> (Boolean _rv)"},
|
|
{"SetWindowModified", (PyCFunction)WinObj_SetWindowModified, 1,
|
|
"(Boolean modified) -> None"},
|
|
{"IsWindowPathSelectClick", (PyCFunction)WinObj_IsWindowPathSelectClick, 1,
|
|
"() -> (Boolean _rv, EventRecord event)"},
|
|
{"HiliteWindowFrameForDrag", (PyCFunction)WinObj_HiliteWindowFrameForDrag, 1,
|
|
"(Boolean hilited) -> None"},
|
|
{"TransitionWindow", (PyCFunction)WinObj_TransitionWindow, 1,
|
|
"(WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None"},
|
|
{"MacMoveWindow", (PyCFunction)WinObj_MacMoveWindow, 1,
|
|
"(short hGlobal, short vGlobal, Boolean front) -> None"},
|
|
{"SizeWindow", (PyCFunction)WinObj_SizeWindow, 1,
|
|
"(short w, short h, Boolean fUpdate) -> None"},
|
|
{"GrowWindow", (PyCFunction)WinObj_GrowWindow, 1,
|
|
"(Point startPt, Rect bBox) -> (long _rv)"},
|
|
{"DragWindow", (PyCFunction)WinObj_DragWindow, 1,
|
|
"(Point startPt, Rect boundsRect) -> None"},
|
|
{"ZoomWindow", (PyCFunction)WinObj_ZoomWindow, 1,
|
|
"(short partCode, Boolean front) -> None"},
|
|
{"IsWindowCollapsable", (PyCFunction)WinObj_IsWindowCollapsable, 1,
|
|
"() -> (Boolean _rv)"},
|
|
{"IsWindowCollapsed", (PyCFunction)WinObj_IsWindowCollapsed, 1,
|
|
"() -> (Boolean _rv)"},
|
|
{"CollapseWindow", (PyCFunction)WinObj_CollapseWindow, 1,
|
|
"(Boolean collapse) -> None"},
|
|
{"RepositionWindow", (PyCFunction)WinObj_RepositionWindow, 1,
|
|
"(WindowPtr parentWindow, WindowPositionMethod method) -> None"},
|
|
{"SetWindowBounds", (PyCFunction)WinObj_SetWindowBounds, 1,
|
|
"(WindowRegionCode regionCode, Rect globalBounds) -> None"},
|
|
{"GetWindowBounds", (PyCFunction)WinObj_GetWindowBounds, 1,
|
|
"(WindowRegionCode regionCode) -> (Rect globalBounds)"},
|
|
{"MoveWindowStructure", (PyCFunction)WinObj_MoveWindowStructure, 1,
|
|
"(short hGlobal, short vGlobal) -> None"},
|
|
{"IsWindowInStandardState", (PyCFunction)WinObj_IsWindowInStandardState, 1,
|
|
"() -> (Boolean _rv, Point idealSize, Rect idealStandardState)"},
|
|
{"ZoomWindowIdeal", (PyCFunction)WinObj_ZoomWindowIdeal, 1,
|
|
"(SInt16 partCode) -> (Point ioIdealSize)"},
|
|
{"GetWindowIdealUserState", (PyCFunction)WinObj_GetWindowIdealUserState, 1,
|
|
"() -> (Rect userState)"},
|
|
{"SetWindowIdealUserState", (PyCFunction)WinObj_SetWindowIdealUserState, 1,
|
|
"() -> (Rect userState)"},
|
|
{"HideWindow", (PyCFunction)WinObj_HideWindow, 1,
|
|
"() -> None"},
|
|
{"MacShowWindow", (PyCFunction)WinObj_MacShowWindow, 1,
|
|
"() -> None"},
|
|
{"ShowHide", (PyCFunction)WinObj_ShowHide, 1,
|
|
"(Boolean showFlag) -> None"},
|
|
{"TrackBox", (PyCFunction)WinObj_TrackBox, 1,
|
|
"(Point thePt, short partCode) -> (Boolean _rv)"},
|
|
{"TrackGoAway", (PyCFunction)WinObj_TrackGoAway, 1,
|
|
"(Point thePt) -> (Boolean _rv)"},
|
|
{"GetAuxWin", (PyCFunction)WinObj_GetAuxWin, 1,
|
|
"() -> (Boolean _rv, AuxWinHandle awHndl)"},
|
|
{"GetWindowPort", (PyCFunction)WinObj_GetWindowPort, 1,
|
|
"() -> (CGrafPtr _rv)"},
|
|
{"SetPortWindowPort", (PyCFunction)WinObj_SetPortWindowPort, 1,
|
|
"() -> None"},
|
|
{"GetWindowKind", (PyCFunction)WinObj_GetWindowKind, 1,
|
|
"() -> (short _rv)"},
|
|
{"SetWindowKind", (PyCFunction)WinObj_SetWindowKind, 1,
|
|
"(short wKind) -> None"},
|
|
{"IsWindowVisible", (PyCFunction)WinObj_IsWindowVisible, 1,
|
|
"() -> (Boolean _rv)"},
|
|
{"IsWindowHilited", (PyCFunction)WinObj_IsWindowHilited, 1,
|
|
"() -> (Boolean _rv)"},
|
|
{"GetWindowGoAwayFlag", (PyCFunction)WinObj_GetWindowGoAwayFlag, 1,
|
|
"() -> (Boolean _rv)"},
|
|
{"GetWindowZoomFlag", (PyCFunction)WinObj_GetWindowZoomFlag, 1,
|
|
"() -> (Boolean _rv)"},
|
|
{"GetWindowStructureRgn", (PyCFunction)WinObj_GetWindowStructureRgn, 1,
|
|
"(RgnHandle r) -> None"},
|
|
{"GetWindowContentRgn", (PyCFunction)WinObj_GetWindowContentRgn, 1,
|
|
"(RgnHandle r) -> None"},
|
|
{"GetWindowUpdateRgn", (PyCFunction)WinObj_GetWindowUpdateRgn, 1,
|
|
"(RgnHandle r) -> None"},
|
|
{"GetWindowTitleWidth", (PyCFunction)WinObj_GetWindowTitleWidth, 1,
|
|
"() -> (short _rv)"},
|
|
{"GetNextWindow", (PyCFunction)WinObj_GetNextWindow, 1,
|
|
"() -> (WindowPtr _rv)"},
|
|
{"GetWindowStandardState", (PyCFunction)WinObj_GetWindowStandardState, 1,
|
|
"() -> (Rect r)"},
|
|
{"GetWindowUserState", (PyCFunction)WinObj_GetWindowUserState, 1,
|
|
"() -> (Rect r)"},
|
|
{"SetWindowStandardState", (PyCFunction)WinObj_SetWindowStandardState, 1,
|
|
"(Rect r) -> None"},
|
|
{"SetWindowUserState", (PyCFunction)WinObj_SetWindowUserState, 1,
|
|
"(Rect r) -> None"},
|
|
{"GetWindowDataHandle", (PyCFunction)WinObj_GetWindowDataHandle, 1,
|
|
"() -> (Handle _rv)"},
|
|
{"SetWindowDataHandle", (PyCFunction)WinObj_SetWindowDataHandle, 1,
|
|
"(Handle data) -> None"},
|
|
{"CloseWindow", (PyCFunction)WinObj_CloseWindow, 1,
|
|
"() -> None"},
|
|
{"MoveWindow", (PyCFunction)WinObj_MoveWindow, 1,
|
|
"(short hGlobal, short vGlobal, Boolean front) -> None"},
|
|
{"ShowWindow", (PyCFunction)WinObj_ShowWindow, 1,
|
|
"() -> None"},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
PyMethodChain WinObj_chain = { WinObj_methods, NULL };
|
|
|
|
static PyObject *WinObj_getattr(self, name)
|
|
WindowObject *self;
|
|
char *name;
|
|
{
|
|
return Py_FindMethodInChain(&WinObj_chain, (PyObject *)self, name);
|
|
}
|
|
|
|
#define WinObj_setattr NULL
|
|
|
|
#define WinObj_compare NULL
|
|
|
|
#define WinObj_repr NULL
|
|
|
|
#define WinObj_hash NULL
|
|
|
|
PyTypeObject Window_Type = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"Window", /*tp_name*/
|
|
sizeof(WindowObject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
(destructor) WinObj_dealloc, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
(getattrfunc) WinObj_getattr, /*tp_getattr*/
|
|
(setattrfunc) WinObj_setattr, /*tp_setattr*/
|
|
(cmpfunc) WinObj_compare, /*tp_compare*/
|
|
(reprfunc) WinObj_repr, /*tp_repr*/
|
|
(PyNumberMethods *)0, /* tp_as_number */
|
|
(PySequenceMethods *)0, /* tp_as_sequence */
|
|
(PyMappingMethods *)0, /* tp_as_mapping */
|
|
(hashfunc) WinObj_hash, /*tp_hash*/
|
|
};
|
|
|
|
/* --------------------- End object type Window --------------------- */
|
|
|
|
|
|
static PyObject *Win_GetNewCWindow(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
WindowPtr _rv;
|
|
short windowID;
|
|
WindowPtr behind;
|
|
if (!PyArg_ParseTuple(_args, "hO&",
|
|
&windowID,
|
|
WinObj_Convert, &behind))
|
|
return NULL;
|
|
_rv = GetNewCWindow(windowID,
|
|
(void *)0,
|
|
behind);
|
|
_res = Py_BuildValue("O&",
|
|
WinObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_NewWindow(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
WindowPtr _rv;
|
|
Rect boundsRect;
|
|
Str255 title;
|
|
Boolean visible;
|
|
short theProc;
|
|
WindowPtr behind;
|
|
Boolean goAwayFlag;
|
|
long refCon;
|
|
if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
|
|
PyMac_GetRect, &boundsRect,
|
|
PyMac_GetStr255, title,
|
|
&visible,
|
|
&theProc,
|
|
WinObj_Convert, &behind,
|
|
&goAwayFlag,
|
|
&refCon))
|
|
return NULL;
|
|
_rv = NewWindow((void *)0,
|
|
&boundsRect,
|
|
title,
|
|
visible,
|
|
theProc,
|
|
behind,
|
|
goAwayFlag,
|
|
refCon);
|
|
_res = Py_BuildValue("O&",
|
|
WinObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_GetNewWindow(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
WindowPtr _rv;
|
|
short windowID;
|
|
WindowPtr behind;
|
|
if (!PyArg_ParseTuple(_args, "hO&",
|
|
&windowID,
|
|
WinObj_Convert, &behind))
|
|
return NULL;
|
|
_rv = GetNewWindow(windowID,
|
|
(void *)0,
|
|
behind);
|
|
_res = Py_BuildValue("O&",
|
|
WinObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_NewCWindow(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
WindowPtr _rv;
|
|
Rect boundsRect;
|
|
Str255 title;
|
|
Boolean visible;
|
|
short procID;
|
|
WindowPtr behind;
|
|
Boolean goAwayFlag;
|
|
long refCon;
|
|
if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
|
|
PyMac_GetRect, &boundsRect,
|
|
PyMac_GetStr255, title,
|
|
&visible,
|
|
&procID,
|
|
WinObj_Convert, &behind,
|
|
&goAwayFlag,
|
|
&refCon))
|
|
return NULL;
|
|
_rv = NewCWindow((void *)0,
|
|
&boundsRect,
|
|
title,
|
|
visible,
|
|
procID,
|
|
behind,
|
|
goAwayFlag,
|
|
refCon);
|
|
_res = Py_BuildValue("O&",
|
|
WinObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_CreateNewWindow(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
WindowClass windowClass;
|
|
WindowAttributes attributes;
|
|
Rect bounds;
|
|
WindowPtr outWindow;
|
|
if (!PyArg_ParseTuple(_args, "llO&",
|
|
&windowClass,
|
|
&attributes,
|
|
PyMac_GetRect, &bounds))
|
|
return NULL;
|
|
_err = CreateNewWindow(windowClass,
|
|
attributes,
|
|
&bounds,
|
|
&outWindow);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
WinObj_WhichWindow, outWindow);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_CreateWindowFromResource(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
SInt16 resID;
|
|
WindowPtr outWindow;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&resID))
|
|
return NULL;
|
|
_err = CreateWindowFromResource(resID,
|
|
&outWindow);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
WinObj_WhichWindow, outWindow);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_ShowFloatingWindows(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = ShowFloatingWindows();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_HideFloatingWindows(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = HideFloatingWindows();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_AreFloatingWindowsVisible(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = AreFloatingWindowsVisible();
|
|
_res = Py_BuildValue("b",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_FrontNonFloatingWindow(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
WindowPtr _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = FrontNonFloatingWindow();
|
|
_res = Py_BuildValue("O&",
|
|
WinObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_SetDeskCPat(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
PixPatHandle deskPixPat;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &deskPixPat))
|
|
return NULL;
|
|
SetDeskCPat(deskPixPat);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_CheckUpdate(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean _rv;
|
|
EventRecord theEvent;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = CheckUpdate(&theEvent);
|
|
_res = Py_BuildValue("bO&",
|
|
_rv,
|
|
PyMac_BuildEventRecord, &theEvent);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_MacFindWindow(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
Point thePoint;
|
|
WindowPtr window;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetPoint, &thePoint))
|
|
return NULL;
|
|
_rv = MacFindWindow(thePoint,
|
|
&window);
|
|
_res = Py_BuildValue("hO&",
|
|
_rv,
|
|
WinObj_WhichWindow, window);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_FrontWindow(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
WindowPtr _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = FrontWindow();
|
|
_res = Py_BuildValue("O&",
|
|
WinObj_WhichWindow, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_InitWindows(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
InitWindows();
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_GetWMgrPort(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
GrafPtr wPort;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
GetWMgrPort(&wPort);
|
|
_res = Py_BuildValue("O&",
|
|
GrafObj_New, wPort);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_GetCWMgrPort(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
CGrafPtr wMgrCPort;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
GetCWMgrPort(&wMgrCPort);
|
|
_res = Py_BuildValue("O&",
|
|
GrafObj_New, wMgrCPort);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_IsValidWindowPtr(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Boolean _rv;
|
|
GrafPtr grafPort;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
GrafObj_Convert, &grafPort))
|
|
return NULL;
|
|
_rv = IsValidWindowPtr(grafPort);
|
|
_res = Py_BuildValue("b",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_InitFloatingWindows(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = InitFloatingWindows();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_InvalRect(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Rect badRect;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetRect, &badRect))
|
|
return NULL;
|
|
InvalRect(&badRect);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_InvalRgn(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
RgnHandle badRgn;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &badRgn))
|
|
return NULL;
|
|
InvalRgn(badRgn);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_ValidRect(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
Rect goodRect;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetRect, &goodRect))
|
|
return NULL;
|
|
ValidRect(&goodRect);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_ValidRgn(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
RgnHandle goodRgn;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
ResObj_Convert, &goodRgn))
|
|
return NULL;
|
|
ValidRgn(goodRgn);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_CollapseAllWindows(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
Boolean collapse;
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
&collapse))
|
|
return NULL;
|
|
_err = CollapseAllWindows(collapse);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_PinRect(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
long _rv;
|
|
Rect theRect;
|
|
Point thePt;
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
PyMac_GetRect, &theRect,
|
|
PyMac_GetPoint, &thePt))
|
|
return NULL;
|
|
_rv = PinRect(&theRect,
|
|
thePt);
|
|
_res = Py_BuildValue("l",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_GetGrayRgn(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
RgnHandle _rv;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetGrayRgn();
|
|
_res = Py_BuildValue("O&",
|
|
ResObj_New, _rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *Win_WhichWindow(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
|
|
long ptr;
|
|
|
|
if ( !PyArg_ParseTuple(_args, "i", &ptr) )
|
|
return NULL;
|
|
return WinObj_WhichWindow((WindowPtr)ptr);
|
|
|
|
}
|
|
|
|
static PyObject *Win_FindWindow(_self, _args)
|
|
PyObject *_self;
|
|
PyObject *_args;
|
|
{
|
|
PyObject *_res = NULL;
|
|
short _rv;
|
|
Point thePoint;
|
|
WindowPtr theWindow;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetPoint, &thePoint))
|
|
return NULL;
|
|
_rv = FindWindow(thePoint,
|
|
&theWindow);
|
|
_res = Py_BuildValue("hO&",
|
|
_rv,
|
|
WinObj_WhichWindow, theWindow);
|
|
return _res;
|
|
}
|
|
|
|
static PyMethodDef Win_methods[] = {
|
|
{"GetNewCWindow", (PyCFunction)Win_GetNewCWindow, 1,
|
|
"(short windowID, WindowPtr behind) -> (WindowPtr _rv)"},
|
|
{"NewWindow", (PyCFunction)Win_NewWindow, 1,
|
|
"(Rect boundsRect, Str255 title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)"},
|
|
{"GetNewWindow", (PyCFunction)Win_GetNewWindow, 1,
|
|
"(short windowID, WindowPtr behind) -> (WindowPtr _rv)"},
|
|
{"NewCWindow", (PyCFunction)Win_NewCWindow, 1,
|
|
"(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)"},
|
|
{"CreateNewWindow", (PyCFunction)Win_CreateNewWindow, 1,
|
|
"(WindowClass windowClass, WindowAttributes attributes, Rect bounds) -> (WindowPtr outWindow)"},
|
|
{"CreateWindowFromResource", (PyCFunction)Win_CreateWindowFromResource, 1,
|
|
"(SInt16 resID) -> (WindowPtr outWindow)"},
|
|
{"ShowFloatingWindows", (PyCFunction)Win_ShowFloatingWindows, 1,
|
|
"() -> None"},
|
|
{"HideFloatingWindows", (PyCFunction)Win_HideFloatingWindows, 1,
|
|
"() -> None"},
|
|
{"AreFloatingWindowsVisible", (PyCFunction)Win_AreFloatingWindowsVisible, 1,
|
|
"() -> (Boolean _rv)"},
|
|
{"FrontNonFloatingWindow", (PyCFunction)Win_FrontNonFloatingWindow, 1,
|
|
"() -> (WindowPtr _rv)"},
|
|
{"SetDeskCPat", (PyCFunction)Win_SetDeskCPat, 1,
|
|
"(PixPatHandle deskPixPat) -> None"},
|
|
{"CheckUpdate", (PyCFunction)Win_CheckUpdate, 1,
|
|
"() -> (Boolean _rv, EventRecord theEvent)"},
|
|
{"MacFindWindow", (PyCFunction)Win_MacFindWindow, 1,
|
|
"(Point thePoint) -> (short _rv, WindowPtr window)"},
|
|
{"FrontWindow", (PyCFunction)Win_FrontWindow, 1,
|
|
"() -> (WindowPtr _rv)"},
|
|
{"InitWindows", (PyCFunction)Win_InitWindows, 1,
|
|
"() -> None"},
|
|
{"GetWMgrPort", (PyCFunction)Win_GetWMgrPort, 1,
|
|
"() -> (GrafPtr wPort)"},
|
|
{"GetCWMgrPort", (PyCFunction)Win_GetCWMgrPort, 1,
|
|
"() -> (CGrafPtr wMgrCPort)"},
|
|
{"IsValidWindowPtr", (PyCFunction)Win_IsValidWindowPtr, 1,
|
|
"(GrafPtr grafPort) -> (Boolean _rv)"},
|
|
{"InitFloatingWindows", (PyCFunction)Win_InitFloatingWindows, 1,
|
|
"() -> None"},
|
|
{"InvalRect", (PyCFunction)Win_InvalRect, 1,
|
|
"(Rect badRect) -> None"},
|
|
{"InvalRgn", (PyCFunction)Win_InvalRgn, 1,
|
|
"(RgnHandle badRgn) -> None"},
|
|
{"ValidRect", (PyCFunction)Win_ValidRect, 1,
|
|
"(Rect goodRect) -> None"},
|
|
{"ValidRgn", (PyCFunction)Win_ValidRgn, 1,
|
|
"(RgnHandle goodRgn) -> None"},
|
|
{"CollapseAllWindows", (PyCFunction)Win_CollapseAllWindows, 1,
|
|
"(Boolean collapse) -> None"},
|
|
{"PinRect", (PyCFunction)Win_PinRect, 1,
|
|
"(Rect theRect, Point thePt) -> (long _rv)"},
|
|
{"GetGrayRgn", (PyCFunction)Win_GetGrayRgn, 1,
|
|
"() -> (RgnHandle _rv)"},
|
|
{"WhichWindow", (PyCFunction)Win_WhichWindow, 1,
|
|
"Resolve an integer WindowPtr address to a Window object"},
|
|
{"FindWindow", (PyCFunction)Win_FindWindow, 1,
|
|
"(Point thePoint) -> (short _rv, WindowPtr theWindow)"},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
|
|
|
|
/* Return the object corresponding to the window, or NULL */
|
|
|
|
PyObject *
|
|
WinObj_WhichWindow(w)
|
|
WindowPtr w;
|
|
{
|
|
PyObject *it;
|
|
|
|
/* XXX What if we find a stdwin window or a window belonging
|
|
to some other package? */
|
|
if (w == NULL)
|
|
it = NULL;
|
|
else
|
|
it = (PyObject *) GetWRefCon(w);
|
|
if (it == NULL || ((WindowObject *)it)->ob_itself != w)
|
|
it = Py_None;
|
|
Py_INCREF(it);
|
|
return it;
|
|
}
|
|
|
|
|
|
void initWin()
|
|
{
|
|
PyObject *m;
|
|
PyObject *d;
|
|
|
|
|
|
|
|
|
|
m = Py_InitModule("Win", Win_methods);
|
|
d = PyModule_GetDict(m);
|
|
Win_Error = PyMac_GetOSErrException();
|
|
if (Win_Error == NULL ||
|
|
PyDict_SetItemString(d, "Error", Win_Error) != 0)
|
|
Py_FatalError("can't initialize Win.Error");
|
|
Window_Type.ob_type = &PyType_Type;
|
|
Py_INCREF(&Window_Type);
|
|
if (PyDict_SetItemString(d, "WindowType", (PyObject *)&Window_Type) != 0)
|
|
Py_FatalError("can't initialize WindowType");
|
|
}
|
|
|
|
/* ========================= End module Win ========================= */
|
|
|