+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
)
functions.append(f)
+f = Function(UInt32, 'TickCount',
+)
+functions.append(f)
+
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
return _res;
}
-#if 0
+#if TARGET_API_MAC_OS8
static PyObject *TXNObj_TXNTSMCheck(TXNObjectObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
Boolean _rv;
- EventRecord iEvent;
+ EventRecord ioEvent;
#ifndef TXNTSMCheck
PyMac_PRECHECK(TXNTSMCheck);
#endif
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetEventRecord, &iEvent))
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TXNTSMCheck(_self->ob_itself,
- &iEvent);
- _res = Py_BuildValue("b",
- _rv);
+ &ioEvent);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ PyMac_BuildEventRecord, &ioEvent);
return _res;
}
#endif
{
PyObject *_res = NULL;
OSStatus _err;
- UInt32 iStartOffset;
- UInt32 iEndOffset;
+ TXNOffset iStartOffset;
+ TXNOffset iEndOffset;
ItemCount oRunCount;
#ifndef TXNCountRunsInRange
PyMac_PRECHECK(TXNCountRunsInRange);
{
PyObject *_res = NULL;
OSStatus _err;
- OSType iType;
+ TXNFileType iType;
OSType iResType;
TXNPermanentTextEncodingType iPermanentEncoding;
FSSpec iFileSpecification;
return _res;
}
+static PyObject *TXNObj_TXNSetViewRect(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect iViewRect;
+#ifndef TXNSetViewRect
+ PyMac_PRECHECK(TXNSetViewRect);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &iViewRect))
+ return NULL;
+ TXNSetViewRect(_self->ob_itself,
+ &iViewRect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *TXNObj_TXNAttachObjectToWindow(TXNObjectObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+static PyObject *TXNObj_TXNPointToOffset(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Point iPoint;
+ TXNOffset oOffset;
+#ifndef TXNPointToOffset
+ PyMac_PRECHECK(TXNPointToOffset);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &iPoint))
+ return NULL;
+ _err = TXNPointToOffset(_self->ob_itself,
+ iPoint,
+ &oOffset);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ oOffset);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNOffsetToPoint(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ TXNOffset iOffset;
+ Point oPoint;
+#ifndef TXNOffsetToPoint
+ PyMac_PRECHECK(TXNOffsetToPoint);
+#endif
+ if (!PyArg_ParseTuple(_args, "l",
+ &iOffset))
+ return NULL;
+ _err = TXNOffsetToPoint(_self->ob_itself,
+ iOffset,
+ &oPoint);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, oPoint);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNGetLineCount(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ItemCount oLineTotal;
+#ifndef TXNGetLineCount
+ PyMac_PRECHECK(TXNGetLineCount);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = TXNGetLineCount(_self->ob_itself,
+ &oLineTotal);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ oLineTotal);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNGetLineMetrics(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ UInt32 iLineNumber;
+ Fixed oLineWidth;
+ Fixed oLineHeight;
+#ifndef TXNGetLineMetrics
+ PyMac_PRECHECK(TXNGetLineMetrics);
+#endif
+ if (!PyArg_ParseTuple(_args, "l",
+ &iLineNumber))
+ return NULL;
+ _err = TXNGetLineMetrics(_self->ob_itself,
+ iLineNumber,
+ &oLineWidth,
+ &oLineHeight);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&",
+ PyMac_BuildFixed, oLineWidth,
+ PyMac_BuildFixed, oLineHeight);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNIsObjectAttachedToSpecificWindow(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowPtr iWindow;
+ Boolean oAttached;
+#ifndef TXNIsObjectAttachedToSpecificWindow
+ PyMac_PRECHECK(TXNIsObjectAttachedToSpecificWindow);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &iWindow))
+ return NULL;
+ _err = TXNIsObjectAttachedToSpecificWindow(_self->ob_itself,
+ iWindow,
+ &oAttached);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("b",
+ oAttached);
+ return _res;
+}
+
static PyMethodDef TXNObj_methods[] = {
{"TXNDeleteObject", (PyCFunction)TXNObj_TXNDeleteObject, 1,
"() -> None"},
{"TXNClick", (PyCFunction)TXNObj_TXNClick, 1,
"(EventRecord iEvent) -> None"},
-#if 0
+#if TARGET_API_MAC_OS8
{"TXNTSMCheck", (PyCFunction)TXNObj_TXNTSMCheck, 1,
- "(EventRecord iEvent) -> (Boolean _rv)"},
+ "() -> (Boolean _rv, EventRecord ioEvent)"},
#endif
{"TXNSelectAll", (PyCFunction)TXNObj_TXNSelectAll, 1,
"() -> None"},
{"TXNSetSelection", (PyCFunction)TXNObj_TXNSetSelection, 1,
"(TXNOffset iStartOffset, TXNOffset iEndOffset) -> None"},
{"TXNCountRunsInRange", (PyCFunction)TXNObj_TXNCountRunsInRange, 1,
- "(UInt32 iStartOffset, UInt32 iEndOffset) -> (ItemCount oRunCount)"},
+ "(TXNOffset iStartOffset, TXNOffset iEndOffset) -> (ItemCount oRunCount)"},
{"TXNDataSize", (PyCFunction)TXNObj_TXNDataSize, 1,
"() -> (ByteCount _rv)"},
{"TXNGetData", (PyCFunction)TXNObj_TXNGetData, 1,
{"TXNGetChangeCount", (PyCFunction)TXNObj_TXNGetChangeCount, 1,
"() -> (ItemCount _rv)"},
{"TXNSave", (PyCFunction)TXNObj_TXNSave, 1,
- "(OSType iType, OSType iResType, TXNPermanentTextEncodingType iPermanentEncoding, FSSpec iFileSpecification, SInt16 iDataReference, SInt16 iResourceReference) -> None"},
+ "(TXNFileType iType, OSType iResType, TXNPermanentTextEncodingType iPermanentEncoding, FSSpec iFileSpecification, SInt16 iDataReference, SInt16 iResourceReference) -> None"},
{"TXNRevert", (PyCFunction)TXNObj_TXNRevert, 1,
"() -> None"},
{"TXNPageSetup", (PyCFunction)TXNObj_TXNPageSetup, 1,
"() -> None"},
{"TXNGetViewRect", (PyCFunction)TXNObj_TXNGetViewRect, 1,
"() -> (Rect oViewRect)"},
+ {"TXNSetViewRect", (PyCFunction)TXNObj_TXNSetViewRect, 1,
+ "(Rect iViewRect) -> None"},
{"TXNAttachObjectToWindow", (PyCFunction)TXNObj_TXNAttachObjectToWindow, 1,
"(GWorldPtr iWindow, Boolean iIsActualWindow) -> None"},
{"TXNIsObjectAttachedToWindow", (PyCFunction)TXNObj_TXNIsObjectAttachedToWindow, 1,
"(TXNFontMenuObject iTXNFontMenuObject, SInt16 iMenuID, SInt16 iMenuItem) -> None"},
{"TXNPrepareFontMenu", (PyCFunction)TXNObj_TXNPrepareFontMenu, 1,
"(TXNFontMenuObject iTXNFontMenuObject) -> None"},
+ {"TXNPointToOffset", (PyCFunction)TXNObj_TXNPointToOffset, 1,
+ "(Point iPoint) -> (TXNOffset oOffset)"},
+ {"TXNOffsetToPoint", (PyCFunction)TXNObj_TXNOffsetToPoint, 1,
+ "(TXNOffset iOffset) -> (Point oPoint)"},
+ {"TXNGetLineCount", (PyCFunction)TXNObj_TXNGetLineCount, 1,
+ "() -> (ItemCount oLineTotal)"},
+ {"TXNGetLineMetrics", (PyCFunction)TXNObj_TXNGetLineMetrics, 1,
+ "(UInt32 iLineNumber) -> (Fixed oLineWidth, Fixed oLineHeight)"},
+ {"TXNIsObjectAttachedToSpecificWindow", (PyCFunction)TXNObj_TXNIsObjectAttachedToSpecificWindow, 1,
+ "(WindowPtr iWindow) -> (Boolean oAttached)"},
{NULL, NULL, 0}
};
def makegreylist(self):
return [
- ('#if !TARGET_API_MAC_OSX', [
+ ('#if TARGET_API_MAC_OS8', [
'TXNTSMCheck',
])]
"TXNMatchTextRecord", #TBD
"TXNBackground", #TBD
"UniChar", #TBD
+ "UniCharCount", #TBD
+ "UniChar_ptr", #TBD
"TXNFindUPP",
+ "ATSUStyle", #TBD
+ "TXNActionKeyMapperProcPtr",
+ "TXNActionKeyMapperUPP",
+ "TXNTextBoxOptionsData",
+ "TXNCountOptions",
]
def makerepairinstructions(self):
GWorldPtr = OpaqueByValueType("GWorldPtr", "GWorldObj")
OptGWorldPtr = OpaqueByValueType("GWorldPtr", "OptGWorldObj")
MlteInBuffer = VarInputBufferType('void *', 'ByteCount', 'l')
+CFStringRef = OpaqueByValueType("CFStringRef", "CFStringRefObj")
OptFSSpecPtr = OpaqueByValueType("FSSpec *", "OptFSSpecPtr")
OptRectPtr = OpaqueByValueType("Rect *", "OptRectPtr")
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
return _res;
}
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Qd_RgnToHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle region;
+ Handle flattenedRgnDataHdl;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, ®ion,
+ ResObj_Convert, &flattenedRgnDataHdl))
+ return NULL;
+ RgnToHandle(region,
+ flattenedRgnDataHdl);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
static PyObject *Qd_DisposeRgn(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Qd_IsValidPort(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = IsValidPort(port);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
static PyObject *Qd_GetPortPixMap(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
#if TARGET_API_MAC_CARBON
+static PyObject *Qd_IsPortPolyBeingDefined(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = IsPortPolyBeingDefined(port);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
static PyObject *Qd_IsPortOffscreen(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+static PyObject *Qd_SetPortFillPixPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ PixPatHandle penPattern;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ ResObj_Convert, &penPattern))
+ return NULL;
+ SetPortFillPixPat(port,
+ penPattern);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *Qd_SetPortBackPixPat(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Qd_QDGetDirtyRegion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ CGrafPtr port;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ ResObj_Convert, &rgn))
+ return NULL;
+ _err = QDGetDirtyRegion(port,
+ rgn);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Qd_QDSetDirtyRegion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ CGrafPtr port;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ ResObj_Convert, &rgn))
+ return NULL;
+ _err = QDSetDirtyRegion(port,
+ rgn);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Qd_LMGetScrVRes(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetScrVRes();
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_LMSetScrVRes(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 value;
+ if (!PyArg_ParseTuple(_args, "h",
+ &value))
+ return NULL;
+ LMSetScrVRes(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_LMGetScrHRes(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetScrHRes();
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_LMSetScrHRes(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 value;
+ if (!PyArg_ParseTuple(_args, "h",
+ &value))
+ return NULL;
+ LMSetScrHRes(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_LMGetMainDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetMainDevice();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_LMSetMainDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle value;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &value))
+ return NULL;
+ LMSetMainDevice(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_LMGetDeviceList(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetDeviceList();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_LMSetDeviceList(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle value;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &value))
+ return NULL;
+ LMSetDeviceList(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_LMGetQDColors(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetQDColors();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_LMSetQDColors(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle value;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &value))
+ return NULL;
+ LMSetQDColors(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_LMGetWidthListHand(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetWidthListHand();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_LMSetWidthListHand(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle value;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &value))
+ return NULL;
+ LMSetWidthListHand(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_LMGetHiliteMode(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt8 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetHiliteMode();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_LMSetHiliteMode(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt8 value;
+ if (!PyArg_ParseTuple(_args, "b",
+ &value))
+ return NULL;
+ LMSetHiliteMode(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_LMGetWidthTabHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetWidthTabHandle();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_LMSetWidthTabHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle value;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &value))
+ return NULL;
+ LMSetWidthTabHandle(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_LMGetLastSPExtra(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetLastSPExtra();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_LMSetLastSPExtra(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 value;
+ if (!PyArg_ParseTuple(_args, "l",
+ &value))
+ return NULL;
+ LMSetLastSPExtra(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_LMGetLastFOND(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetLastFOND();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_LMSetLastFOND(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle value;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &value))
+ return NULL;
+ LMSetLastFOND(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_LMGetFractEnable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt8 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetFractEnable();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_LMSetFractEnable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt8 value;
+ if (!PyArg_ParseTuple(_args, "b",
+ &value))
+ return NULL;
+ LMSetFractEnable(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_LMGetTheGDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetTheGDevice();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_LMSetTheGDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle value;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &value))
+ return NULL;
+ LMSetTheGDevice(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_LMGetHiliteRGB(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RGBColor hiliteRGBValue;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ LMGetHiliteRGB(&hiliteRGBValue);
+ _res = Py_BuildValue("O&",
+ QdRGB_New, &hiliteRGBValue);
+ return _res;
+}
+
+static PyObject *Qd_LMSetHiliteRGB(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RGBColor hiliteRGBValue;
+ if (!PyArg_ParseTuple(_args, "O&",
+ QdRGB_Convert, &hiliteRGBValue))
+ return NULL;
+ LMSetHiliteRGB(&hiliteRGBValue);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_LMGetCursorNew(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetCursorNew();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_LMSetCursorNew(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean value;
+ if (!PyArg_ParseTuple(_args, "b",
+ &value))
+ return NULL;
+ LMSetCursorNew(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *Qd_TextFont(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+static PyObject *Qd_TruncString(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ short width;
+ Str255 theString;
+ TruncCode truncWhere;
+ if (!PyArg_ParseTuple(_args, "hO&h",
+ &width,
+ PyMac_GetStr255, theString,
+ &truncWhere))
+ return NULL;
+ _rv = TruncString(width,
+ theString,
+ truncWhere);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
static PyObject *Qd_SetPort(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
"(RgnHandle dstRgn) -> None"},
{"BitMapToRegion", (PyCFunction)Qd_BitMapToRegion, 1,
"(RgnHandle region, BitMapPtr bMap) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"RgnToHandle", (PyCFunction)Qd_RgnToHandle, 1,
+ "(RgnHandle region, Handle flattenedRgnDataHdl) -> None"},
+#endif
{"DisposeRgn", (PyCFunction)Qd_DisposeRgn, 1,
"(RgnHandle rgn) -> None"},
{"MacCopyRgn", (PyCFunction)Qd_MacCopyRgn, 1,
"(short angle) -> (Fixed _rv)"},
{"AngleFromSlope", (PyCFunction)Qd_AngleFromSlope, 1,
"(Fixed slope) -> (short _rv)"},
+
+#if TARGET_API_MAC_CARBON
+ {"IsValidPort", (PyCFunction)Qd_IsValidPort, 1,
+ "(CGrafPtr port) -> (Boolean _rv)"},
+#endif
{"GetPortPixMap", (PyCFunction)Qd_GetPortPixMap, 1,
"(CGrafPtr port) -> (PixMapHandle _rv)"},
{"GetPortBitMapForCopyBits", (PyCFunction)Qd_GetPortBitMapForCopyBits, 1,
{"IsPortPictureBeingDefined", (PyCFunction)Qd_IsPortPictureBeingDefined, 1,
"(CGrafPtr port) -> (Boolean _rv)"},
+#if TARGET_API_MAC_CARBON
+ {"IsPortPolyBeingDefined", (PyCFunction)Qd_IsPortPolyBeingDefined, 1,
+ "(CGrafPtr port) -> (Boolean _rv)"},
+#endif
+
#if TARGET_API_MAC_CARBON
{"IsPortOffscreen", (PyCFunction)Qd_IsPortOffscreen, 1,
"(CGrafPtr port) -> (Boolean _rv)"},
"(CGrafPtr port, RgnHandle clipRgn) -> None"},
{"SetPortPenPixPat", (PyCFunction)Qd_SetPortPenPixPat, 1,
"(CGrafPtr port, PixPatHandle penPattern) -> None"},
+ {"SetPortFillPixPat", (PyCFunction)Qd_SetPortFillPixPat, 1,
+ "(CGrafPtr port, PixPatHandle penPattern) -> None"},
{"SetPortBackPixPat", (PyCFunction)Qd_SetPortBackPixPat, 1,
"(CGrafPtr port, PixPatHandle backPattern) -> None"},
{"SetPortPenSize", (PyCFunction)Qd_SetPortPenSize, 1,
"(CGrafPtr port) -> (Boolean _rv)"},
{"QDFlushPortBuffer", (PyCFunction)Qd_QDFlushPortBuffer, 1,
"(CGrafPtr port, RgnHandle region) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"QDGetDirtyRegion", (PyCFunction)Qd_QDGetDirtyRegion, 1,
+ "(CGrafPtr port, RgnHandle rgn) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"QDSetDirtyRegion", (PyCFunction)Qd_QDSetDirtyRegion, 1,
+ "(CGrafPtr port, RgnHandle rgn) -> None"},
+#endif
+ {"LMGetScrVRes", (PyCFunction)Qd_LMGetScrVRes, 1,
+ "() -> (SInt16 _rv)"},
+ {"LMSetScrVRes", (PyCFunction)Qd_LMSetScrVRes, 1,
+ "(SInt16 value) -> None"},
+ {"LMGetScrHRes", (PyCFunction)Qd_LMGetScrHRes, 1,
+ "() -> (SInt16 _rv)"},
+ {"LMSetScrHRes", (PyCFunction)Qd_LMSetScrHRes, 1,
+ "(SInt16 value) -> None"},
+ {"LMGetMainDevice", (PyCFunction)Qd_LMGetMainDevice, 1,
+ "() -> (GDHandle _rv)"},
+ {"LMSetMainDevice", (PyCFunction)Qd_LMSetMainDevice, 1,
+ "(GDHandle value) -> None"},
+ {"LMGetDeviceList", (PyCFunction)Qd_LMGetDeviceList, 1,
+ "() -> (GDHandle _rv)"},
+ {"LMSetDeviceList", (PyCFunction)Qd_LMSetDeviceList, 1,
+ "(GDHandle value) -> None"},
+ {"LMGetQDColors", (PyCFunction)Qd_LMGetQDColors, 1,
+ "() -> (Handle _rv)"},
+ {"LMSetQDColors", (PyCFunction)Qd_LMSetQDColors, 1,
+ "(Handle value) -> None"},
+ {"LMGetWidthListHand", (PyCFunction)Qd_LMGetWidthListHand, 1,
+ "() -> (Handle _rv)"},
+ {"LMSetWidthListHand", (PyCFunction)Qd_LMSetWidthListHand, 1,
+ "(Handle value) -> None"},
+ {"LMGetHiliteMode", (PyCFunction)Qd_LMGetHiliteMode, 1,
+ "() -> (UInt8 _rv)"},
+ {"LMSetHiliteMode", (PyCFunction)Qd_LMSetHiliteMode, 1,
+ "(UInt8 value) -> None"},
+ {"LMGetWidthTabHandle", (PyCFunction)Qd_LMGetWidthTabHandle, 1,
+ "() -> (Handle _rv)"},
+ {"LMSetWidthTabHandle", (PyCFunction)Qd_LMSetWidthTabHandle, 1,
+ "(Handle value) -> None"},
+ {"LMGetLastSPExtra", (PyCFunction)Qd_LMGetLastSPExtra, 1,
+ "() -> (SInt32 _rv)"},
+ {"LMSetLastSPExtra", (PyCFunction)Qd_LMSetLastSPExtra, 1,
+ "(SInt32 value) -> None"},
+ {"LMGetLastFOND", (PyCFunction)Qd_LMGetLastFOND, 1,
+ "() -> (Handle _rv)"},
+ {"LMSetLastFOND", (PyCFunction)Qd_LMSetLastFOND, 1,
+ "(Handle value) -> None"},
+ {"LMGetFractEnable", (PyCFunction)Qd_LMGetFractEnable, 1,
+ "() -> (UInt8 _rv)"},
+ {"LMSetFractEnable", (PyCFunction)Qd_LMSetFractEnable, 1,
+ "(UInt8 value) -> None"},
+ {"LMGetTheGDevice", (PyCFunction)Qd_LMGetTheGDevice, 1,
+ "() -> (GDHandle _rv)"},
+ {"LMSetTheGDevice", (PyCFunction)Qd_LMSetTheGDevice, 1,
+ "(GDHandle value) -> None"},
+ {"LMGetHiliteRGB", (PyCFunction)Qd_LMGetHiliteRGB, 1,
+ "() -> (RGBColor hiliteRGBValue)"},
+ {"LMSetHiliteRGB", (PyCFunction)Qd_LMSetHiliteRGB, 1,
+ "(RGBColor hiliteRGBValue) -> None"},
+ {"LMGetCursorNew", (PyCFunction)Qd_LMGetCursorNew, 1,
+ "() -> (Boolean _rv)"},
+ {"LMSetCursorNew", (PyCFunction)Qd_LMSetCursorNew, 1,
+ "(Boolean value) -> None"},
{"TextFont", (PyCFunction)Qd_TextFont, 1,
"(short font) -> None"},
{"TextFace", (PyCFunction)Qd_TextFace, 1,
"() -> (FontInfo info)"},
{"CharExtra", (PyCFunction)Qd_CharExtra, 1,
"(Fixed extra) -> None"},
+ {"TruncString", (PyCFunction)Qd_TruncString, 1,
+ "(short width, Str255 theString, TruncCode truncWhere) -> (short _rv)"},
{"SetPort", (PyCFunction)Qd_SetPort, 1,
"(GrafPtr thePort) -> None"},
{"GetCursor", (PyCFunction)Qd_GetCursor, 1,
'CreateNewPort',
'DisposePort',
'SetQDError',
+ 'IsPortPolyBeingDefined',
+ 'QDSetDirtyRegion',
+ 'QDGetDirtyRegion',
+ 'IsValidPort',
+ 'RgnToHandle',
])]
Pattern_ptr = StructInputBufferType('Pattern')
PenState = StructOutputBufferType('PenState')
PenState_ptr = StructInputBufferType('PenState')
+TruncCode = Type("TruncCode", "h")
includestuff = includestuff + """
#ifdef WITHOUT_FRAMEWORKS
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
return _res;
}
+static PyObject *MovieCtlObj_MCAddMovieSegment(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Movie srcMovie;
+ Boolean scaled;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ MovieObj_Convert, &srcMovie,
+ &scaled))
+ return NULL;
+ _rv = MCAddMovieSegment(_self->ob_itself,
+ srcMovie,
+ scaled);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCTrimMovieSegment(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCTrimMovieSegment(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
static PyMethodDef MovieCtlObj_methods[] = {
{"MCSetMovie", (PyCFunction)MovieCtlObj_MCSetMovie, 1,
"(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)"},
"(WindowPtr w, Point where, long modifiers) -> (ComponentResult _rv)"},
{"MCGetInterfaceElement", (PyCFunction)MovieCtlObj_MCGetInterfaceElement, 1,
"(MCInterfaceElement whichElement, void * element) -> (ComponentResult _rv)"},
+ {"MCAddMovieSegment", (PyCFunction)MovieCtlObj_MCAddMovieSegment, 1,
+ "(Movie srcMovie, Boolean scaled) -> (ComponentResult _rv)"},
+ {"MCTrimMovieSegment", (PyCFunction)MovieCtlObj_MCTrimMovieSegment, 1,
+ "() -> (ComponentResult _rv)"},
{NULL, NULL, 0}
};
return _res;
}
+static PyObject *TrackObj_AddClonedTrackToMovie(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Movie dstMovie;
+ long flags;
+ Track dstTrack;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ MovieObj_Convert, &dstMovie,
+ &flags))
+ return NULL;
+ _err = AddClonedTrackToMovie(_self->ob_itself,
+ dstMovie,
+ flags,
+ &dstTrack);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ TrackObj_New, dstTrack);
+ return _res;
+}
+
static PyObject *TrackObj_AddTrackReference(TrackObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
"(Track dstTrack) -> None"},
{"AddEmptyTrackToMovie", (PyCFunction)TrackObj_AddEmptyTrackToMovie, 1,
"(Movie dstMovie, Handle dataRef, OSType dataRefType) -> (Track dstTrack)"},
+ {"AddClonedTrackToMovie", (PyCFunction)TrackObj_AddClonedTrackToMovie, 1,
+ "(Movie dstMovie, long flags) -> (Track dstTrack)"},
{"AddTrackReference", (PyCFunction)TrackObj_AddTrackReference, 1,
"(Track refTrack, OSType refType) -> (long addedIndex)"},
{"DeleteTrackReference", (PyCFunction)TrackObj_DeleteTrackReference, 1,
return _res;
}
+static PyObject *MovieObj_SetMovieVideoOutput(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentInstance vout;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &vout))
+ return NULL;
+ SetMovieVideoOutput(_self->ob_itself,
+ vout);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *MovieObj_PutMovieIntoHandle(MovieObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
"() -> (RgnHandle _rv)"},
{"GetMovieBoundsRgn", (PyCFunction)MovieObj_GetMovieBoundsRgn, 1,
"() -> (RgnHandle _rv)"},
+ {"SetMovieVideoOutput", (PyCFunction)MovieObj_SetMovieVideoOutput, 1,
+ "(ComponentInstance vout) -> None"},
{"PutMovieIntoHandle", (PyCFunction)MovieObj_PutMovieIntoHandle, 1,
"(Handle publicMovie) -> None"},
{"PutMovieIntoDataFork", (PyCFunction)MovieObj_PutMovieIntoDataFork, 1,
return _res;
}
+static PyObject *Qt_QTGetMIMETypeInfo(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ char* mimeStringStart;
+ short mimeStringLength;
+ OSType infoSelector;
+ void * infoDataPtr;
+ long infoDataSize;
+ if (!PyArg_ParseTuple(_args, "shO&s",
+ &mimeStringStart,
+ &mimeStringLength,
+ PyMac_GetOSType, &infoSelector,
+ &infoDataPtr))
+ return NULL;
+ _err = QTGetMIMETypeInfo(mimeStringStart,
+ mimeStringLength,
+ infoSelector,
+ infoDataPtr,
+ &infoDataSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ infoDataSize);
+ return _res;
+}
+
static PyObject *Qt_TrackTimeToMediaTime(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+static PyObject *Qt_CanQuickTimeOpenFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ FSSpec fileSpec;
+ OSType fileType;
+ OSType fileNameExtension;
+ Boolean outCanOpenWithGraphicsImporter;
+ Boolean outCanOpenAsMovie;
+ Boolean outPreferGraphicsImporter;
+ UInt32 inFlags;
+ if (!PyArg_ParseTuple(_args, "O&O&O&l",
+ PyMac_GetFSSpec, &fileSpec,
+ PyMac_GetOSType, &fileType,
+ PyMac_GetOSType, &fileNameExtension,
+ &inFlags))
+ return NULL;
+ _err = CanQuickTimeOpenFile(&fileSpec,
+ fileType,
+ fileNameExtension,
+ &outCanOpenWithGraphicsImporter,
+ &outCanOpenAsMovie,
+ &outPreferGraphicsImporter,
+ inFlags);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("bbb",
+ outCanOpenWithGraphicsImporter,
+ outCanOpenAsMovie,
+ outPreferGraphicsImporter);
+ return _res;
+}
+
+static PyObject *Qt_CanQuickTimeOpenDataRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle dataRef;
+ OSType dataRefType;
+ Boolean outCanOpenWithGraphicsImporter;
+ Boolean outCanOpenAsMovie;
+ Boolean outPreferGraphicsImporter;
+ UInt32 inFlags;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType,
+ &inFlags))
+ return NULL;
+ _err = CanQuickTimeOpenDataRef(dataRef,
+ dataRefType,
+ &outCanOpenWithGraphicsImporter,
+ &outCanOpenAsMovie,
+ &outPreferGraphicsImporter,
+ inFlags);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("bbb",
+ outCanOpenWithGraphicsImporter,
+ outCanOpenAsMovie,
+ outPreferGraphicsImporter);
+ return _res;
+}
+
static PyObject *Qt_NewMovieFromScrap(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+static PyObject *Qt_TextMediaGetTextProperty(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ TimeValue atMediaTime;
+ long propertyType;
+ void * data;
+ long dataSize;
+ if (!PyArg_ParseTuple(_args, "O&llsl",
+ CmpInstObj_Convert, &mh,
+ &atMediaTime,
+ &propertyType,
+ &data,
+ &dataSize))
+ return NULL;
+ _rv = TextMediaGetTextProperty(mh,
+ atMediaTime,
+ propertyType,
+ data,
+ dataSize);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
static PyObject *Qt_TextMediaFindNextText(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+static PyObject *Qt_FlashMediaGetFlashVariable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ char path;
+ char name;
+ Handle theVariableCStringOut;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mh))
+ return NULL;
+ _rv = FlashMediaGetFlashVariable(mh,
+ &path,
+ &name,
+ &theVariableCStringOut);
+ _res = Py_BuildValue("lccO&",
+ _rv,
+ path,
+ name,
+ ResObj_New, theVariableCStringOut);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaSetFlashVariable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ char path;
+ char name;
+ char value;
+ Boolean updateFocus;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ CmpInstObj_Convert, &mh,
+ &updateFocus))
+ return NULL;
+ _rv = FlashMediaSetFlashVariable(mh,
+ &path,
+ &name,
+ &value,
+ updateFocus);
+ _res = Py_BuildValue("lccc",
+ _rv,
+ path,
+ name,
+ value);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaDoButtonActions(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ char path;
+ long buttonID;
+ long transition;
+ if (!PyArg_ParseTuple(_args, "O&ll",
+ CmpInstObj_Convert, &mh,
+ &buttonID,
+ &transition))
+ return NULL;
+ _rv = FlashMediaDoButtonActions(mh,
+ &path,
+ buttonID,
+ transition);
+ _res = Py_BuildValue("lc",
+ _rv,
+ path);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaGetSupportedSwfVersion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ UInt8 swfVersion;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mh))
+ return NULL;
+ _rv = FlashMediaGetSupportedSwfVersion(mh,
+ &swfVersion);
+ _res = Py_BuildValue("lb",
+ _rv,
+ swfVersion);
+ return _res;
+}
+
#if !TARGET_API_MAC_CARBON
static PyObject *Qt_MovieMediaGetCurrentMovieProperty(PyObject *_self, PyObject *_args)
static PyObject *Qt_ConvertTime(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
- TimeRecord inout;
+ TimeRecord theTime;
TimeBase newBase;
- if (!PyArg_ParseTuple(_args, "O&O&",
- QtTimeRecord_Convert, &inout,
+ if (!PyArg_ParseTuple(_args, "O&",
TimeBaseObj_Convert, &newBase))
return NULL;
- ConvertTime(&inout,
+ ConvertTime(&theTime,
newBase);
_res = Py_BuildValue("O&",
- QtTimeRecord_New, &inout);
+ QtTimeRecord_New, &theTime);
return _res;
}
static PyObject *Qt_ConvertTimeScale(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
- TimeRecord inout;
+ TimeRecord theTime;
TimeScale newScale;
- if (!PyArg_ParseTuple(_args, "O&l",
- QtTimeRecord_Convert, &inout,
+ if (!PyArg_ParseTuple(_args, "l",
&newScale))
return NULL;
- ConvertTimeScale(&inout,
+ ConvertTimeScale(&theTime,
newScale);
_res = Py_BuildValue("O&",
- QtTimeRecord_New, &inout);
+ QtTimeRecord_New, &theTime);
return _res;
}
"(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None"},
{"GetMovieImporterForDataRef", (PyCFunction)Qt_GetMovieImporterForDataRef, 1,
"(OSType dataRefType, Handle dataRef, long flags) -> (Component importer)"},
+ {"QTGetMIMETypeInfo", (PyCFunction)Qt_QTGetMIMETypeInfo, 1,
+ "(char* mimeStringStart, short mimeStringLength, OSType infoSelector, void * infoDataPtr) -> (long infoDataSize)"},
{"TrackTimeToMediaTime", (PyCFunction)Qt_TrackTimeToMediaTime, 1,
"(TimeValue value, Track theTrack) -> (TimeValue _rv)"},
{"NewUserData", (PyCFunction)Qt_NewUserData, 1,
"(short resRefNum, short resId) -> None"},
{"CreateShortcutMovieFile", (PyCFunction)Qt_CreateShortcutMovieFile, 1,
"(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Handle targetDataRef, OSType targetDataRefType) -> None"},
+ {"CanQuickTimeOpenFile", (PyCFunction)Qt_CanQuickTimeOpenFile, 1,
+ "(FSSpec fileSpec, OSType fileType, OSType fileNameExtension, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)"},
+ {"CanQuickTimeOpenDataRef", (PyCFunction)Qt_CanQuickTimeOpenDataRef, 1,
+ "(Handle dataRef, OSType dataRefType, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)"},
{"NewMovieFromScrap", (PyCFunction)Qt_NewMovieFromScrap, 1,
"(long newMovieFlags) -> (Movie _rv)"},
{"QTNewAlias", (PyCFunction)Qt_QTNewAlias, 1,
"(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh, TimeValue sampleDuration) -> (ComponentResult _rv)"},
{"TextMediaRawIdle", (PyCFunction)Qt_TextMediaRawIdle, 1,
"(MediaHandler mh, GWorldPtr gw, GDHandle gd, TimeValue sampleTime, long flagsIn) -> (ComponentResult _rv, long flagsOut)"},
+ {"TextMediaGetTextProperty", (PyCFunction)Qt_TextMediaGetTextProperty, 1,
+ "(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)"},
{"TextMediaFindNextText", (PyCFunction)Qt_TextMediaFindNextText, 1,
"(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)"},
{"TextMediaHiliteTextSample", (PyCFunction)Qt_TextMediaHiliteTextSample, 1,
"(MediaHandler mh, long flashFrameNumber) -> (ComponentResult _rv, TimeValue movieTime)"},
{"FlashMediaFrameLabelToMovieTime", (PyCFunction)Qt_FlashMediaFrameLabelToMovieTime, 1,
"(MediaHandler mh, Ptr theLabel) -> (ComponentResult _rv, TimeValue movieTime)"},
+ {"FlashMediaGetFlashVariable", (PyCFunction)Qt_FlashMediaGetFlashVariable, 1,
+ "(MediaHandler mh) -> (ComponentResult _rv, char path, char name, Handle theVariableCStringOut)"},
+ {"FlashMediaSetFlashVariable", (PyCFunction)Qt_FlashMediaSetFlashVariable, 1,
+ "(MediaHandler mh, Boolean updateFocus) -> (ComponentResult _rv, char path, char name, char value)"},
+ {"FlashMediaDoButtonActions", (PyCFunction)Qt_FlashMediaDoButtonActions, 1,
+ "(MediaHandler mh, long buttonID, long transition) -> (ComponentResult _rv, char path)"},
+ {"FlashMediaGetSupportedSwfVersion", (PyCFunction)Qt_FlashMediaGetSupportedSwfVersion, 1,
+ "(MediaHandler mh) -> (ComponentResult _rv, UInt8 swfVersion)"},
#if !TARGET_API_MAC_CARBON
{"MovieMediaGetCurrentMovieProperty", (PyCFunction)Qt_MovieMediaGetCurrentMovieProperty, 1,
{"NewTimeBase", (PyCFunction)Qt_NewTimeBase, 1,
"() -> (TimeBase _rv)"},
{"ConvertTime", (PyCFunction)Qt_ConvertTime, 1,
- "(TimeRecord inout, TimeBase newBase) -> (TimeRecord inout)"},
+ "(TimeBase newBase) -> (TimeRecord theTime)"},
{"ConvertTimeScale", (PyCFunction)Qt_ConvertTimeScale, 1,
- "(TimeRecord inout, TimeScale newScale) -> (TimeRecord inout)"},
+ "(TimeScale newScale) -> (TimeRecord theTime)"},
{"AddTime", (PyCFunction)Qt_AddTime, 1,
"(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)"},
{"SubtractTime", (PyCFunction)Qt_SubtractTime, 1,
# AddTime and SubtractTime
([('TimeRecord', 'dst', 'OutMode')], [('TimeRecord', 'dst', 'InOutMode')]),
+
+ # Funny definitions
+ ([('char_ptr', '*', 'InMode')], [('stringptr', '*', 'InMode')]),
+ ([('FSSpecPtr', '*', 'InMode')], [('FSSpec_ptr', '*', 'InMode')]),
+ ([('unsigned_char', 'swfVersion', 'OutMode')], [('UInt8', 'swfVersion', 'OutMode')]),
]
if __name__ == "__main__":
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
}
#endif
+static PyObject *Res_FSOpenResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ FSRef ref;
+ SignedByte permission;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ PyMac_GetFSRef, &ref,
+ &permission))
+ return NULL;
+ _rv = FSOpenResFile(&ref,
+ permission);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_FSResourceFileAlreadyOpen(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ FSRef resourceFileRef;
+ Boolean inChain;
+ SInt16 refNum;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFSRef, &resourceFileRef))
+ return NULL;
+ _rv = FSResourceFileAlreadyOpen(&resourceFileRef,
+ &inChain,
+ &refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("bbh",
+ _rv,
+ inChain,
+ refNum);
+ return _res;
+}
+
static PyObject *Res_Resource(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
{"GetNextResourceFile", (PyCFunction)Res_GetNextResourceFile, 1,
"(SInt16 curRefNum) -> (OSErr _rv, SInt16 nextRefNum)"},
#endif
+ {"FSOpenResFile", (PyCFunction)Res_FSOpenResFile, 1,
+ "(FSRef ref, SignedByte permission) -> (short _rv)"},
+ {"FSResourceFileAlreadyOpen", (PyCFunction)Res_FSResourceFileAlreadyOpen, 1,
+ "(FSRef resourceFileRef) -> (Boolean _rv, Boolean inChain, SInt16 refNum)"},
{"Resource", (PyCFunction)Res_Resource, 1,
"Convert a string to a resource object.\n\nThe created resource object is actually just a handle,\napply AddResource() to write it to a resource file.\nSee also the Handle() docstring.\n"},
{"Handle", (PyCFunction)Res_Handle, 1,
## "MaxSizeRsrc", # GetMaxResourceSize
]
+ def makeblacklisttypes(self):
+ return [
+ "UniCharCount", #TBD
+ ]
+
def makegreylist(self):
return [
('#if TARGET_API_MAC_OS8', [
from macsupport import *
+FSRef_ptr = OpaqueType("FSRef", "PyMac_BuildFSRef", "PyMac_GetFSRef")
class ResMixIn:
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
#include "macglue.h"
#include "pymactoolbox.h"
+#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
return _res;
}
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_GetWindowRetainCount(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ItemCount _rv;
+#ifndef GetWindowRetainCount
+ PyMac_PRECHECK(GetWindowRetainCount);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetWindowRetainCount(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_RetainWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+#ifndef RetainWindow
+ PyMac_PRECHECK(RetainWindow);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = RetainWindow(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_ReleaseWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+#ifndef ReleaseWindow
+ PyMac_PRECHECK(ReleaseWindow);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = ReleaseWindow(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
static PyObject *WinObj_ReshapeCustomWindow(WindowObject *_self, PyObject *_args)
{
}
#endif
+static PyObject *WinObj_GetWindowWidgetHilite(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowDefPartCode outHilite;
+#ifndef GetWindowWidgetHilite
+ PyMac_PRECHECK(GetWindowWidgetHilite);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetWindowWidgetHilite(_self->ob_itself,
+ &outHilite);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ outHilite);
+ return _res;
+}
+
static PyObject *WinObj_GetWindowClass(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
static PyObject *WinObj_ChangeWindowAttributes(WindowObject *_self, PyObject *_args)
{
}
#endif
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_SetWindowClass(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowClass inWindowClass;
+#ifndef SetWindowClass
+ PyMac_PRECHECK(SetWindowClass);
+#endif
+ if (!PyArg_ParseTuple(_args, "l",
+ &inWindowClass))
+ return NULL;
+ _err = SetWindowClass(_self->ob_itself,
+ inWindowClass);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_SetWindowModality(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowModality inModalKind;
+ WindowPtr inUnavailableWindow;
+#ifndef SetWindowModality
+ PyMac_PRECHECK(SetWindowModality);
+#endif
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &inModalKind,
+ WinObj_Convert, &inUnavailableWindow))
+ return NULL;
+ _err = SetWindowModality(_self->ob_itself,
+ inModalKind,
+ inUnavailableWindow);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_GetWindowModality(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowModality outModalKind;
+ WindowPtr outUnavailableWindow;
+#ifndef GetWindowModality
+ PyMac_PRECHECK(GetWindowModality);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetWindowModality(_self->ob_itself,
+ &outModalKind,
+ &outUnavailableWindow);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("lO&",
+ outModalKind,
+ WinObj_WhichWindow, outUnavailableWindow);
+ return _res;
+}
+#endif
+
#if !TARGET_API_MAC_CARBON
static PyObject *WinObj_SetWinColor(WindowObject *_self, PyObject *_args)
return _res;
}
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
static PyObject *WinObj_ScrollWindowRect(WindowObject *_self, PyObject *_args)
{
}
#endif
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
static PyObject *WinObj_ScrollWindowRegion(WindowObject *_self, PyObject *_args)
{
return _res;
}
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
static PyObject *WinObj_GetNextWindowOfClass(WindowObject *_self, PyObject *_args)
{
}
#endif
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_SetWindowAlternateTitle(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ CFStringRef inTitle;
+#ifndef SetWindowAlternateTitle
+ PyMac_PRECHECK(SetWindowAlternateTitle);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFStringRefObj_Convert, &inTitle))
+ return NULL;
+ _err = SetWindowAlternateTitle(_self->ob_itself,
+ inTitle);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_CopyWindowAlternateTitle(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ CFStringRef outTitle;
+#ifndef CopyWindowAlternateTitle
+ PyMac_PRECHECK(CopyWindowAlternateTitle);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = CopyWindowAlternateTitle(_self->ob_itself,
+ &outTitle);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, outTitle);
+ return _res;
+}
+#endif
+
#if !TARGET_API_MAC_CARBON
static PyObject *WinObj_IsValidWindowPtr(WindowObject *_self, PyObject *_args)
return _res;
}
+static PyObject *WinObj_GetWindowStructureWidths(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect outRect;
+#ifndef GetWindowStructureWidths
+ PyMac_PRECHECK(GetWindowStructureWidths);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetWindowStructureWidths(_self->ob_itself,
+ &outRect);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &outRect);
+ return _res;
+}
+
static PyObject *WinObj_BeginUpdate(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_SetWindowTitleWithCFString(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ CFStringRef inString;
+#ifndef SetWindowTitleWithCFString
+ PyMac_PRECHECK(SetWindowTitleWithCFString);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFStringRefObj_Convert, &inString))
+ return NULL;
+ _err = SetWindowTitleWithCFString(_self->ob_itself,
+ inString);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_CopyWindowTitleAsCFString(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ CFStringRef outString;
+#ifndef CopyWindowTitleAsCFString
+ PyMac_PRECHECK(CopyWindowTitleAsCFString);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = CopyWindowTitleAsCFString(_self->ob_itself,
+ &outString);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, outString);
+ return _res;
+}
+#endif
+
static PyObject *WinObj_SetWindowProxyFSSpec(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+#if TARGET_API_MAC_OSX
+
+static PyObject *WinObj_TransitionWindowAndParent(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowPtr parentWindow;
+ WindowTransitionEffect effect;
+ WindowTransitionAction action;
+ Rect rect;
+#ifndef TransitionWindowAndParent
+ PyMac_PRECHECK(TransitionWindowAndParent);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&llO&",
+ WinObj_Convert, &parentWindow,
+ &effect,
+ &action,
+ PyMac_GetRect, &rect))
+ return NULL;
+ _err = TransitionWindowAndParent(_self->ob_itself,
+ parentWindow,
+ effect,
+ action,
+ &rect);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
static PyObject *WinObj_MacMoveWindow(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
#ifndef SetWindowIdealUserState
PyMac_PRECHECK(SetWindowIdealUserState);
#endif
- if (!PyArg_ParseTuple(_args, ""))
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &userState))
return NULL;
_err = SetWindowIdealUserState(_self->ob_itself,
&userState);
if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_GetWindowGreatestAreaDevice(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowRegionCode inRegion;
+ GDHandle outGreatestDevice;
+ Rect outGreatestDeviceRect;
+#ifndef GetWindowGreatestAreaDevice
+ PyMac_PRECHECK(GetWindowGreatestAreaDevice);
+#endif
+ if (!PyArg_ParseTuple(_args, "H",
+ &inRegion))
+ return NULL;
+ _err = GetWindowGreatestAreaDevice(_self->ob_itself,
+ inRegion,
+ &outGreatestDevice,
+ &outGreatestDeviceRect);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&",
+ ResObj_New, outGreatestDevice,
+ PyMac_BuildRect, &outGreatestDeviceRect);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_ConstrainWindowToScreen(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowRegionCode inRegionCode;
+ WindowConstrainOptions inOptions;
+ Rect inScreenRect;
+ Rect outStructure;
+#ifndef ConstrainWindowToScreen
+ PyMac_PRECHECK(ConstrainWindowToScreen);
+#endif
+ if (!PyArg_ParseTuple(_args, "HlO&",
+ &inRegionCode,
+ &inOptions,
+ PyMac_GetRect, &inScreenRect))
+ return NULL;
+ _err = ConstrainWindowToScreen(_self->ob_itself,
+ inRegionCode,
+ inOptions,
+ &inScreenRect,
+ &outStructure);
+ if (_err != noErr) return PyMac_Error(_err);
_res = Py_BuildValue("O&",
- PyMac_BuildRect, &userState);
+ PyMac_BuildRect, &outStructure);
return _res;
}
+#endif
static PyObject *WinObj_HideWindow(WindowObject *_self, PyObject *_args)
{
return _res;
}
-#if TARGET_API_MAC_CARBON
+static PyObject *WinObj_MacIsWindowVisible(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+#ifndef MacIsWindowVisible
+ PyMac_PRECHECK(MacIsWindowVisible);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MacIsWindowVisible(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_ShowSheetWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowPtr inParentWindow;
+#ifndef ShowSheetWindow
+ PyMac_PRECHECK(ShowSheetWindow);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &inParentWindow))
+ return NULL;
+ _err = ShowSheetWindow(_self->ob_itself,
+ inParentWindow);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_HideSheetWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+#ifndef HideSheetWindow
+ PyMac_PRECHECK(HideSheetWindow);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = HideSheetWindow(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_GetSheetWindowParent(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowPtr outParentWindow;
+#ifndef GetSheetWindowParent
+ PyMac_PRECHECK(GetSheetWindowParent);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetSheetWindowParent(_self->ob_itself,
+ &outParentWindow);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ WinObj_WhichWindow, outParentWindow);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
static PyObject *WinObj_GetWindowPropertyAttributes(WindowObject *_self, PyObject *_args)
{
}
#endif
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
static PyObject *WinObj_ChangeWindowPropertyAttributes(WindowObject *_self, PyObject *_args)
{
return _res;
}
-static PyObject *WinObj_MacIsWindowVisible(WindowObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- Boolean _rv;
-#ifndef MacIsWindowVisible
- PyMac_PRECHECK(MacIsWindowVisible);
-#endif
- if (!PyArg_ParseTuple(_args, ""))
- return NULL;
- _rv = MacIsWindowVisible(_self->ob_itself);
- _res = Py_BuildValue("b",
- _rv);
- return _res;
-}
-
static PyObject *WinObj_IsWindowHilited(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
static PyObject *WinObj_IsWindowUpdatePending(WindowObject *_self, PyObject *_args)
{
{"CloneWindow", (PyCFunction)WinObj_CloneWindow, 1,
"() -> None"},
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
+ {"GetWindowRetainCount", (PyCFunction)WinObj_GetWindowRetainCount, 1,
+ "() -> (ItemCount _rv)"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+ {"RetainWindow", (PyCFunction)WinObj_RetainWindow, 1,
+ "() -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+ {"ReleaseWindow", (PyCFunction)WinObj_ReleaseWindow, 1,
+ "() -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
{"ReshapeCustomWindow", (PyCFunction)WinObj_ReshapeCustomWindow, 1,
"() -> None"},
#endif
+ {"GetWindowWidgetHilite", (PyCFunction)WinObj_GetWindowWidgetHilite, 1,
+ "() -> (WindowDefPartCode outHilite)"},
{"GetWindowClass", (PyCFunction)WinObj_GetWindowClass, 1,
"() -> (WindowClass outClass)"},
{"GetWindowAttributes", (PyCFunction)WinObj_GetWindowAttributes, 1,
"() -> (WindowAttributes outAttributes)"},
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
{"ChangeWindowAttributes", (PyCFunction)WinObj_ChangeWindowAttributes, 1,
"(WindowAttributes setTheseAttributes, WindowAttributes clearTheseAttributes) -> None"},
#endif
+#if !TARGET_API_MAC_OS8
+ {"SetWindowClass", (PyCFunction)WinObj_SetWindowClass, 1,
+ "(WindowClass inWindowClass) -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+ {"SetWindowModality", (PyCFunction)WinObj_SetWindowModality, 1,
+ "(WindowModality inModalKind, WindowPtr inUnavailableWindow) -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+ {"GetWindowModality", (PyCFunction)WinObj_GetWindowModality, 1,
+ "() -> (WindowModality outModalKind, WindowPtr outUnavailableWindow)"},
+#endif
+
#if !TARGET_API_MAC_CARBON
{"SetWinColor", (PyCFunction)WinObj_SetWinColor, 1,
"(WCTabHandle newColorTable) -> None"},
{"SetWindowContentPattern", (PyCFunction)WinObj_SetWindowContentPattern, 1,
"(PixPatHandle pixPat) -> None"},
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
{"ScrollWindowRect", (PyCFunction)WinObj_ScrollWindowRect, 1,
"(Rect inScrollRect, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None"},
#endif
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
{"ScrollWindowRegion", (PyCFunction)WinObj_ScrollWindowRegion, 1,
"(RgnHandle inScrollRgn, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None"},
#endif
{"SelectWindow", (PyCFunction)WinObj_SelectWindow, 1,
"() -> None"},
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
{"GetNextWindowOfClass", (PyCFunction)WinObj_GetNextWindowOfClass, 1,
"(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)"},
#endif
+#if !TARGET_API_MAC_OS8
+ {"SetWindowAlternateTitle", (PyCFunction)WinObj_SetWindowAlternateTitle, 1,
+ "(CFStringRef inTitle) -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+ {"CopyWindowAlternateTitle", (PyCFunction)WinObj_CopyWindowAlternateTitle, 1,
+ "() -> (CFStringRef outTitle)"},
+#endif
+
#if !TARGET_API_MAC_CARBON
{"IsValidWindowPtr", (PyCFunction)WinObj_IsValidWindowPtr, 1,
"() -> (Boolean _rv)"},
"() -> (UInt32 outFeatures)"},
{"GetWindowRegion", (PyCFunction)WinObj_GetWindowRegion, 1,
"(WindowRegionCode inRegionCode, RgnHandle ioWinRgn) -> None"},
+ {"GetWindowStructureWidths", (PyCFunction)WinObj_GetWindowStructureWidths, 1,
+ "() -> (Rect outRect)"},
{"BeginUpdate", (PyCFunction)WinObj_BeginUpdate, 1,
"() -> None"},
{"EndUpdate", (PyCFunction)WinObj_EndUpdate, 1,
"(Str255 title) -> None"},
{"GetWTitle", (PyCFunction)WinObj_GetWTitle, 1,
"() -> (Str255 title)"},
+
+#if !TARGET_API_MAC_OS8
+ {"SetWindowTitleWithCFString", (PyCFunction)WinObj_SetWindowTitleWithCFString, 1,
+ "(CFStringRef inString) -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+ {"CopyWindowTitleAsCFString", (PyCFunction)WinObj_CopyWindowTitleAsCFString, 1,
+ "() -> (CFStringRef outString)"},
+#endif
{"SetWindowProxyFSSpec", (PyCFunction)WinObj_SetWindowProxyFSSpec, 1,
"(FSSpec inFile) -> None"},
{"GetWindowProxyFSSpec", (PyCFunction)WinObj_GetWindowProxyFSSpec, 1,
"(Boolean hilited) -> None"},
{"TransitionWindow", (PyCFunction)WinObj_TransitionWindow, 1,
"(WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None"},
+
+#if TARGET_API_MAC_OSX
+ {"TransitionWindowAndParent", (PyCFunction)WinObj_TransitionWindowAndParent, 1,
+ "(WindowPtr parentWindow, WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None"},
+#endif
{"MacMoveWindow", (PyCFunction)WinObj_MacMoveWindow, 1,
"(short hGlobal, short vGlobal, Boolean front) -> None"},
{"SizeWindow", (PyCFunction)WinObj_SizeWindow, 1,
{"GetWindowIdealUserState", (PyCFunction)WinObj_GetWindowIdealUserState, 1,
"() -> (Rect userState)"},
{"SetWindowIdealUserState", (PyCFunction)WinObj_SetWindowIdealUserState, 1,
- "() -> (Rect userState)"},
+ "(Rect userState) -> None"},
+
+#if !TARGET_API_MAC_OS8
+ {"GetWindowGreatestAreaDevice", (PyCFunction)WinObj_GetWindowGreatestAreaDevice, 1,
+ "(WindowRegionCode inRegion) -> (GDHandle outGreatestDevice, Rect outGreatestDeviceRect)"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+ {"ConstrainWindowToScreen", (PyCFunction)WinObj_ConstrainWindowToScreen, 1,
+ "(WindowRegionCode inRegionCode, WindowConstrainOptions inOptions, Rect inScreenRect) -> (Rect outStructure)"},
+#endif
{"HideWindow", (PyCFunction)WinObj_HideWindow, 1,
"() -> None"},
{"MacShowWindow", (PyCFunction)WinObj_MacShowWindow, 1,
"() -> None"},
{"ShowHide", (PyCFunction)WinObj_ShowHide, 1,
"(Boolean showFlag) -> None"},
+ {"MacIsWindowVisible", (PyCFunction)WinObj_MacIsWindowVisible, 1,
+ "() -> (Boolean _rv)"},
+
+#if !TARGET_API_MAC_OS8
+ {"ShowSheetWindow", (PyCFunction)WinObj_ShowSheetWindow, 1,
+ "(WindowPtr inParentWindow) -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+ {"HideSheetWindow", (PyCFunction)WinObj_HideSheetWindow, 1,
+ "() -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+ {"GetSheetWindowParent", (PyCFunction)WinObj_GetSheetWindowParent, 1,
+ "() -> (WindowPtr outParentWindow)"},
+#endif
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
{"GetWindowPropertyAttributes", (PyCFunction)WinObj_GetWindowPropertyAttributes, 1,
"(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"},
#endif
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
{"ChangeWindowPropertyAttributes", (PyCFunction)WinObj_ChangeWindowPropertyAttributes, 1,
"(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"},
#endif
"() -> (CGrafPtr _rv)"},
{"GetWindowKind", (PyCFunction)WinObj_GetWindowKind, 1,
"() -> (short _rv)"},
- {"MacIsWindowVisible", (PyCFunction)WinObj_MacIsWindowVisible, 1,
- "() -> (Boolean _rv)"},
{"IsWindowHilited", (PyCFunction)WinObj_IsWindowHilited, 1,
"() -> (Boolean _rv)"},
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
{"IsWindowUpdatePending", (PyCFunction)WinObj_IsWindowUpdatePending, 1,
"() -> (Boolean _rv)"},
#endif
return _res;
}
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
static PyObject *Win_GetFrontWindowOfClass(PyObject *_self, PyObject *_args)
{
}
#endif
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
static PyObject *Win_FindWindowOfClass(PyObject *_self, PyObject *_args)
{
}
#endif
+#if !TARGET_API_MAC_OS8
+
+static PyObject *Win_CreateStandardWindowMenu(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ OptionBits inOptions;
+ MenuHandle outMenu;
+#ifndef CreateStandardWindowMenu
+ PyMac_PRECHECK(CreateStandardWindowMenu);
+#endif
+ if (!PyArg_ParseTuple(_args, "l",
+ &inOptions))
+ return NULL;
+ _err = CreateStandardWindowMenu(inOptions,
+ &outMenu);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, outMenu);
+ return _res;
+}
+#endif
+
#if !TARGET_API_MAC_CARBON
static PyObject *Win_InitWindows(PyObject *_self, PyObject *_args)
return _res;
}
+#if !TARGET_API_MAC_OS8
+
+static PyObject *Win_GetAvailableWindowPositioningBounds(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ GDHandle inDevice;
+ Rect availableRect;
+#ifndef GetAvailableWindowPositioningBounds
+ PyMac_PRECHECK(GetAvailableWindowPositioningBounds);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &inDevice))
+ return NULL;
+ _err = GetAvailableWindowPositioningBounds(inDevice,
+ &availableRect);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &availableRect);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *Win_DisableScreenUpdates(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+#ifndef DisableScreenUpdates
+ PyMac_PRECHECK(DisableScreenUpdates);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = DisableScreenUpdates();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *Win_EnableScreenUpdates(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+#ifndef EnableScreenUpdates
+ PyMac_PRECHECK(EnableScreenUpdates);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = EnableScreenUpdates();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
static PyObject *Win_PinRect(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
{"FrontNonFloatingWindow", (PyCFunction)Win_FrontNonFloatingWindow, 1,
"() -> (WindowPtr _rv)"},
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
{"GetFrontWindowOfClass", (PyCFunction)Win_GetFrontWindowOfClass, 1,
"(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)"},
#endif
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
{"FindWindowOfClass", (PyCFunction)Win_FindWindowOfClass, 1,
"(Point where, WindowClass inWindowClass) -> (WindowPtr outWindow, WindowPartCode outWindowPart)"},
#endif
+#if !TARGET_API_MAC_OS8
+ {"CreateStandardWindowMenu", (PyCFunction)Win_CreateStandardWindowMenu, 1,
+ "(OptionBits inOptions) -> (MenuHandle outMenu)"},
+#endif
+
#if !TARGET_API_MAC_CARBON
{"InitWindows", (PyCFunction)Win_InitWindows, 1,
"() -> None"},
#endif
{"CollapseAllWindows", (PyCFunction)Win_CollapseAllWindows, 1,
"(Boolean collapse) -> None"},
+
+#if !TARGET_API_MAC_OS8
+ {"GetAvailableWindowPositioningBounds", (PyCFunction)Win_GetAvailableWindowPositioningBounds, 1,
+ "(GDHandle inDevice) -> (Rect availableRect)"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+ {"DisableScreenUpdates", (PyCFunction)Win_DisableScreenUpdates, 1,
+ "() -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+ {"EnableScreenUpdates", (PyCFunction)Win_EnableScreenUpdates, 1,
+ "() -> None"},
+#endif
{"PinRect", (PyCFunction)Win_PinRect, 1,
"(Rect theRect, Point thePt) -> (long _rv)"},
{"GetGrayRgn", (PyCFunction)Win_GetGrayRgn, 1,
'GetWindowGoAwayFlag',
'GetWindowSpareFlag',
]),
- ('#if TARGET_API_MAC_CARBON', [
+ ('#if !TARGET_API_MAC_OS8', [
'IsWindowUpdatePending',
'FindWindowOfClass',
'GetFrontWindowOfClass',
'ScrollWindowRect',
'ChangeWindowAttributes',
'ReshapeCustomWindow',
+ 'EnableScreenUpdates',
+ 'DisableScreenUpdates',
+ 'GetAvailableWindowPositioningBounds',
+ 'CreateStandardWindowMenu',
+ 'GetSheetWindowParent',
+ 'HideSheetWindow',
+ 'ShowSheetWindow',
+ 'ConstrainWindowToScreen',
+ 'GetWindowGreatestAreaDevice',
+ 'CopyWindowTitleAsCFString',
+ 'SetWindowTitleWithCFString',
+ 'CopyWindowAlternateTitle',
+ 'SetWindowAlternateTitle',
+ 'GetWindowModality',
+ 'SetWindowModality',
+ 'SetWindowClass',
+ 'ReleaseWindow',
+ 'RetainWindow',
+ 'GetWindowRetainCount',
+ ]),
+ ('#if TARGET_API_MAC_OSX', [
+ 'TransitionWindowAndParent',
])]
def makeblacklisttypes(self):
'Collection', # For now, to be done later
'WindowDefSpec', # Too difficult for now
'WindowDefSpec_ptr',
+ 'EventRef', #TBD
]
def makerepairinstructions(self):
RGBColor_ptr = RGBColor
ScrollWindowOptions = Type("ScrollWindowOptions", "l")
WindowPartCode = Type("WindowPartCode", "h")
+WindowDefPartCode = Type("WindowDefPartCode", "h")
+WindowModality = Type("WindowModality", "l")
+CFStringRef = OpaqueByValueType("CFStringRef", "CFStringRefObj")
+GDHandle = OpaqueByValueType("GDHandle", "ResObj")
+WindowConstrainOptions = Type("WindowConstrainOptions", "l")
PropertyCreator = OSTypeType("PropertyCreator")
PropertyTag = OSTypeType("PropertyTag")
projects / python / commitdiff