#if TARGET_API_MAC_CARBON
+static PyObject *CtlObj_HandleControlDragTracking(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ DragTrackingMessage inMessage;
+ DragReference inDrag;
+ Boolean outLikesDrag;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &inMessage,
+ DragObj_Convert, &inDrag))
+ return NULL;
+ _err = HandleControlDragTracking(_self->ob_itself,
+ inMessage,
+ inDrag,
+ &outLikesDrag);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("b",
+ outLikesDrag);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_HandleControlDragReceive(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ DragReference inDrag;
+ if (!PyArg_ParseTuple(_args, "O&",
+ DragObj_Convert, &inDrag))
+ return NULL;
+ _err = HandleControlDragReceive(_self->ob_itself,
+ inDrag);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
static PyObject *CtlObj_SetControlDragTrackingEnabled(_self, _args)
ControlObject *_self;
PyObject *_args;
{"GetControlDataSize", (PyCFunction)CtlObj_GetControlDataSize, 1,
"(ControlPartCode inPart, ResType inTagName) -> (Size outMaxSize)"},
+#if TARGET_API_MAC_CARBON
+ {"HandleControlDragTracking", (PyCFunction)CtlObj_HandleControlDragTracking, 1,
+ "(DragTrackingMessage inMessage, DragReference inDrag) -> (Boolean outLikesDrag)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"HandleControlDragReceive", (PyCFunction)CtlObj_HandleControlDragReceive, 1,
+ "(DragReference inDrag) -> None"},
+#endif
+
#if TARGET_API_MAC_CARBON
{"SetControlDragTrackingEnabled", (PyCFunction)CtlObj_SetControlDragTrackingEnabled, 1,
"(Boolean tracks) -> None"},
self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
self.defsfile.write("from TextEdit import *\n")
self.defsfile.write("from QuickDraw import *\n")
+ self.defsfile.write("from Dragconst import *\n")
self.defsfile.write("\n")
def makeblacklistnames(self):
('#if TARGET_API_MAC_CARBON', [
'IsAutomaticControlDragTrackingEnabledForWindow',
'SetAutomaticControlDragTrackingEnabledForWindow',
+ 'HandleControlDragReceive',
+ 'HandleControlDragTracking',
'GetControlByID',
'IsControlDragTrackingEnabled',
'SetControlDragTrackingEnabled',
'ControlDefSpec', # Don't know how to do this yet
'ControlDefSpec_ptr', # ditto
'Collection', # Ditto
- 'DragTrackingMessage', # Needs Drag module, must implement later
- 'DragReference', # ditto
]
def makerepairinstructions(self):
ControlID = OpaqueType('ControlID', 'PyControlID')
ControlID_ptr = ControlID
+DragTrackingMessage = Type("DragTrackingMessage", "h")
+DragReference = OpaqueByValueType("DragReference", "DragObj")
+
includestuff = includestuff + """
#include <%s>""" % MACHEADERFILE + """
#ifndef kControlCheckBoxUncheckedValue
'GetPortHWND',
'GetHWNDPort',
'GetPICTFromDIB',
-
+ 'GetPortBitMapForCopyBits', # Something funny in the declaration
]
+ def makegreylist(self):
+ return [
+ ('#if !TARGET_API_MAC_CARBON', [
+ ]),
+ ('#if TARGET_API_MAC_CARBON', [
+ ])]
+
+
def makeblacklisttypes(self):
return [
-## 'CCrsrHandle',
'CIconHandle', # Obsolete
'CQDProcs',
+ 'CQDProcsPtr',
'CSpecArray',
-## 'CTabHandle',
'ColorComplementProcPtr',
'ColorComplementUPP',
'ColorSearchProcPtr',
'ConstPatternParam',
'DeviceLoopDrawingProcPtr',
'DeviceLoopFlags',
-## 'FontInfo',
-## 'GDHandle',
'GrafVerb',
'OpenCPicParams_ptr',
'Ptr',
'QDProcs',
'ReqListRec',
'void_ptr',
+ 'CustomXFerProcPtr',
]
def makerepairinstructions(self):
CGrafPtr = OpaqueByValueType("CGrafPtr", "GrafObj")
GrafPtr = OpaqueByValueType("GrafPtr", "GrafObj")
BitMap_ptr = OpaqueByValueType("BitMapPtr", "BMObj")
+BitMap = BitMap_ptr
RGBColor = OpaqueType('RGBColor', 'QdRGB')
RGBColor_ptr = RGBColor
FontInfo = OpaqueType('FontInfo', 'QdFI')
+Component = OpaqueByValueType('Component', 'CmpObj')
+ComponentInstance = OpaqueByValueType('ComponentInstance', 'CmpInstObj')
Cursor_ptr = StructInputBufferType('Cursor')
Pattern = StructOutputBufferType('Pattern')
includestuff = includestuff + """
#include <%s>""" % MACHEADERFILE + """
+#if !ACCESSOR_CALLS_ARE_FUNCTIONS
+#define GetPortBitMapForCopyBits(port) (((GrafPort)(port))->portBits)
+#define GetPortBounds(port, bounds) (*(bounds) = (port)->portRect, (bounds))
+#define GetPortForeColor(port, color) (*(color) = (port)->rgbFgColor, (color))
+#define GetPortBackColor(port, color) (*(color) = (port)->rgbBkColor, (color))
+#define GetPortOpColor(port, color) (*(color) = (*((port)->grafVars))->rgbOpColor, (color))
+#define GetPortHiliteColor(port, color) (*(color) = (*((port)->grafVars))->rgbHiliteColor, (color))
+#define GetPortTextFont(port) ((port)->txFont)
+#define GetPortTextFace(port) ((port)->txFace)
+#define GetPortTextMode(port) ((port)->txMode)
+#define GetPortTextSize(port) ((port)->txSize)
+#define GetPortChExtra(port) ((port)->chExtra)
+#define GetPortFracHPenLocation(port) ((port)->pnLocHFrac)
+#define GetPortSpExtra(port) ((port)->spExtra)
+#define GetPortPenVisibility(port) ((port)->pnVis)
+#define GetPortVisibleRegion(port, rgn) ((rgn) = (port)->visRgn, (rgn))
+#define GetPortClipRegion(port, rgn) ((rgn) = (port)->clipRgn, (rgn))
+#define GetPortBackPixPat(port, pat) ((pat) = (port)->bkPixPat, (pat))
+#define GetPortPenPixPat(port, pat) ((pat) = (port)->pnPixPat, (pat))
+#define GetPortFillPixPat(port, pat) ((pat) = (port)->fillPixPat, (pat))
+#define GetPortPenSize(port, pensize) (*(pensize) = (port)->pnSize, (pensize))
+#define GetPortPenMode(port) ((port)->pnMode)
+#define GetPortPenLocation(port, location) ((*location) = (port)->pnLoc, (location))
+#define IsPortRegionBeingDefined(port) ((port)->rgnSave)
+#define IsPortPictureBeingDefined(port) ((port)->picSave)
+/* #define IsPortOffscreen(port) */
+/* #define IsPortColor(port) */
+
+#define SetPortBounds(port, bounds) ((port)->portRect = *(bounds))
+#define SetPortOpColor(port, color) ((*((port)->grafVars))->rgbOpColor = *(color))
+#define SetPortVisibleRegion(port, rgn) ((port)->visRgn = (rgn))
+#define SetPortClipRegion(port, rgn) ((port)->clipRgn = (rgn))
+#define SetPortBackPixPat(port, pat) ((port)->bkPixPat = (pat))
+#define SetPortPenPixPat(port, pat) ((port)->pnPixPat = (pat))
+#define GetPortFillPixPat(port, pat) ((port)->fillPixPat = (pat))
+#define SetPortPenSize(port, pensize) ((port)->pnSize = (pensize))
+#define SetPortPenMode(port, mode) ((port)->pnMode = (mode))
+#define SetPortFracHPenLocation(port, frac) ((port)->pnLocHFrac = (frac))
+
+#endif
+
/*
** Parse/generate RGB records
*/
/* --------------------- End object type GWorld --------------------- */
-static PyObject *Qdoffs_NewGWorld(_self, _args)
- PyObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- QDErr _err;
- GWorldPtr offscreenGWorld;
- short PixelDepth;
- Rect boundsRect;
- CTabHandle cTable;
- GDHandle aGDevice;
- GWorldFlags flags;
- if (!PyArg_ParseTuple(_args, "hO&O&O&l",
- &PixelDepth,
- PyMac_GetRect, &boundsRect,
- OptResObj_Convert, &cTable,
- OptResObj_Convert, &aGDevice,
- &flags))
- return NULL;
- _err = NewGWorld(&offscreenGWorld,
- PixelDepth,
- &boundsRect,
- cTable,
- aGDevice,
- flags);
- if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("O&",
- GWorldObj_New, offscreenGWorld);
- return _res;
-}
-
static PyObject *Qdoffs_LockPixels(_self, _args)
PyObject *_self;
PyObject *_args;
return _res;
}
-static PyObject *Qdoffs_UpdateGWorld(_self, _args)
- PyObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- GWorldFlags _rv;
- GWorldPtr offscreenGWorld;
- short pixelDepth;
- Rect boundsRect;
- CTabHandle cTable;
- GDHandle aGDevice;
- GWorldFlags flags;
- if (!PyArg_ParseTuple(_args, "hO&O&O&l",
- &pixelDepth,
- PyMac_GetRect, &boundsRect,
- OptResObj_Convert, &cTable,
- OptResObj_Convert, &aGDevice,
- &flags))
- return NULL;
- _rv = UpdateGWorld(&offscreenGWorld,
- pixelDepth,
- &boundsRect,
- cTable,
- aGDevice,
- flags);
- _res = Py_BuildValue("lO&",
- _rv,
- GWorldObj_New, offscreenGWorld);
- return _res;
-}
-
static PyObject *Qdoffs_GetGWorld(_self, _args)
PyObject *_self;
PyObject *_args;
}
static PyMethodDef Qdoffs_methods[] = {
- {"NewGWorld", (PyCFunction)Qdoffs_NewGWorld, 1,
- "(short PixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldPtr offscreenGWorld)"},
{"LockPixels", (PyCFunction)Qdoffs_LockPixels, 1,
"(PixMapHandle pm) -> (Boolean _rv)"},
{"UnlockPixels", (PyCFunction)Qdoffs_UnlockPixels, 1,
"(PixMapHandle pm) -> None"},
- {"UpdateGWorld", (PyCFunction)Qdoffs_UpdateGWorld, 1,
- "(short pixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldFlags _rv, GWorldPtr offscreenGWorld)"},
{"GetGWorld", (PyCFunction)Qdoffs_GetGWorld, 1,
"() -> (CGrafPtr port, GDHandle gdh)"},
{"SetGWorld", (PyCFunction)Qdoffs_SetGWorld, 1,
Qdoffs_Error = PyMac_GetOSErrException();
if (Qdoffs_Error == NULL ||
PyDict_SetItemString(d, "Error", Qdoffs_Error) != 0)
- Py_FatalError("can't initialize Qdoffs.Error");
+ return;
GWorld_Type.ob_type = &PyType_Type;
Py_INCREF(&GWorld_Type);
if (PyDict_SetItemString(d, "GWorldType", (PyObject *)&GWorld_Type) != 0)
return _res;
}
+static PyObject *MediaObj_GetMediaDataSize64(_self, _args)
+ MediaObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue startTime;
+ TimeValue duration;
+ wide dataSize;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
+ return NULL;
+ _err = GetMediaDataSize64(_self->ob_itself,
+ startTime,
+ duration,
+ &dataSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_Buildwide, dataSize);
+ return _res;
+}
+
static PyObject *MediaObj_GetMediaNextInterestingTime(_self, _args)
MediaObject *_self;
PyObject *_args;
"(long frameDiffSampleNum) -> (long syncSampleNum)"},
{"GetMediaDataSize", (PyCFunction)MediaObj_GetMediaDataSize, 1,
"(TimeValue startTime, TimeValue duration) -> (long _rv)"},
+ {"GetMediaDataSize64", (PyCFunction)MediaObj_GetMediaDataSize64, 1,
+ "(TimeValue startTime, TimeValue duration) -> (wide dataSize)"},
{"GetMediaNextInterestingTime", (PyCFunction)MediaObj_GetMediaNextInterestingTime, 1,
"(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
{"GetMediaDataRef", (PyCFunction)MediaObj_GetMediaDataRef, 1,
return _res;
}
+static PyObject *TrackObj_GetTrackDataSize64(_self, _args)
+ TrackObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue startTime;
+ TimeValue duration;
+ wide dataSize;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
+ return NULL;
+ _err = GetTrackDataSize64(_self->ob_itself,
+ startTime,
+ duration,
+ &dataSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_Buildwide, dataSize);
+ return _res;
+}
+
static PyObject *TrackObj_PtInTrack(_self, _args)
TrackObject *_self;
PyObject *_args;
"(TimeValue atTime) -> (Fixed _rv)"},
{"GetTrackDataSize", (PyCFunction)TrackObj_GetTrackDataSize, 1,
"(TimeValue startTime, TimeValue duration) -> (long _rv)"},
+ {"GetTrackDataSize64", (PyCFunction)TrackObj_GetTrackDataSize64, 1,
+ "(TimeValue startTime, TimeValue duration) -> (wide dataSize)"},
{"PtInTrack", (PyCFunction)TrackObj_PtInTrack, 1,
"(Point pt) -> (Boolean _rv)"},
{"GetTrackNextInterestingTime", (PyCFunction)TrackObj_GetTrackNextInterestingTime, 1,
return _res;
}
+static PyObject *MovieObj_AbortPrePrerollMovie(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr err;
+ if (!PyArg_ParseTuple(_args, "h",
+ &err))
+ return NULL;
+ AbortPrePrerollMovie(_self->ob_itself,
+ err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *MovieObj_LoadMovieIntoRam(_self, _args)
MovieObject *_self;
PyObject *_args;
return _res;
}
+static PyObject *MovieObj_PutMovieIntoDataFork64(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long fRefNum;
+ wide offset;
+ unsigned long maxSize;
+ if (!PyArg_ParseTuple(_args, "lO&l",
+ &fRefNum,
+ PyMac_Getwide, &offset,
+ &maxSize))
+ return NULL;
+ _err = PutMovieIntoDataFork64(_self->ob_itself,
+ fRefNum,
+ &offset,
+ maxSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *MovieObj_GetMovieCreationTime(_self, _args)
MovieObject *_self;
PyObject *_args;
return _res;
}
+static PyObject *MovieObj_GetMovieDataSize64(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue startTime;
+ TimeValue duration;
+ wide dataSize;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
+ return NULL;
+ _err = GetMovieDataSize64(_self->ob_itself,
+ startTime,
+ duration,
+ &dataSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_Buildwide, dataSize);
+ return _res;
+}
+
static PyObject *MovieObj_PtInMovie(_self, _args)
MovieObject *_self;
PyObject *_args;
return _res;
}
+static PyObject *MovieObj_SetMovieAnchorDataRef(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle dataRef;
+ OSType dataRefType;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType))
+ return NULL;
+ _err = SetMovieAnchorDataRef(_self->ob_itself,
+ dataRef,
+ dataRefType);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieAnchorDataRef(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle dataRef;
+ OSType dataRefType;
+ long outFlags;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetMovieAnchorDataRef(_self->ob_itself,
+ &dataRef,
+ &dataRefType,
+ &outFlags);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&l",
+ ResObj_New, dataRef,
+ PyMac_BuildOSType, dataRefType,
+ outFlags);
+ return _res;
+}
+
static PyObject *MovieObj_SetMovieColorTable(_self, _args)
MovieObject *_self;
PyObject *_args;
return _res;
}
+static PyObject *MovieObj_GetMovieLoadState(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieLoadState(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
static PyObject *MovieObj_NewMovieController(_self, _args)
MovieObject *_self;
PyObject *_args;
"(long maxMilliSecToUse) -> None"},
{"PrerollMovie", (PyCFunction)MovieObj_PrerollMovie, 1,
"(TimeValue time, Fixed Rate) -> None"},
+ {"AbortPrePrerollMovie", (PyCFunction)MovieObj_AbortPrePrerollMovie, 1,
+ "(OSErr err) -> None"},
{"LoadMovieIntoRam", (PyCFunction)MovieObj_LoadMovieIntoRam, 1,
"(TimeValue time, TimeValue duration, long flags) -> None"},
{"SetMovieActive", (PyCFunction)MovieObj_SetMovieActive, 1,
"(Handle publicMovie) -> None"},
{"PutMovieIntoDataFork", (PyCFunction)MovieObj_PutMovieIntoDataFork, 1,
"(short fRefNum, long offset, long maxSize) -> None"},
+ {"PutMovieIntoDataFork64", (PyCFunction)MovieObj_PutMovieIntoDataFork64, 1,
+ "(long fRefNum, wide offset, unsigned long maxSize) -> None"},
{"GetMovieCreationTime", (PyCFunction)MovieObj_GetMovieCreationTime, 1,
"() -> (unsigned long _rv)"},
{"GetMovieModificationTime", (PyCFunction)MovieObj_GetMovieModificationTime, 1,
"(Track onlyTrack, FSSpec outputFile, OSType fileType, OSType creator, ScriptCode scriptTag, long flags, ComponentInstance userComp) -> (short resID)"},
{"GetMovieDataSize", (PyCFunction)MovieObj_GetMovieDataSize, 1,
"(TimeValue startTime, TimeValue duration) -> (long _rv)"},
+ {"GetMovieDataSize64", (PyCFunction)MovieObj_GetMovieDataSize64, 1,
+ "(TimeValue startTime, TimeValue duration) -> (wide dataSize)"},
{"PtInMovie", (PyCFunction)MovieObj_PtInMovie, 1,
"(Point pt) -> (Boolean _rv)"},
{"SetMovieLanguage", (PyCFunction)MovieObj_SetMovieLanguage, 1,
"(Handle dataRef, OSType dataRefType) -> None"},
{"GetMovieDefaultDataRef", (PyCFunction)MovieObj_GetMovieDefaultDataRef, 1,
"() -> (Handle dataRef, OSType dataRefType)"},
+ {"SetMovieAnchorDataRef", (PyCFunction)MovieObj_SetMovieAnchorDataRef, 1,
+ "(Handle dataRef, OSType dataRefType) -> None"},
+ {"GetMovieAnchorDataRef", (PyCFunction)MovieObj_GetMovieAnchorDataRef, 1,
+ "() -> (Handle dataRef, OSType dataRefType, long outFlags)"},
{"SetMovieColorTable", (PyCFunction)MovieObj_SetMovieColorTable, 1,
"(CTabHandle ctab) -> None"},
{"GetMovieColorTable", (PyCFunction)MovieObj_GetMovieColorTable, 1,
"(TimeValue time, TimeValue duration) -> (RgnHandle _rv)"},
{"GetMovieStatus", (PyCFunction)MovieObj_GetMovieStatus, 1,
"() -> (ComponentResult _rv, Track firstProblemTrack)"},
+ {"GetMovieLoadState", (PyCFunction)MovieObj_GetMovieLoadState, 1,
+ "() -> (long _rv)"},
{"NewMovieController", (PyCFunction)MovieObj_NewMovieController, 1,
"(Rect movieRect, long someFlags) -> (MovieController _rv)"},
{"PutMovieOnScrap", (PyCFunction)MovieObj_PutMovieOnScrap, 1,
return _res;
}
+static PyObject *Qt_OpenADataHandler(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle dataRef;
+ OSType dataHandlerSubType;
+ Handle anchorDataRef;
+ OSType anchorDataRefType;
+ TimeBase tb;
+ long flags;
+ ComponentInstance dh;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&O&l",
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataHandlerSubType,
+ ResObj_Convert, &anchorDataRef,
+ PyMac_GetOSType, &anchorDataRefType,
+ TimeBaseObj_Convert, &tb,
+ &flags))
+ return NULL;
+ _err = OpenADataHandler(dataRef,
+ dataHandlerSubType,
+ anchorDataRef,
+ anchorDataRefType,
+ tb,
+ flags,
+ &dh);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CmpInstObj_New, dh);
+ return _res;
+}
+
static PyObject *Qt_PasteHandleIntoMovie(_self, _args)
PyObject *_self;
PyObject *_args;
return _res;
}
+static PyObject *Qt_NewMovieFromDataFork64(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Movie theMovie;
+ long fRefNum;
+ wide fileOffset;
+ short newMovieFlags;
+ Boolean dataRefWasChanged;
+ if (!PyArg_ParseTuple(_args, "lO&h",
+ &fRefNum,
+ PyMac_Getwide, &fileOffset,
+ &newMovieFlags))
+ return NULL;
+ _err = NewMovieFromDataFork64(&theMovie,
+ fRefNum,
+ &fileOffset,
+ newMovieFlags,
+ &dataRefWasChanged);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&b",
+ MovieObj_New, theMovie,
+ dataRefWasChanged);
+ return _res;
+}
+
static PyObject *Qt_NewMovieFromDataRef(_self, _args)
PyObject *_self;
PyObject *_args;
return _res;
}
+static PyObject *Qt_CreateShortcutMovieFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ FSSpec fileSpec;
+ OSType creator;
+ ScriptCode scriptTag;
+ long createMovieFileFlags;
+ Handle targetDataRef;
+ OSType targetDataRefType;
+ if (!PyArg_ParseTuple(_args, "O&O&hlO&O&",
+ PyMac_GetFSSpec, &fileSpec,
+ PyMac_GetOSType, &creator,
+ &scriptTag,
+ &createMovieFileFlags,
+ ResObj_Convert, &targetDataRef,
+ PyMac_GetOSType, &targetDataRefType))
+ return NULL;
+ _err = CreateShortcutMovieFile(&fileSpec,
+ creator,
+ scriptTag,
+ createMovieFileFlags,
+ targetDataRef,
+ targetDataRefType);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *Qt_NewMovieFromScrap(_self, _args)
PyObject *_self;
PyObject *_args;
return _res;
}
+static PyObject *Qt_VideoMediaSetCodecParameter(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ CodecType cType;
+ OSType parameterID;
+ long parameterChangeSeed;
+ void * dataPtr;
+ long dataSize;
+ if (!PyArg_ParseTuple(_args, "O&O&O&lsl",
+ CmpInstObj_Convert, &mh,
+ PyMac_GetOSType, &cType,
+ PyMac_GetOSType, ¶meterID,
+ ¶meterChangeSeed,
+ &dataPtr,
+ &dataSize))
+ return NULL;
+ _rv = VideoMediaSetCodecParameter(mh,
+ cType,
+ parameterID,
+ parameterChangeSeed,
+ dataPtr,
+ dataSize);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_VideoMediaGetCodecParameter(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ CodecType cType;
+ OSType parameterID;
+ Handle outParameterData;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+ CmpInstObj_Convert, &mh,
+ PyMac_GetOSType, &cType,
+ PyMac_GetOSType, ¶meterID,
+ ResObj_Convert, &outParameterData))
+ return NULL;
+ _rv = VideoMediaGetCodecParameter(mh,
+ cType,
+ parameterID,
+ outParameterData);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
static PyObject *Qt_TextMediaAddTextSample(_self, _args)
PyObject *_self;
PyObject *_args;
return _res;
}
-static PyObject *Qt_TextMediaFindNextText(_self, _args)
+static PyObject *Qt_TextMediaDrawRaw(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
ComponentResult _rv;
MediaHandler mh;
- Ptr text;
- long size;
- short findFlags;
- TimeValue startTime;
- TimeValue foundTime;
- TimeValue foundDuration;
- long offset;
- if (!PyArg_ParseTuple(_args, "O&slhl",
+ GWorldPtr gw;
+ GDHandle gd;
+ void * data;
+ long dataSize;
+ TextDescriptionHandle tdh;
+ if (!PyArg_ParseTuple(_args, "O&O&O&slO&",
CmpInstObj_Convert, &mh,
- &text,
- &size,
- &findFlags,
- &startTime))
+ GWorldObj_Convert, &gw,
+ OptResObj_Convert, &gd,
+ &data,
+ &dataSize,
+ ResObj_Convert, &tdh))
return NULL;
- _rv = TextMediaFindNextText(mh,
- text,
- size,
- findFlags,
- startTime,
- &foundTime,
- &foundDuration,
- &offset);
- _res = Py_BuildValue("llll",
- _rv,
- foundTime,
- foundDuration,
- offset);
+ _rv = TextMediaDrawRaw(mh,
+ gw,
+ gd,
+ data,
+ dataSize,
+ tdh);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *Qt_TextMediaHiliteTextSample(_self, _args)
+static PyObject *Qt_TextMediaSetTextProperty(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
ComponentResult _rv;
MediaHandler mh;
- TimeValue sampleTime;
- short hiliteStart;
- short hiliteEnd;
- RGBColor rgbHiliteColor;
- if (!PyArg_ParseTuple(_args, "O&lhh",
+ TimeValue atMediaTime;
+ long propertyType;
+ void * data;
+ long dataSize;
+ if (!PyArg_ParseTuple(_args, "O&llsl",
CmpInstObj_Convert, &mh,
- &sampleTime,
- &hiliteStart,
- &hiliteEnd))
+ &atMediaTime,
+ &propertyType,
+ &data,
+ &dataSize))
return NULL;
- _rv = TextMediaHiliteTextSample(mh,
- sampleTime,
- hiliteStart,
- hiliteEnd,
- &rgbHiliteColor);
- _res = Py_BuildValue("lO&",
- _rv,
- QdRGB_New, &rgbHiliteColor);
+ _rv = TextMediaSetTextProperty(mh,
+ atMediaTime,
+ propertyType,
+ data,
+ dataSize);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TextMediaRawSetup(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ GWorldPtr gw;
+ GDHandle gd;
+ void * data;
+ long dataSize;
+ TextDescriptionHandle tdh;
+ TimeValue sampleDuration;
+ if (!PyArg_ParseTuple(_args, "O&O&O&slO&l",
+ CmpInstObj_Convert, &mh,
+ GWorldObj_Convert, &gw,
+ OptResObj_Convert, &gd,
+ &data,
+ &dataSize,
+ ResObj_Convert, &tdh,
+ &sampleDuration))
+ return NULL;
+ _rv = TextMediaRawSetup(mh,
+ gw,
+ gd,
+ data,
+ dataSize,
+ tdh,
+ sampleDuration);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TextMediaRawIdle(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ GWorldPtr gw;
+ GDHandle gd;
+ TimeValue sampleTime;
+ long flagsIn;
+ long flagsOut;
+ if (!PyArg_ParseTuple(_args, "O&O&O&ll",
+ CmpInstObj_Convert, &mh,
+ GWorldObj_Convert, &gw,
+ OptResObj_Convert, &gd,
+ &sampleTime,
+ &flagsIn))
+ return NULL;
+ _rv = TextMediaRawIdle(mh,
+ gw,
+ gd,
+ sampleTime,
+ flagsIn,
+ &flagsOut);
+ _res = Py_BuildValue("ll",
+ _rv,
+ flagsOut);
+ return _res;
+}
+
+static PyObject *Qt_TextMediaFindNextText(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ Ptr text;
+ long size;
+ short findFlags;
+ TimeValue startTime;
+ TimeValue foundTime;
+ TimeValue foundDuration;
+ long offset;
+ if (!PyArg_ParseTuple(_args, "O&slhl",
+ CmpInstObj_Convert, &mh,
+ &text,
+ &size,
+ &findFlags,
+ &startTime))
+ return NULL;
+ _rv = TextMediaFindNextText(mh,
+ text,
+ size,
+ findFlags,
+ startTime,
+ &foundTime,
+ &foundDuration,
+ &offset);
+ _res = Py_BuildValue("llll",
+ _rv,
+ foundTime,
+ foundDuration,
+ offset);
+ return _res;
+}
+
+static PyObject *Qt_TextMediaHiliteTextSample(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ TimeValue sampleTime;
+ short hiliteStart;
+ short hiliteEnd;
+ RGBColor rgbHiliteColor;
+ if (!PyArg_ParseTuple(_args, "O&lhh",
+ CmpInstObj_Convert, &mh,
+ &sampleTime,
+ &hiliteStart,
+ &hiliteEnd))
+ return NULL;
+ _rv = TextMediaHiliteTextSample(mh,
+ sampleTime,
+ hiliteStart,
+ hiliteEnd,
+ &rgbHiliteColor);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ QdRGB_New, &rgbHiliteColor);
return _res;
}
}
#endif
+static PyObject *Qt_SpriteMediaDisposeSprite(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID spriteID;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &spriteID))
+ return NULL;
+ _rv = SpriteMediaDisposeSprite(mh,
+ spriteID);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaSetActionVariableToString(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID variableID;
+ Ptr theCString;
+ if (!PyArg_ParseTuple(_args, "O&ls",
+ CmpInstObj_Convert, &mh,
+ &variableID,
+ &theCString))
+ return NULL;
+ _rv = SpriteMediaSetActionVariableToString(mh,
+ variableID,
+ theCString);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaGetActionVariableAsString(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID variableID;
+ Handle theCString;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &variableID))
+ return NULL;
+ _rv = SpriteMediaGetActionVariableAsString(mh,
+ variableID,
+ &theCString);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ ResObj_New, theCString);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaSetPan(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ short xPercent;
+ short yPercent;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ CmpInstObj_Convert, &mh,
+ &xPercent,
+ &yPercent))
+ return NULL;
+ _rv = FlashMediaSetPan(mh,
+ xPercent,
+ yPercent);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaSetZoom(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ short factor;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ CmpInstObj_Convert, &mh,
+ &factor))
+ return NULL;
+ _rv = FlashMediaSetZoom(mh,
+ factor);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaSetZoomRect(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long left;
+ long top;
+ long right;
+ long bottom;
+ if (!PyArg_ParseTuple(_args, "O&llll",
+ CmpInstObj_Convert, &mh,
+ &left,
+ &top,
+ &right,
+ &bottom))
+ return NULL;
+ _rv = FlashMediaSetZoomRect(mh,
+ left,
+ top,
+ right,
+ bottom);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaGetRefConBounds(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long refCon;
+ long left;
+ long top;
+ long right;
+ long bottom;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &refCon))
+ return NULL;
+ _rv = FlashMediaGetRefConBounds(mh,
+ refCon,
+ &left,
+ &top,
+ &right,
+ &bottom);
+ _res = Py_BuildValue("lllll",
+ _rv,
+ left,
+ top,
+ right,
+ bottom);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaGetRefConID(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long refCon;
+ long refConID;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &refCon))
+ return NULL;
+ _rv = FlashMediaGetRefConID(mh,
+ refCon,
+ &refConID);
+ _res = Py_BuildValue("ll",
+ _rv,
+ refConID);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaIDToRefCon(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long refConID;
+ long refCon;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &refConID))
+ return NULL;
+ _rv = FlashMediaIDToRefCon(mh,
+ refConID,
+ &refCon);
+ _res = Py_BuildValue("ll",
+ _rv,
+ refCon);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaGetDisplayedFrameNumber(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long flashFrameNumber;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mh))
+ return NULL;
+ _rv = FlashMediaGetDisplayedFrameNumber(mh,
+ &flashFrameNumber);
+ _res = Py_BuildValue("ll",
+ _rv,
+ flashFrameNumber);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaFrameNumberToMovieTime(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long flashFrameNumber;
+ TimeValue movieTime;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &flashFrameNumber))
+ return NULL;
+ _rv = FlashMediaFrameNumberToMovieTime(mh,
+ flashFrameNumber,
+ &movieTime);
+ _res = Py_BuildValue("ll",
+ _rv,
+ movieTime);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaFrameLabelToMovieTime(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ Ptr theLabel;
+ TimeValue movieTime;
+ if (!PyArg_ParseTuple(_args, "O&s",
+ CmpInstObj_Convert, &mh,
+ &theLabel))
+ return NULL;
+ _rv = FlashMediaFrameLabelToMovieTime(mh,
+ theLabel,
+ &movieTime);
+ _res = Py_BuildValue("ll",
+ _rv,
+ movieTime);
+ return _res;
+}
+
+static PyObject *Qt_MovieMediaGetCurrentMovieProperty(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ OSType whichProperty;
+ void * value;
+ if (!PyArg_ParseTuple(_args, "O&O&s",
+ CmpInstObj_Convert, &mh,
+ PyMac_GetOSType, &whichProperty,
+ &value))
+ return NULL;
+ _rv = MovieMediaGetCurrentMovieProperty(mh,
+ whichProperty,
+ value);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MovieMediaGetCurrentTrackProperty(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long trackID;
+ OSType whichProperty;
+ void * value;
+ if (!PyArg_ParseTuple(_args, "O&lO&s",
+ CmpInstObj_Convert, &mh,
+ &trackID,
+ PyMac_GetOSType, &whichProperty,
+ &value))
+ return NULL;
+ _rv = MovieMediaGetCurrentTrackProperty(mh,
+ trackID,
+ whichProperty,
+ value);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MovieMediaGetChildMovieDataReference(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID dataRefID;
+ short dataRefIndex;
+ OSType dataRefType;
+ Handle dataRef;
+ QTAtomID dataRefIDOut;
+ short dataRefIndexOut;
+ if (!PyArg_ParseTuple(_args, "O&lh",
+ CmpInstObj_Convert, &mh,
+ &dataRefID,
+ &dataRefIndex))
+ return NULL;
+ _rv = MovieMediaGetChildMovieDataReference(mh,
+ dataRefID,
+ dataRefIndex,
+ &dataRefType,
+ &dataRef,
+ &dataRefIDOut,
+ &dataRefIndexOut);
+ _res = Py_BuildValue("lO&O&lh",
+ _rv,
+ PyMac_BuildOSType, dataRefType,
+ ResObj_New, dataRef,
+ dataRefIDOut,
+ dataRefIndexOut);
+ return _res;
+}
+
+static PyObject *Qt_MovieMediaSetChildMovieDataReference(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID dataRefID;
+ OSType dataRefType;
+ Handle dataRef;
+ if (!PyArg_ParseTuple(_args, "O&lO&O&",
+ CmpInstObj_Convert, &mh,
+ &dataRefID,
+ PyMac_GetOSType, &dataRefType,
+ ResObj_Convert, &dataRef))
+ return NULL;
+ _rv = MovieMediaSetChildMovieDataReference(mh,
+ dataRefID,
+ dataRefType,
+ dataRef);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MovieMediaLoadChildMovieFromDataReference(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID dataRefID;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &dataRefID))
+ return NULL;
+ _rv = MovieMediaLoadChildMovieFromDataReference(mh,
+ dataRefID);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_Media3DGetCurrentGroup(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ void * group;
+ if (!PyArg_ParseTuple(_args, "O&s",
+ CmpInstObj_Convert, &mh,
+ &group))
+ return NULL;
+ _rv = Media3DGetCurrentGroup(mh,
+ group);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_Media3DTranslateNamedObjectTo(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ char objectName;
+ Fixed x;
+ Fixed y;
+ Fixed z;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+ CmpInstObj_Convert, &mh,
+ PyMac_GetFixed, &x,
+ PyMac_GetFixed, &y,
+ PyMac_GetFixed, &z))
+ return NULL;
+ _rv = Media3DTranslateNamedObjectTo(mh,
+ &objectName,
+ x,
+ y,
+ z);
+ _res = Py_BuildValue("lc",
+ _rv,
+ objectName);
+ return _res;
+}
+
+static PyObject *Qt_Media3DScaleNamedObjectTo(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ char objectName;
+ Fixed xScale;
+ Fixed yScale;
+ Fixed zScale;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+ CmpInstObj_Convert, &mh,
+ PyMac_GetFixed, &xScale,
+ PyMac_GetFixed, &yScale,
+ PyMac_GetFixed, &zScale))
+ return NULL;
+ _rv = Media3DScaleNamedObjectTo(mh,
+ &objectName,
+ xScale,
+ yScale,
+ zScale);
+ _res = Py_BuildValue("lc",
+ _rv,
+ objectName);
+ return _res;
+}
+
+static PyObject *Qt_Media3DRotateNamedObjectTo(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ char objectName;
+ Fixed xDegrees;
+ Fixed yDegrees;
+ Fixed zDegrees;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+ CmpInstObj_Convert, &mh,
+ PyMac_GetFixed, &xDegrees,
+ PyMac_GetFixed, &yDegrees,
+ PyMac_GetFixed, &zDegrees))
+ return NULL;
+ _rv = Media3DRotateNamedObjectTo(mh,
+ &objectName,
+ xDegrees,
+ yDegrees,
+ zDegrees);
+ _res = Py_BuildValue("lc",
+ _rv,
+ objectName);
+ return _res;
+}
+
+static PyObject *Qt_Media3DSetCameraData(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ void * cameraData;
+ if (!PyArg_ParseTuple(_args, "O&s",
+ CmpInstObj_Convert, &mh,
+ &cameraData))
+ return NULL;
+ _rv = Media3DSetCameraData(mh,
+ cameraData);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_Media3DGetCameraData(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ void * cameraData;
+ if (!PyArg_ParseTuple(_args, "O&s",
+ CmpInstObj_Convert, &mh,
+ &cameraData))
+ return NULL;
+ _rv = Media3DGetCameraData(mh,
+ cameraData);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_Media3DSetCameraAngleAspect(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTFloatSingle fov;
+ QTFloatSingle aspectRatioXToY;
+ if (!PyArg_ParseTuple(_args, "O&ff",
+ CmpInstObj_Convert, &mh,
+ &fov,
+ &aspectRatioXToY))
+ return NULL;
+ _rv = Media3DSetCameraAngleAspect(mh,
+ fov,
+ aspectRatioXToY);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_Media3DGetCameraAngleAspect(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTFloatSingle fov;
+ QTFloatSingle aspectRatioXToY;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mh))
+ return NULL;
+ _rv = Media3DGetCameraAngleAspect(mh,
+ &fov,
+ &aspectRatioXToY);
+ _res = Py_BuildValue("lff",
+ _rv,
+ fov,
+ aspectRatioXToY);
+ return _res;
+}
+
+static PyObject *Qt_Media3DSetCameraRange(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ void * tQ3CameraRange;
+ if (!PyArg_ParseTuple(_args, "O&s",
+ CmpInstObj_Convert, &mh,
+ &tQ3CameraRange))
+ return NULL;
+ _rv = Media3DSetCameraRange(mh,
+ tQ3CameraRange);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_Media3DGetCameraRange(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ void * tQ3CameraRange;
+ if (!PyArg_ParseTuple(_args, "O&s",
+ CmpInstObj_Convert, &mh,
+ &tQ3CameraRange))
+ return NULL;
+ _rv = Media3DGetCameraRange(mh,
+ tQ3CameraRange);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_Media3DGetViewObject(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ void * tq3viewObject;
+ if (!PyArg_ParseTuple(_args, "O&s",
+ CmpInstObj_Convert, &mh,
+ &tq3viewObject))
+ return NULL;
+ _rv = Media3DGetViewObject(mh,
+ tq3viewObject);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
static PyObject *Qt_NewTimeBase(_self, _args)
PyObject *_self;
PyObject *_args;
"(long flags) -> (Movie _rv)"},
{"GetDataHandler", (PyCFunction)Qt_GetDataHandler, 1,
"(Handle dataRef, OSType dataHandlerSubType, long flags) -> (Component _rv)"},
+ {"OpenADataHandler", (PyCFunction)Qt_OpenADataHandler, 1,
+ "(Handle dataRef, OSType dataHandlerSubType, Handle anchorDataRef, OSType anchorDataRefType, TimeBase tb, long flags) -> (ComponentInstance dh)"},
{"PasteHandleIntoMovie", (PyCFunction)Qt_PasteHandleIntoMovie, 1,
"(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None"},
{"GetMovieImporterForDataRef", (PyCFunction)Qt_GetMovieImporterForDataRef, 1,
"(Handle h, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
{"NewMovieFromDataFork", (PyCFunction)Qt_NewMovieFromDataFork, 1,
"(short fRefNum, long fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
+ {"NewMovieFromDataFork64", (PyCFunction)Qt_NewMovieFromDataFork64, 1,
+ "(long fRefNum, wide fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
{"NewMovieFromDataRef", (PyCFunction)Qt_NewMovieFromDataRef, 1,
"(short flags, Handle dataRef, OSType dataRefType) -> (Movie m, short id)"},
{"RemoveMovieResource", (PyCFunction)Qt_RemoveMovieResource, 1,
"(short resRefNum, short resId) -> None"},
+ {"CreateShortcutMovieFile", (PyCFunction)Qt_CreateShortcutMovieFile, 1,
+ "(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Handle targetDataRef, OSType targetDataRefType) -> None"},
{"NewMovieFromScrap", (PyCFunction)Qt_NewMovieFromScrap, 1,
"(long newMovieFlags) -> (Movie _rv)"},
{"QTNewAlias", (PyCFunction)Qt_QTNewAlias, 1,
"(MediaHandler mh) -> (ComponentResult _rv)"},
{"VideoMediaGetStallCount", (PyCFunction)Qt_VideoMediaGetStallCount, 1,
"(MediaHandler mh) -> (ComponentResult _rv, unsigned long stalls)"},
+ {"VideoMediaSetCodecParameter", (PyCFunction)Qt_VideoMediaSetCodecParameter, 1,
+ "(MediaHandler mh, CodecType cType, OSType parameterID, long parameterChangeSeed, void * dataPtr, long dataSize) -> (ComponentResult _rv)"},
+ {"VideoMediaGetCodecParameter", (PyCFunction)Qt_VideoMediaGetCodecParameter, 1,
+ "(MediaHandler mh, CodecType cType, OSType parameterID, Handle outParameterData) -> (ComponentResult _rv)"},
{"TextMediaAddTextSample", (PyCFunction)Qt_TextMediaAddTextSample, 1,
"(MediaHandler mh, Ptr text, unsigned long size, short fontNumber, short fontSize, Style textFace, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor textColor, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)"},
{"TextMediaAddTESample", (PyCFunction)Qt_TextMediaAddTESample, 1,
"(MediaHandler mh, TEHandle hTE, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)"},
{"TextMediaAddHiliteSample", (PyCFunction)Qt_TextMediaAddHiliteSample, 1,
"(MediaHandler mh, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor rgbHiliteColor, TimeValue sampleTime)"},
+ {"TextMediaDrawRaw", (PyCFunction)Qt_TextMediaDrawRaw, 1,
+ "(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh) -> (ComponentResult _rv)"},
+ {"TextMediaSetTextProperty", (PyCFunction)Qt_TextMediaSetTextProperty, 1,
+ "(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)"},
+ {"TextMediaRawSetup", (PyCFunction)Qt_TextMediaRawSetup, 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)"},
{"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,
{"SpriteMediaGetIndImageProperty", (PyCFunction)Qt_SpriteMediaGetIndImageProperty, 1,
"(MediaHandler mh, short imageIndex, long imagePropertyType, void * imagePropertyValue) -> (ComponentResult _rv)"},
#endif
+ {"SpriteMediaDisposeSprite", (PyCFunction)Qt_SpriteMediaDisposeSprite, 1,
+ "(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv)"},
+ {"SpriteMediaSetActionVariableToString", (PyCFunction)Qt_SpriteMediaSetActionVariableToString, 1,
+ "(MediaHandler mh, QTAtomID variableID, Ptr theCString) -> (ComponentResult _rv)"},
+ {"SpriteMediaGetActionVariableAsString", (PyCFunction)Qt_SpriteMediaGetActionVariableAsString, 1,
+ "(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, Handle theCString)"},
+ {"FlashMediaSetPan", (PyCFunction)Qt_FlashMediaSetPan, 1,
+ "(MediaHandler mh, short xPercent, short yPercent) -> (ComponentResult _rv)"},
+ {"FlashMediaSetZoom", (PyCFunction)Qt_FlashMediaSetZoom, 1,
+ "(MediaHandler mh, short factor) -> (ComponentResult _rv)"},
+ {"FlashMediaSetZoomRect", (PyCFunction)Qt_FlashMediaSetZoomRect, 1,
+ "(MediaHandler mh, long left, long top, long right, long bottom) -> (ComponentResult _rv)"},
+ {"FlashMediaGetRefConBounds", (PyCFunction)Qt_FlashMediaGetRefConBounds, 1,
+ "(MediaHandler mh, long refCon) -> (ComponentResult _rv, long left, long top, long right, long bottom)"},
+ {"FlashMediaGetRefConID", (PyCFunction)Qt_FlashMediaGetRefConID, 1,
+ "(MediaHandler mh, long refCon) -> (ComponentResult _rv, long refConID)"},
+ {"FlashMediaIDToRefCon", (PyCFunction)Qt_FlashMediaIDToRefCon, 1,
+ "(MediaHandler mh, long refConID) -> (ComponentResult _rv, long refCon)"},
+ {"FlashMediaGetDisplayedFrameNumber", (PyCFunction)Qt_FlashMediaGetDisplayedFrameNumber, 1,
+ "(MediaHandler mh) -> (ComponentResult _rv, long flashFrameNumber)"},
+ {"FlashMediaFrameNumberToMovieTime", (PyCFunction)Qt_FlashMediaFrameNumberToMovieTime, 1,
+ "(MediaHandler mh, long flashFrameNumber) -> (ComponentResult _rv, TimeValue movieTime)"},
+ {"FlashMediaFrameLabelToMovieTime", (PyCFunction)Qt_FlashMediaFrameLabelToMovieTime, 1,
+ "(MediaHandler mh, Ptr theLabel) -> (ComponentResult _rv, TimeValue movieTime)"},
+ {"MovieMediaGetCurrentMovieProperty", (PyCFunction)Qt_MovieMediaGetCurrentMovieProperty, 1,
+ "(MediaHandler mh, OSType whichProperty, void * value) -> (ComponentResult _rv)"},
+ {"MovieMediaGetCurrentTrackProperty", (PyCFunction)Qt_MovieMediaGetCurrentTrackProperty, 1,
+ "(MediaHandler mh, long trackID, OSType whichProperty, void * value) -> (ComponentResult _rv)"},
+ {"MovieMediaGetChildMovieDataReference", (PyCFunction)Qt_MovieMediaGetChildMovieDataReference, 1,
+ "(MediaHandler mh, QTAtomID dataRefID, short dataRefIndex) -> (ComponentResult _rv, OSType dataRefType, Handle dataRef, QTAtomID dataRefIDOut, short dataRefIndexOut)"},
+ {"MovieMediaSetChildMovieDataReference", (PyCFunction)Qt_MovieMediaSetChildMovieDataReference, 1,
+ "(MediaHandler mh, QTAtomID dataRefID, OSType dataRefType, Handle dataRef) -> (ComponentResult _rv)"},
+ {"MovieMediaLoadChildMovieFromDataReference", (PyCFunction)Qt_MovieMediaLoadChildMovieFromDataReference, 1,
+ "(MediaHandler mh, QTAtomID dataRefID) -> (ComponentResult _rv)"},
+ {"Media3DGetCurrentGroup", (PyCFunction)Qt_Media3DGetCurrentGroup, 1,
+ "(MediaHandler mh, void * group) -> (ComponentResult _rv)"},
+ {"Media3DTranslateNamedObjectTo", (PyCFunction)Qt_Media3DTranslateNamedObjectTo, 1,
+ "(MediaHandler mh, Fixed x, Fixed y, Fixed z) -> (ComponentResult _rv, char objectName)"},
+ {"Media3DScaleNamedObjectTo", (PyCFunction)Qt_Media3DScaleNamedObjectTo, 1,
+ "(MediaHandler mh, Fixed xScale, Fixed yScale, Fixed zScale) -> (ComponentResult _rv, char objectName)"},
+ {"Media3DRotateNamedObjectTo", (PyCFunction)Qt_Media3DRotateNamedObjectTo, 1,
+ "(MediaHandler mh, Fixed xDegrees, Fixed yDegrees, Fixed zDegrees) -> (ComponentResult _rv, char objectName)"},
+ {"Media3DSetCameraData", (PyCFunction)Qt_Media3DSetCameraData, 1,
+ "(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)"},
+ {"Media3DGetCameraData", (PyCFunction)Qt_Media3DGetCameraData, 1,
+ "(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)"},
+ {"Media3DSetCameraAngleAspect", (PyCFunction)Qt_Media3DSetCameraAngleAspect, 1,
+ "(MediaHandler mh, QTFloatSingle fov, QTFloatSingle aspectRatioXToY) -> (ComponentResult _rv)"},
+ {"Media3DGetCameraAngleAspect", (PyCFunction)Qt_Media3DGetCameraAngleAspect, 1,
+ "(MediaHandler mh) -> (ComponentResult _rv, QTFloatSingle fov, QTFloatSingle aspectRatioXToY)"},
+ {"Media3DSetCameraRange", (PyCFunction)Qt_Media3DSetCameraRange, 1,
+ "(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)"},
+ {"Media3DGetCameraRange", (PyCFunction)Qt_Media3DGetCameraRange, 1,
+ "(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)"},
+ {"Media3DGetViewObject", (PyCFunction)Qt_Media3DGetViewObject, 1,
+ "(MediaHandler mh, void * tq3viewObject) -> (ComponentResult _rv)"},
{"NewTimeBase", (PyCFunction)Qt_NewTimeBase, 1,
"() -> (TimeBase _rv)"},
{"ConvertTime", (PyCFunction)Qt_ConvertTime, 1,
Qt_Error = PyMac_GetOSErrException();
if (Qt_Error == NULL ||
PyDict_SetItemString(d, "Error", Qt_Error) != 0)
- Py_FatalError("can't initialize Qt.Error");
+ return;
MovieController_Type.ob_type = &PyType_Type;
Py_INCREF(&MovieController_Type);
if (PyDict_SetItemString(d, "MovieControllerType", (PyObject *)&MovieController_Type) != 0)
"GetMovieUPP",
"ModalFilterUPP",
"TrackTransferUPP",
+ "MoviePrePrerollCompleteUPP",
+ "MovieExecuteWiredActionsUPP",
+ "QTBandwidthNotificationUPP",
+ "DoMCActionUPP",
+
+ "SampleReference64Ptr", # Don't know what this does, yet
+ "QTRuntimeSpriteDescPtr",
+ "QTBandwidthReference",
+ "QTScheduledBandwidthReference",
"QTAtomContainer",
"SpriteWorld",
"Sprite",
PixMapHandle = OpaqueByValueType("PixMapHandle", "ResObj")
SampleDescriptionHandle = OpaqueByValueType("SampleDescriptionHandle", "ResObj")
ImageDescriptionHandle = OpaqueByValueType("ImageDescriptionHandle", "ResObj")
+TextDescriptionHandle = OpaqueByValueType("TextDescriptionHandle", "ResObj")
TEHandle = OpaqueByValueType("TEHandle", "ResObj")
CGrafPtr = OpaqueByValueType("CGrafPtr", "GrafObj")
GDHandle = OpaqueByValueType("GDHandle", "OptResObj")
QTParameterDialog = Type("QTParameterDialog", "l")
QTAtomID = Type("QTAtomID", "l")
MCInterfaceElement = Type("MCInterfaceElement", "l")
+CodecType = OSTypeType("CodecType")
+GWorldPtr = OpaqueByValueType("GWorldPtr", "GWorldObj")
+QTFloatSingle = Type("QTFloatSingle", "f")
+
# Could-not-be-bothered-types (NewMovieFromFile)
dummyshortptr = FakeType('(short *)0')
dummyStringPtr = FakeType('(StringPtr)0')
return _res;
}
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Res_InsertResourceFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ SInt16 refNum;
+ RsrcChainLocation where;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &refNum,
+ &where))
+ return NULL;
+ _rv = InsertResourceFile(refNum,
+ where);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Res_DetachResourceFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ SInt16 refNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &refNum))
+ return NULL;
+ _rv = DetachResourceFile(refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *Res_FSpResourceFileAlreadyOpen(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ FSSpec resourceFile;
+ Boolean inChain;
+ SInt16 refNum;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFSSpec, &resourceFile))
+ return NULL;
+ _rv = FSpResourceFileAlreadyOpen(&resourceFile,
+ &inChain,
+ &refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("bbh",
+ _rv,
+ inChain,
+ refNum);
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Res_FSpOpenOrphanResFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ FSSpec spec;
+ SignedByte permission;
+ SInt16 refNum;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ PyMac_GetFSSpec, &spec,
+ &permission))
+ return NULL;
+ _rv = FSpOpenOrphanResFile(&spec,
+ permission,
+ &refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("hh",
+ _rv,
+ refNum);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Res_GetTopResourceFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ SInt16 refNum;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTopResourceFile(&refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("hh",
+ _rv,
+ refNum);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Res_GetNextResourceFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ SInt16 curRefNum;
+ SInt16 nextRefNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &curRefNum))
+ return NULL;
+ _rv = GetNextResourceFile(curRefNum,
+ &nextRefNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("hh",
+ _rv,
+ nextRefNum);
+ return _res;
+}
+#endif
+
static PyObject *Res_Resource(_self, _args)
PyObject *_self;
PyObject *_args;
"(FSSpec spec, SignedByte permission) -> (short _rv)"},
{"FSpCreateResFile", (PyCFunction)Res_FSpCreateResFile, 1,
"(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"InsertResourceFile", (PyCFunction)Res_InsertResourceFile, 1,
+ "(SInt16 refNum, RsrcChainLocation where) -> (OSErr _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"DetachResourceFile", (PyCFunction)Res_DetachResourceFile, 1,
+ "(SInt16 refNum) -> (OSErr _rv)"},
+#endif
+ {"FSpResourceFileAlreadyOpen", (PyCFunction)Res_FSpResourceFileAlreadyOpen, 1,
+ "(FSSpec resourceFile) -> (Boolean _rv, Boolean inChain, SInt16 refNum)"},
+
+#if TARGET_API_MAC_CARBON
+ {"FSpOpenOrphanResFile", (PyCFunction)Res_FSpOpenOrphanResFile, 1,
+ "(FSSpec spec, SignedByte permission) -> (OSErr _rv, SInt16 refNum)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetTopResourceFile", (PyCFunction)Res_GetTopResourceFile, 1,
+ "() -> (OSErr _rv, SInt16 refNum)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetNextResourceFile", (PyCFunction)Res_GetNextResourceFile, 1,
+ "(SInt16 curRefNum) -> (OSErr _rv, SInt16 nextRefNum)"},
+#endif
{"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,
Res_Error = PyMac_GetOSErrException();
if (Res_Error == NULL ||
PyDict_SetItemString(d, "Error", Res_Error) != 0)
- Py_FatalError("can't initialize Res.Error");
+ return;
Resource_Type.ob_type = &PyType_Type;
Py_INCREF(&Resource_Type);
if (PyDict_SetItemString(d, "ResourceType", (PyObject *)&Resource_Type) != 0)
'RsrcZoneInit',
'InitResources',
'RsrcMapEntry',
+ ]),
+ ('#if TARGET_API_MAC_CARBON', [
+ 'GetNextResourceFile',
+ 'GetTopResourceFile',
+ 'FSpOpenOrphanResFile',
+ 'DetachResourceFile',
+ 'InsertResourceFile',
])]
def makerepairinstructions(self):
class ResFunction(ResMixIn, FunctionGenerator): pass
class ResMethod(ResMixIn, MethodGenerator): pass
+RsrcChainLocation = Type("RsrcChainLocation", "h")
+
# includestuff etc. are imported from macsupport
includestuff = includestuff + """
Snd_Error = PyMac_GetOSErrException();
if (Snd_Error == NULL ||
PyDict_SetItemString(d, "Error", Snd_Error) != 0)
- Py_FatalError("can't initialize Snd.Error");
+ return;
SndChannel_Type.ob_type = &PyType_Type;
Py_INCREF(&SndChannel_Type);
if (PyDict_SetItemString(d, "SndChannelType", (PyObject *)&SndChannel_Type) != 0)
'SndDisposeChannel', # automatic on deallocation
'SndAddModifier', # for internal use only
'SndPlayDoubleBuffer', # very low level routine
- # Obsolete:
- 'StartSound',
- 'StopSound',
- 'SoundDone',
- # These do not work for cfm68k:
-## 'SndGetInfo',
-## 'SndSetInfo',
-## 'GetCompressionInfo',
-## 'GetCompressionName',
-## 'GetSoundPreference',
-## 'SetSoundPreference',
- # And old calls that are no longer supported
- 'SetSoundVol',
- 'GetSoundVol',
+ # Missing from libraries (UH332)
+ 'SoundManagerSetInfo',
+ 'SoundManagerGetInfo',
# Constants with funny definitions
'rate48khz',
'rate44khz',
return _res;
}
+#if TARGET_API_MAC_CARBON
+
+static PyObject *TE_TEGetScrapHandle(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TEGetScrapHandle();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *TE_TESetScrapHandle(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Handle value;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &value))
+ return NULL;
+ TESetScrapHandle(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
static PyObject *TE_as_TE(_self, _args)
PyObject *_self;
PyObject *_args;
"() -> None"},
{"TEToScrap", (PyCFunction)TE_TEToScrap, 1,
"() -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"TEGetScrapHandle", (PyCFunction)TE_TEGetScrapHandle, 1,
+ "() -> (Handle _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"TESetScrapHandle", (PyCFunction)TE_TESetScrapHandle, 1,
+ "(Handle value) -> None"},
+#endif
{"as_TE", (PyCFunction)TE_as_TE, 1,
"(Handle h) -> (TEHandle _rv)"},
{NULL, NULL, 0}
TE_Error = PyMac_GetOSErrException();
if (TE_Error == NULL ||
PyDict_SetItemString(d, "Error", TE_Error) != 0)
- Py_FatalError("can't initialize TE.Error");
+ return;
TE_Type.ob_type = &PyType_Type;
Py_INCREF(&TE_Type);
if (PyDict_SetItemString(d, "TEType", (PyObject *)&TE_Type) != 0)
## "TEGetHiliteRgn",
]
+ def makegreylist(self):
+ return [
+ ('#if TARGET_API_MAC_CARBON', [
+ 'TEGetScrapHandle',
+ 'TESetScrapHandle',
+ ])]
+
def makeblacklisttypes(self):
return [
"TEClickLoopUPP",
"UniversalProcPtr",
- "WordBreakUPP"
+ "WordBreakUPP",
+ "TEDoTextUPP",
+ "TERecalcUPP",
+ "TEFindWordUPP",
]
def makerepairinstructions(self):
#include "pymactoolbox.h"
#include <Windows.h>
+
+#if !ACCESSOR_CALLS_ARE_FUNCTIONS
+#define GetWindowSpareFlag(win) (((CWindowPeek)(win))->spareFlag)
+#define GetWindowFromPort(port) ((WindowRef)(port))
+#define GetWindowPortBounds(win, rectp) (*(rectp) = ((CWindowPeek)(win))->port.portRect)
+#endif
+
/* Function to dispose a window, with a "normal" calling sequence */
static void
PyMac_AutoDisposeWindow(WindowPtr w)
PyObject *v;
WindowPtr *p_itself;
{
-#if !TARGET_API_MAC_CARBON
if (DlgObj_Check(v)) {
- *p_itself = ((WindowObject *)v)->ob_itself;
+ *p_itself = DlgObj_ConvertToWindow(v);
return 1;
}
-#endif
if (v == Py_None) { *p_itself = NULL; return 1; }
if (PyInt_Check(v)) { *p_itself = (WindowPtr)PyInt_AsLong(v); return 1; }
return _res;
}
+#if TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_ReshapeCustomWindow(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = ReshapeCustomWindow(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
static PyObject *WinObj_GetWindowClass(_self, _args)
WindowObject *_self;
PyObject *_args;
return _res;
}
+#if TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_ChangeWindowAttributes(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowAttributes setTheseAttributes;
+ WindowAttributes clearTheseAttributes;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &setTheseAttributes,
+ &clearTheseAttributes))
+ return NULL;
+ _err = ChangeWindowAttributes(_self->ob_itself,
+ setTheseAttributes,
+ clearTheseAttributes);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
#if !TARGET_API_MAC_CARBON
static PyObject *WinObj_SetWinColor(_self, _args)
PyObject *_res = NULL;
OSStatus _err;
RGBColor color;
- if (!PyArg_ParseTuple(_args, ""))
+ if (!PyArg_ParseTuple(_args, "O&",
+ QdRGB_Convert, &color))
return NULL;
_err = SetWindowContentColor(_self->ob_itself,
&color);
if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("O&",
- QdRGB_New, &color);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
return _res;
}
+#if TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_ScrollWindowRect(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inScrollRect;
+ SInt16 inHPixels;
+ SInt16 inVPixels;
+ ScrollWindowOptions inOptions;
+ RgnHandle outExposedRgn;
+ if (!PyArg_ParseTuple(_args, "O&hhlO&",
+ PyMac_GetRect, &inScrollRect,
+ &inHPixels,
+ &inVPixels,
+ &inOptions,
+ ResObj_Convert, &outExposedRgn))
+ return NULL;
+ _err = ScrollWindowRect(_self->ob_itself,
+ &inScrollRect,
+ inHPixels,
+ inVPixels,
+ inOptions,
+ outExposedRgn);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_ScrollWindowRegion(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ RgnHandle inScrollRgn;
+ SInt16 inHPixels;
+ SInt16 inVPixels;
+ ScrollWindowOptions inOptions;
+ RgnHandle outExposedRgn;
+ if (!PyArg_ParseTuple(_args, "O&hhlO&",
+ ResObj_Convert, &inScrollRgn,
+ &inHPixels,
+ &inVPixels,
+ &inOptions,
+ ResObj_Convert, &outExposedRgn))
+ return NULL;
+ _err = ScrollWindowRegion(_self->ob_itself,
+ inScrollRgn,
+ inHPixels,
+ inVPixels,
+ inOptions,
+ outExposedRgn);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
static PyObject *WinObj_ClipAbove(_self, _args)
WindowObject *_self;
PyObject *_args;
}
#endif
-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)
+static PyObject *WinObj_CalcVis(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- RgnHandle clobberedRgn;
- if (!PyArg_ParseTuple(_args, "O&",
- ResObj_Convert, &clobberedRgn))
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- PaintBehind(_self->ob_itself,
- clobberedRgn);
+ CalcVis(_self->ob_itself);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *WinObj_CalcVis(_self, _args)
+static PyObject *WinObj_BringToFront(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- CalcVis(_self->ob_itself);
+ BringToFront(_self->ob_itself);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *WinObj_CalcVisBehind(_self, _args)
+static PyObject *WinObj_SendBehind(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- RgnHandle clobberedRgn;
+ WindowPtr behindWindow;
if (!PyArg_ParseTuple(_args, "O&",
- ResObj_Convert, &clobberedRgn))
+ WinObj_Convert, &behindWindow))
return NULL;
- CalcVisBehind(_self->ob_itself,
- clobberedRgn);
+ SendBehind(_self->ob_itself,
+ behindWindow);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *WinObj_BringToFront(_self, _args)
+static PyObject *WinObj_SelectWindow(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- BringToFront(_self->ob_itself);
+ SelectWindow(_self->ob_itself);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *WinObj_SendBehind(_self, _args)
+#if TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_GetNextWindowOfClass(_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;
+ WindowPtr _rv;
+ WindowClass inWindowClass;
+ Boolean mustBeVisible;
+ if (!PyArg_ParseTuple(_args, "lb",
+ &inWindowClass,
+ &mustBeVisible))
+ return NULL;
+ _rv = GetNextWindowOfClass(_self->ob_itself,
+ inWindowClass,
+ mustBeVisible);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
return _res;
}
+#endif
-static PyObject *WinObj_SelectWindow(_self, _args)
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_IsValidWindowPtr(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
+ Boolean _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- SelectWindow(_self->ob_itself);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = IsValidWindowPtr(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
return _res;
}
+#endif
static PyObject *WinObj_HiliteWindow(_self, _args)
WindowObject *_self;
return _res;
}
+static PyObject *WinObj_BeginWindowProxyDrag(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ DragReference outNewDrag;
+ RgnHandle outDragOutlineRgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &outDragOutlineRgn))
+ return NULL;
+ _err = BeginWindowProxyDrag(_self->ob_itself,
+ &outNewDrag,
+ outDragOutlineRgn);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ DragObj_New, outNewDrag);
+ return _res;
+}
+
+static PyObject *WinObj_EndWindowProxyDrag(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ DragReference theDrag;
+ if (!PyArg_ParseTuple(_args, "O&",
+ DragObj_Convert, &theDrag))
+ return NULL;
+ _err = EndWindowProxyDrag(_self->ob_itself,
+ theDrag);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_TrackWindowProxyFromExistingDrag(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Point startPt;
+ DragReference drag;
+ RgnHandle inDragOutlineRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ PyMac_GetPoint, &startPt,
+ DragObj_Convert, &drag,
+ ResObj_Convert, &inDragOutlineRgn))
+ return NULL;
+ _err = TrackWindowProxyFromExistingDrag(_self->ob_itself,
+ startPt,
+ drag,
+ inDragOutlineRgn);
+ 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;
Boolean _rv;
EventRecord event;
- if (!PyArg_ParseTuple(_args, ""))
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &event))
return NULL;
_rv = IsWindowPathSelectClick(_self->ob_itself,
&event);
- _res = Py_BuildValue("bO&",
- _rv,
- PyMac_BuildEventRecord, &event);
+ _res = Py_BuildValue("b",
+ _rv);
return _res;
}
PyObject *_args;
{
PyObject *_res = NULL;
- short partCode;
+ WindowPartCode partCode;
Boolean front;
if (!PyArg_ParseTuple(_args, "hb",
&partCode,
return _res;
}
-static PyObject *WinObj_RepositionWindow(_self, _args)
+static PyObject *WinObj_GetWindowBounds(_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))
+ WindowRegionCode regionCode;
+ Rect globalBounds;
+ if (!PyArg_ParseTuple(_args, "H",
+ ®ionCode))
return NULL;
- _err = RepositionWindow(_self->ob_itself,
- parentWindow,
- method);
+ _err = GetWindowBounds(_self->ob_itself,
+ regionCode,
+ &globalBounds);
if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &globalBounds);
return _res;
}
return _res;
}
-static PyObject *WinObj_GetWindowBounds(_self, _args)
+static PyObject *WinObj_RepositionWindow(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSStatus _err;
- WindowRegionCode regionCode;
- Rect globalBounds;
- if (!PyArg_ParseTuple(_args, "H",
- ®ionCode))
+ WindowPtr parentWindow;
+ WindowPositionMethod method;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ WinObj_Convert, &parentWindow,
+ &method))
return NULL;
- _err = GetWindowBounds(_self->ob_itself,
- regionCode,
- &globalBounds);
+ _err = RepositionWindow(_self->ob_itself,
+ parentWindow,
+ method);
if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("O&",
- PyMac_BuildRect, &globalBounds);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
{
PyObject *_res = NULL;
OSStatus _err;
- SInt16 partCode;
+ WindowPartCode partCode;
Point ioIdealSize;
if (!PyArg_ParseTuple(_args, "h",
&partCode))
return _res;
}
+#if TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_GetWindowPropertyAttributes(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ OSType propertyCreator;
+ OSType propertyTag;
+ UInt32 attributes;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &propertyCreator,
+ PyMac_GetOSType, &propertyTag))
+ return NULL;
+ _err = GetWindowPropertyAttributes(_self->ob_itself,
+ propertyCreator,
+ propertyTag,
+ &attributes);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ attributes);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_ChangeWindowPropertyAttributes(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ OSType propertyCreator;
+ OSType propertyTag;
+ UInt32 attributesToSet;
+ UInt32 attributesToClear;
+ if (!PyArg_ParseTuple(_args, "O&O&ll",
+ PyMac_GetOSType, &propertyCreator,
+ PyMac_GetOSType, &propertyTag,
+ &attributesToSet,
+ &attributesToClear))
+ return NULL;
+ _err = ChangeWindowPropertyAttributes(_self->ob_itself,
+ propertyCreator,
+ propertyTag,
+ attributesToSet,
+ attributesToClear);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
static PyObject *WinObj_TrackBox(_self, _args)
WindowObject *_self;
PyObject *_args;
PyObject *_res = NULL;
Boolean _rv;
Point thePt;
- short partCode;
+ WindowPartCode partCode;
if (!PyArg_ParseTuple(_args, "O&h",
PyMac_GetPoint, &thePt,
&partCode))
}
#endif
-static PyObject *WinObj_GetWindowPort(_self, _args)
+static PyObject *WinObj_GetWindowGoAwayFlag(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- CGrafPtr _rv;
+ Boolean _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetWindowPort(_self->ob_itself);
- _res = Py_BuildValue("O&",
- GrafObj_New, _rv);
+ _rv = GetWindowGoAwayFlag(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
return _res;
}
-static PyObject *WinObj_SetPortWindowPort(_self, _args)
+static PyObject *WinObj_GetWindowSpareFlag(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
+ Boolean _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- SetPortWindowPort(_self->ob_itself);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = GetWindowSpareFlag(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
return _res;
}
-static PyObject *WinObj_GetWindowKind(_self, _args)
+static PyObject *WinObj_GetWindowPort(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short _rv;
+ CGrafPtr _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;
+ _rv = GetWindowPort(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ GrafObj_New, _rv);
return _res;
}
-static PyObject *WinObj_IsWindowVisible(_self, _args)
+static PyObject *WinObj_GetWindowKind(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Boolean _rv;
+ short _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = IsWindowVisible(_self->ob_itself);
- _res = Py_BuildValue("b",
+ _rv = GetWindowKind(_self->ob_itself);
+ _res = Py_BuildValue("h",
_rv);
return _res;
}
-static PyObject *WinObj_IsWindowHilited(_self, _args)
+static PyObject *WinObj_MacIsWindowVisible(_self, _args)
WindowObject *_self;
PyObject *_args;
{
Boolean _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = IsWindowHilited(_self->ob_itself);
+ _rv = MacIsWindowVisible(_self->ob_itself);
_res = Py_BuildValue("b",
_rv);
return _res;
}
-static PyObject *WinObj_GetWindowGoAwayFlag(_self, _args)
+static PyObject *WinObj_IsWindowHilited(_self, _args)
WindowObject *_self;
PyObject *_args;
{
Boolean _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetWindowGoAwayFlag(_self->ob_itself);
+ _rv = IsWindowHilited(_self->ob_itself);
_res = Py_BuildValue("b",
_rv);
return _res;
}
-#if !TARGET_API_MAC_CARBON
+#if TARGET_API_MAC_CARBON
-static PyObject *WinObj_GetWindowZoomFlag(_self, _args)
+static PyObject *WinObj_IsWindowUpdatePending(_self, _args)
WindowObject *_self;
PyObject *_args;
{
Boolean _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetWindowZoomFlag(_self->ob_itself);
+ _rv = IsWindowUpdatePending(_self->ob_itself);
_res = Py_BuildValue("b",
_rv);
return _res;
}
#endif
-#if !TARGET_API_MAC_CARBON
-
-static PyObject *WinObj_GetWindowStructureRgn(_self, _args)
+static PyObject *WinObj_MacGetNextWindow(_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;
-}
-#endif
-
-#if !TARGET_API_MAC_CARBON
-
-static PyObject *WinObj_GetWindowContentRgn(_self, _args)
- WindowObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- RgnHandle r;
- if (!PyArg_ParseTuple(_args, "O&",
- ResObj_Convert, &r))
+ WindowPtr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- GetWindowContentRgn(_self->ob_itself,
- r);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = MacGetNextWindow(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
return _res;
}
-#endif
-
-#if !TARGET_API_MAC_CARBON
-static PyObject *WinObj_GetWindowUpdateRgn(_self, _args)
+static PyObject *WinObj_GetWindowStandardState(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- RgnHandle r;
- if (!PyArg_ParseTuple(_args, "O&",
- ResObj_Convert, &r))
+ Rect rect;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- GetWindowUpdateRgn(_self->ob_itself,
- r);
- Py_INCREF(Py_None);
- _res = Py_None;
+ GetWindowStandardState(_self->ob_itself,
+ &rect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &rect);
return _res;
}
-#endif
-#if !TARGET_API_MAC_CARBON
-
-static PyObject *WinObj_GetWindowTitleWidth(_self, _args)
+static PyObject *WinObj_GetWindowUserState(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short _rv;
+ Rect rect;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetWindowTitleWidth(_self->ob_itself);
- _res = Py_BuildValue("h",
- _rv);
+ GetWindowUserState(_self->ob_itself,
+ &rect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &rect);
return _res;
}
-#endif
-static PyObject *WinObj_GetNextWindow(_self, _args)
+static PyObject *WinObj_SetWindowKind(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- WindowPtr _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ short kind;
+ if (!PyArg_ParseTuple(_args, "h",
+ &kind))
return NULL;
- _rv = GetNextWindow(_self->ob_itself);
- _res = Py_BuildValue("O&",
- WinObj_WhichWindow, _rv);
+ SetWindowKind(_self->ob_itself,
+ kind);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *WinObj_GetWindowStandardState(_self, _args)
+static PyObject *WinObj_SetWindowStandardState(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Rect r;
- if (!PyArg_ParseTuple(_args, ""))
+ Rect rect;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &rect))
return NULL;
- GetWindowStandardState(_self->ob_itself,
- &r);
- _res = Py_BuildValue("O&",
- PyMac_BuildRect, &r);
+ SetWindowStandardState(_self->ob_itself,
+ &rect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *WinObj_GetWindowUserState(_self, _args)
+static PyObject *WinObj_SetWindowUserState(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Rect r;
- if (!PyArg_ParseTuple(_args, ""))
+ Rect rect;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &rect))
return NULL;
- GetWindowUserState(_self->ob_itself,
- &r);
- _res = Py_BuildValue("O&",
- PyMac_BuildRect, &r);
+ SetWindowUserState(_self->ob_itself,
+ &rect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *WinObj_SetWindowStandardState(_self, _args)
+static PyObject *WinObj_SetPortWindowPort(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Rect r;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetRect, &r))
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- SetWindowStandardState(_self->ob_itself,
- &r);
+ SetPortWindowPort(_self->ob_itself);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *WinObj_SetWindowUserState(_self, _args)
+static PyObject *WinObj_GetWindowPortBounds(_self, _args)
WindowObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Rect r;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetRect, &r))
+ Rect bounds;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- SetWindowUserState(_self->ob_itself,
- &r);
- Py_INCREF(Py_None);
- _res = Py_None;
+ GetWindowPortBounds(_self->ob_itself,
+ &bounds);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &bounds);
return _res;
}
"() -> (UInt32 outCount)"},
{"CloneWindow", (PyCFunction)WinObj_CloneWindow, 1,
"() -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"ReshapeCustomWindow", (PyCFunction)WinObj_ReshapeCustomWindow, 1,
+ "() -> None"},
+#endif
{"GetWindowClass", (PyCFunction)WinObj_GetWindowClass, 1,
"() -> (WindowClass outClass)"},
{"GetWindowAttributes", (PyCFunction)WinObj_GetWindowAttributes, 1,
"() -> (WindowAttributes outAttributes)"},
+#if TARGET_API_MAC_CARBON
+ {"ChangeWindowAttributes", (PyCFunction)WinObj_ChangeWindowAttributes, 1,
+ "(WindowAttributes setTheseAttributes, WindowAttributes clearTheseAttributes) -> None"},
+#endif
+
#if !TARGET_API_MAC_CARBON
{"SetWinColor", (PyCFunction)WinObj_SetWinColor, 1,
"(WCTabHandle newColorTable) -> None"},
#endif
{"SetWindowContentColor", (PyCFunction)WinObj_SetWindowContentColor, 1,
- "() -> (RGBColor color)"},
+ "(RGBColor color) -> None"},
{"GetWindowContentColor", (PyCFunction)WinObj_GetWindowContentColor, 1,
"() -> (RGBColor color)"},
{"GetWindowContentPattern", (PyCFunction)WinObj_GetWindowContentPattern, 1,
"(PixPatHandle outPixPat) -> None"},
{"SetWindowContentPattern", (PyCFunction)WinObj_SetWindowContentPattern, 1,
"(PixPatHandle pixPat) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"ScrollWindowRect", (PyCFunction)WinObj_ScrollWindowRect, 1,
+ "(Rect inScrollRect, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"ScrollWindowRegion", (PyCFunction)WinObj_ScrollWindowRegion, 1,
+ "(RgnHandle inScrollRgn, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None"},
+#endif
{"ClipAbove", (PyCFunction)WinObj_ClipAbove, 1,
"() -> None"},
{"DrawNew", (PyCFunction)WinObj_DrawNew, 1,
"(Boolean update) -> None"},
#endif
- {"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"},
+
+#if TARGET_API_MAC_CARBON
+ {"GetNextWindowOfClass", (PyCFunction)WinObj_GetNextWindowOfClass, 1,
+ "(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"IsValidWindowPtr", (PyCFunction)WinObj_IsValidWindowPtr, 1,
+ "() -> (Boolean _rv)"},
+#endif
{"HiliteWindow", (PyCFunction)WinObj_HiliteWindow, 1,
"(Boolean fHilite) -> None"},
{"SetWRefCon", (PyCFunction)WinObj_SetWRefCon, 1,
"(IconRef icon) -> None"},
{"RemoveWindowProxy", (PyCFunction)WinObj_RemoveWindowProxy, 1,
"() -> None"},
+ {"BeginWindowProxyDrag", (PyCFunction)WinObj_BeginWindowProxyDrag, 1,
+ "(RgnHandle outDragOutlineRgn) -> (DragReference outNewDrag)"},
+ {"EndWindowProxyDrag", (PyCFunction)WinObj_EndWindowProxyDrag, 1,
+ "(DragReference theDrag) -> None"},
+ {"TrackWindowProxyFromExistingDrag", (PyCFunction)WinObj_TrackWindowProxyFromExistingDrag, 1,
+ "(Point startPt, DragReference drag, RgnHandle inDragOutlineRgn) -> None"},
{"TrackWindowProxyDrag", (PyCFunction)WinObj_TrackWindowProxyDrag, 1,
"(Point startPt) -> None"},
{"IsWindowModified", (PyCFunction)WinObj_IsWindowModified, 1,
{"SetWindowModified", (PyCFunction)WinObj_SetWindowModified, 1,
"(Boolean modified) -> None"},
{"IsWindowPathSelectClick", (PyCFunction)WinObj_IsWindowPathSelectClick, 1,
- "() -> (Boolean _rv, EventRecord event)"},
+ "(EventRecord event) -> (Boolean _rv)"},
{"HiliteWindowFrameForDrag", (PyCFunction)WinObj_HiliteWindowFrameForDrag, 1,
"(Boolean hilited) -> None"},
{"TransitionWindow", (PyCFunction)WinObj_TransitionWindow, 1,
{"DragWindow", (PyCFunction)WinObj_DragWindow, 1,
"(Point startPt, Rect boundsRect) -> None"},
{"ZoomWindow", (PyCFunction)WinObj_ZoomWindow, 1,
- "(short partCode, Boolean front) -> None"},
+ "(WindowPartCode 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)"},
+ {"SetWindowBounds", (PyCFunction)WinObj_SetWindowBounds, 1,
+ "(WindowRegionCode regionCode, Rect globalBounds) -> None"},
+ {"RepositionWindow", (PyCFunction)WinObj_RepositionWindow, 1,
+ "(WindowPtr parentWindow, WindowPositionMethod method) -> None"},
{"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)"},
+ "(WindowPartCode partCode) -> (Point ioIdealSize)"},
{"GetWindowIdealUserState", (PyCFunction)WinObj_GetWindowIdealUserState, 1,
"() -> (Rect userState)"},
{"SetWindowIdealUserState", (PyCFunction)WinObj_SetWindowIdealUserState, 1,
"() -> None"},
{"ShowHide", (PyCFunction)WinObj_ShowHide, 1,
"(Boolean showFlag) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"GetWindowPropertyAttributes", (PyCFunction)WinObj_GetWindowPropertyAttributes, 1,
+ "(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"ChangeWindowPropertyAttributes", (PyCFunction)WinObj_ChangeWindowPropertyAttributes, 1,
+ "(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"},
+#endif
{"TrackBox", (PyCFunction)WinObj_TrackBox, 1,
- "(Point thePt, short partCode) -> (Boolean _rv)"},
+ "(Point thePt, WindowPartCode partCode) -> (Boolean _rv)"},
{"TrackGoAway", (PyCFunction)WinObj_TrackGoAway, 1,
"(Point thePt) -> (Boolean _rv)"},
{"GetAuxWin", (PyCFunction)WinObj_GetAuxWin, 1,
"() -> (Boolean _rv, AuxWinHandle awHndl)"},
#endif
+ {"GetWindowGoAwayFlag", (PyCFunction)WinObj_GetWindowGoAwayFlag, 1,
+ "() -> (Boolean _rv)"},
+ {"GetWindowSpareFlag", (PyCFunction)WinObj_GetWindowSpareFlag, 1,
+ "() -> (Boolean _rv)"},
{"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,
+ {"MacIsWindowVisible", (PyCFunction)WinObj_MacIsWindowVisible, 1,
"() -> (Boolean _rv)"},
{"IsWindowHilited", (PyCFunction)WinObj_IsWindowHilited, 1,
"() -> (Boolean _rv)"},
- {"GetWindowGoAwayFlag", (PyCFunction)WinObj_GetWindowGoAwayFlag, 1,
- "() -> (Boolean _rv)"},
-#if !TARGET_API_MAC_CARBON
- {"GetWindowZoomFlag", (PyCFunction)WinObj_GetWindowZoomFlag, 1,
+#if TARGET_API_MAC_CARBON
+ {"IsWindowUpdatePending", (PyCFunction)WinObj_IsWindowUpdatePending, 1,
"() -> (Boolean _rv)"},
#endif
-
-#if !TARGET_API_MAC_CARBON
- {"GetWindowStructureRgn", (PyCFunction)WinObj_GetWindowStructureRgn, 1,
- "(RgnHandle r) -> None"},
-#endif
-
-#if !TARGET_API_MAC_CARBON
- {"GetWindowContentRgn", (PyCFunction)WinObj_GetWindowContentRgn, 1,
- "(RgnHandle r) -> None"},
-#endif
-
-#if !TARGET_API_MAC_CARBON
- {"GetWindowUpdateRgn", (PyCFunction)WinObj_GetWindowUpdateRgn, 1,
- "(RgnHandle r) -> None"},
-#endif
-
-#if !TARGET_API_MAC_CARBON
- {"GetWindowTitleWidth", (PyCFunction)WinObj_GetWindowTitleWidth, 1,
- "() -> (short _rv)"},
-#endif
- {"GetNextWindow", (PyCFunction)WinObj_GetNextWindow, 1,
+ {"MacGetNextWindow", (PyCFunction)WinObj_MacGetNextWindow, 1,
"() -> (WindowPtr _rv)"},
{"GetWindowStandardState", (PyCFunction)WinObj_GetWindowStandardState, 1,
- "() -> (Rect r)"},
+ "() -> (Rect rect)"},
{"GetWindowUserState", (PyCFunction)WinObj_GetWindowUserState, 1,
- "() -> (Rect r)"},
+ "() -> (Rect rect)"},
+ {"SetWindowKind", (PyCFunction)WinObj_SetWindowKind, 1,
+ "(short kind) -> None"},
{"SetWindowStandardState", (PyCFunction)WinObj_SetWindowStandardState, 1,
- "(Rect r) -> None"},
+ "(Rect rect) -> None"},
{"SetWindowUserState", (PyCFunction)WinObj_SetWindowUserState, 1,
- "(Rect r) -> None"},
+ "(Rect rect) -> None"},
+ {"SetPortWindowPort", (PyCFunction)WinObj_SetPortWindowPort, 1,
+ "() -> None"},
+ {"GetWindowPortBounds", (PyCFunction)WinObj_GetWindowPortBounds, 1,
+ "() -> (Rect bounds)"},
#if !TARGET_API_MAC_CARBON
{"CloseWindow", (PyCFunction)WinObj_CloseWindow, 1,
OSStatus _err;
WindowClass windowClass;
WindowAttributes attributes;
- Rect bounds;
+ Rect contentBounds;
WindowPtr outWindow;
if (!PyArg_ParseTuple(_args, "llO&",
&windowClass,
&attributes,
- PyMac_GetRect, &bounds))
+ PyMac_GetRect, &contentBounds))
return NULL;
_err = CreateNewWindow(windowClass,
attributes,
- &bounds,
+ &contentBounds,
&outWindow);
if (_err != noErr) return PyMac_Error(_err);
_res = Py_BuildValue("O&",
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_WhichWindow, _rv);
- return _res;
-}
-
#if !TARGET_API_MAC_CARBON
static PyObject *Win_SetDeskCPat(_self, _args)
PyObject *_args;
{
PyObject *_res = NULL;
- short _rv;
+ WindowPartCode _rv;
Point thePoint;
WindowPtr window;
if (!PyArg_ParseTuple(_args, "O&",
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_WhichWindow, _rv);
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Win_GetFrontWindowOfClass(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ WindowClass inWindowClass;
+ Boolean mustBeVisible;
+ if (!PyArg_ParseTuple(_args, "lb",
+ &inWindowClass,
+ &mustBeVisible))
+ return NULL;
+ _rv = GetFrontWindowOfClass(inWindowClass,
+ mustBeVisible);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Win_FindWindowOfClass(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Point where;
+ WindowClass inWindowClass;
+ WindowPtr outWindow;
+ WindowPartCode outWindowPart;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetPoint, &where,
+ &inWindowClass))
+ return NULL;
+ _err = FindWindowOfClass(&where,
+ inWindowClass,
+ &outWindow,
+ &outWindowPart);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&h",
+ WinObj_WhichWindow, outWindow,
+ outWindowPart);
+ return _res;
+}
+#endif
+
#if !TARGET_API_MAC_CARBON
static PyObject *Win_InitWindows(_self, _args)
#if !TARGET_API_MAC_CARBON
-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;
-}
-#endif
-
-#if !TARGET_API_MAC_CARBON
-
static PyObject *Win_InitFloatingWindows(_self, _args)
PyObject *_self;
PyObject *_args;
return _res;
}
+static PyObject *Win_GetWindowFromPort(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = GetWindowFromPort(port);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+
static PyObject *Win_WhichWindow(_self, _args)
PyObject *_self;
PyObject *_args;
{"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)"},
+ "(WindowClass windowClass, WindowAttributes attributes, Rect contentBounds) -> (WindowPtr outWindow)"},
{"CreateWindowFromResource", (PyCFunction)Win_CreateWindowFromResource, 1,
"(SInt16 resID) -> (WindowPtr outWindow)"},
{"ShowFloatingWindows", (PyCFunction)Win_ShowFloatingWindows, 1,
"() -> None"},
{"AreFloatingWindowsVisible", (PyCFunction)Win_AreFloatingWindowsVisible, 1,
"() -> (Boolean _rv)"},
- {"FrontNonFloatingWindow", (PyCFunction)Win_FrontNonFloatingWindow, 1,
- "() -> (WindowPtr _rv)"},
#if !TARGET_API_MAC_CARBON
{"SetDeskCPat", (PyCFunction)Win_SetDeskCPat, 1,
{"CheckUpdate", (PyCFunction)Win_CheckUpdate, 1,
"() -> (Boolean _rv, EventRecord theEvent)"},
{"MacFindWindow", (PyCFunction)Win_MacFindWindow, 1,
- "(Point thePoint) -> (short _rv, WindowPtr window)"},
+ "(Point thePoint) -> (WindowPartCode _rv, WindowPtr window)"},
{"FrontWindow", (PyCFunction)Win_FrontWindow, 1,
"() -> (WindowPtr _rv)"},
+ {"FrontNonFloatingWindow", (PyCFunction)Win_FrontNonFloatingWindow, 1,
+ "() -> (WindowPtr _rv)"},
+
+#if TARGET_API_MAC_CARBON
+ {"GetFrontWindowOfClass", (PyCFunction)Win_GetFrontWindowOfClass, 1,
+ "(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"FindWindowOfClass", (PyCFunction)Win_FindWindowOfClass, 1,
+ "(Point where, WindowClass inWindowClass) -> (WindowPtr outWindow, WindowPartCode outWindowPart)"},
+#endif
#if !TARGET_API_MAC_CARBON
{"InitWindows", (PyCFunction)Win_InitWindows, 1,
"() -> (CGrafPtr wMgrCPort)"},
#endif
-#if !TARGET_API_MAC_CARBON
- {"IsValidWindowPtr", (PyCFunction)Win_IsValidWindowPtr, 1,
- "(GrafPtr grafPort) -> (Boolean _rv)"},
-#endif
-
#if !TARGET_API_MAC_CARBON
{"InitFloatingWindows", (PyCFunction)Win_InitFloatingWindows, 1,
"() -> None"},
"(Rect theRect, Point thePt) -> (long _rv)"},
{"GetGrayRgn", (PyCFunction)Win_GetGrayRgn, 1,
"() -> (RgnHandle _rv)"},
+ {"GetWindowFromPort", (PyCFunction)Win_GetWindowFromPort, 1,
+ "(CGrafPtr port) -> (WindowPtr _rv)"},
{"WhichWindow", (PyCFunction)Win_WhichWindow, 1,
"Resolve an integer WindowPtr address to a Window object"},
{"FindWindow", (PyCFunction)Win_FindWindow, 1,
Win_Error = PyMac_GetOSErrException();
if (Win_Error == NULL ||
PyDict_SetItemString(d, "Error", Win_Error) != 0)
- Py_FatalError("can't initialize Win.Error");
+ return;
Window_Type.ob_type = &PyType_Type;
Py_INCREF(&Window_Type);
if (PyDict_SetItemString(d, "WindowType", (PyObject *)&Window_Type) != 0)
# These are inline-routines/defines, so we do them "by hand"
#
-
-f = Method(CGrafPtr, 'GetWindowPort',
- (WindowRef, 'theWindow', InMode),
-)
-methods.append(f)
-
-f = Method(void, 'SetPortWindowPort',
- (WindowRef, 'theWindow', InMode),
-)
-methods.append(f)
-
-f = Method(short, 'GetWindowKind',
- (WindowRef, 'theWindow', InMode),
-)
-methods.append(f)
-
-f = Method(void, 'SetWindowKind',
- (WindowRef, 'theWindow', InMode),
- (short, 'wKind', InMode),
-)
-methods.append(f)
-
-
-f = Method(Boolean, 'IsWindowVisible',
- (WindowRef, 'theWindow', InMode),
-)
-methods.append(f)
-
-f = Method(Boolean, 'IsWindowHilited',
- (WindowRef, 'theWindow', InMode),
-)
-methods.append(f)
-
-f = Method(Boolean, 'GetWindowGoAwayFlag',
- (WindowRef, 'theWindow', InMode),
-)
-methods.append(f)
-
-f = Method(Boolean, 'GetWindowZoomFlag',
- (WindowRef, 'theWindow', InMode),
- condition='#if !TARGET_API_MAC_CARBON'
-)
-methods.append(f)
-
-f = Method(void, 'GetWindowStructureRgn',
- (WindowRef, 'theWindow', InMode),
- (RgnHandle, 'r', InMode),
- condition='#if !TARGET_API_MAC_CARBON'
-)
-methods.append(f)
-
-f = Method(void, 'GetWindowContentRgn',
- (WindowRef, 'theWindow', InMode),
- (RgnHandle, 'r', InMode),
- condition='#if !TARGET_API_MAC_CARBON'
-)
-methods.append(f)
-
-f = Method(void, 'GetWindowUpdateRgn',
- (WindowRef, 'theWindow', InMode),
- (RgnHandle, 'r', InMode),
- condition='#if !TARGET_API_MAC_CARBON'
-)
-methods.append(f)
-
-f = Method(short, 'GetWindowTitleWidth',
- (WindowRef, 'theWindow', InMode),
- condition='#if !TARGET_API_MAC_CARBON'
-)
-methods.append(f)
-
-f = Method(ExistingWindowPtr, 'GetNextWindow',
- (WindowRef, 'theWindow', InMode),
-)
-methods.append(f)
-
-f = Method(void, 'GetWindowStandardState',
- (WindowRef, 'theWindow', InMode),
- (Rect, 'r', OutMode),
-)
-methods.append(f)
-
-f = Method(void, 'GetWindowUserState',
- (WindowRef, 'theWindow', InMode),
- (Rect, 'r', OutMode),
-)
-methods.append(f)
-
-
-f = Method(void, 'SetWindowStandardState',
- (WindowRef, 'theWindow', InMode),
- (Rect, 'r', InMode),
-)
-methods.append(f)
-
-f = Method(void, 'SetWindowUserState',
- (WindowRef, 'theWindow', InMode),
- (Rect, 'r', InMode),
-)
-methods.append(f)
+if 0:
+ f = Method(CGrafPtr, 'GetWindowPort',
+ (WindowRef, 'theWindow', InMode),
+ )
+ methods.append(f)
+
+ f = Method(void, 'SetPortWindowPort',
+ (WindowRef, 'theWindow', InMode),
+ )
+ methods.append(f)
+
+ f = Method(short, 'GetWindowKind',
+ (WindowRef, 'theWindow', InMode),
+ )
+ methods.append(f)
+
+ f = Method(void, 'SetWindowKind',
+ (WindowRef, 'theWindow', InMode),
+ (short, 'wKind', InMode),
+ )
+ methods.append(f)
+
+
+ f = Method(Boolean, 'IsWindowVisible',
+ (WindowRef, 'theWindow', InMode),
+ )
+ methods.append(f)
+
+ f = Method(Boolean, 'IsWindowHilited',
+ (WindowRef, 'theWindow', InMode),
+ )
+ methods.append(f)
+
+ f = Method(Boolean, 'GetWindowGoAwayFlag',
+ (WindowRef, 'theWindow', InMode),
+ )
+ methods.append(f)
+
+ f = Method(Boolean, 'GetWindowZoomFlag',
+ (WindowRef, 'theWindow', InMode),
+ condition='#if !TARGET_API_MAC_CARBON'
+ )
+ methods.append(f)
+
+ f = Method(void, 'GetWindowStructureRgn',
+ (WindowRef, 'theWindow', InMode),
+ (RgnHandle, 'r', InMode),
+ condition='#if !TARGET_API_MAC_CARBON'
+ )
+ methods.append(f)
+
+ f = Method(void, 'GetWindowContentRgn',
+ (WindowRef, 'theWindow', InMode),
+ (RgnHandle, 'r', InMode),
+ condition='#if !TARGET_API_MAC_CARBON'
+ )
+ methods.append(f)
+
+ f = Method(void, 'GetWindowUpdateRgn',
+ (WindowRef, 'theWindow', InMode),
+ (RgnHandle, 'r', InMode),
+ condition='#if !TARGET_API_MAC_CARBON'
+ )
+ methods.append(f)
+
+ f = Method(short, 'GetWindowTitleWidth',
+ (WindowRef, 'theWindow', InMode),
+ condition='#if !TARGET_API_MAC_CARBON'
+ )
+ methods.append(f)
+
+ f = Method(ExistingWindowPtr, 'GetNextWindow',
+ (WindowRef, 'theWindow', InMode),
+ )
+ methods.append(f)
+
+ f = Method(void, 'GetWindowStandardState',
+ (WindowRef, 'theWindow', InMode),
+ (Rect, 'r', OutMode),
+ )
+ methods.append(f)
+
+ f = Method(void, 'GetWindowUserState',
+ (WindowRef, 'theWindow', InMode),
+ (Rect, 'r', OutMode),
+ )
+ methods.append(f)
+
+
+ f = Method(void, 'SetWindowStandardState',
+ (WindowRef, 'theWindow', InMode),
+ (Rect, 'r', InMode),
+ )
+ methods.append(f)
+
+ f = Method(void, 'SetWindowUserState',
+ (WindowRef, 'theWindow', InMode),
+ (Rect, 'r', InMode),
+ )
+ methods.append(f)
# These have Mac prefixed to their name in the 3.1 universal headers,
# so we add the old/real names by hand.
'GetWindowPropertySize',
'RemoveWindowProperty',
'MacCloseWindow',
+ 'GetWindowList', # Don't know whether this is safe...
# Constants with funny definitions
'kMouseUpOutOfSlop',
+ 'kAllWindowClasses',
]
def makegreylist(self):
'InvalRgn',
'InvalRect',
'IsValidWindowPtr', # I think this is useless for Python, but not sure...
+ ]),
+ ('#if TARGET_API_MAC_CARBON', [
+ 'IsWindowUpdatePending',
+ 'FindWindowOfClass',
+ 'GetFrontWindowOfClass',
+ 'ChangeWindowPropertyAttributes',
+ 'GetWindowPropertyAttributes',
+ 'GetNextWindowOfClass',
+ 'ScrollWindowRegion',
+ 'ScrollWindowRect',
+ 'ChangeWindowAttributes',
+ 'ReshapeCustomWindow',
])]
def makeblacklisttypes(self):
return [
'ProcPtr',
'DragGrayRgnUPP',
+ 'WindowPaintUPP',
'Collection', # For now, to be done later
- 'DragReference', # Ditto, dragmodule doesn't export it yet.
+ 'WindowDefSpec', # Too difficult for now
+ 'WindowDefSpec_ptr',
]
def makerepairinstructions(self):
[("ExistingWindowPtr", "*", "*")]),
([("WindowRef", "FrontNonFloatingWindow", "ReturnMode")], # Ditto
[("ExistingWindowPtr", "*", "*")]),
+
+ ([("Rect_ptr", "*", "ReturnMode")], # GetWindowXXXState accessors
+ [("void", "*", "ReturnMode")]),
]
if __name__ == "__main__":
CGrafPtr = OpaqueByValueType("CGrafPtr", "GrafObj")
GrafPtr = OpaqueByValueType("GrafPtr", "GrafObj")
+DragReference = OpaqueByValueType("DragReference", "DragObj")
+
RgnHandle = OpaqueByValueType("RgnHandle", "ResObj")
PicHandle = OpaqueByValueType("PicHandle", "ResObj")
WCTabHandle = OpaqueByValueType("WCTabHandle", "ResObj")
WindowTransitionEffect = Type("WindowTransitionEffect", "l")
WindowTransitionAction = Type("WindowTransitionAction", "l")
RGBColor = OpaqueType("RGBColor", "QdRGB")
+RGBColor_ptr = RGBColor
+ScrollWindowOptions = Type("ScrollWindowOptions", "l")
+WindowPartCode = Type("WindowPartCode", "h")
+
PropertyCreator = OSTypeType("PropertyCreator")
PropertyTag = OSTypeType("PropertyTag")
includestuff = includestuff + """
#include <%s>""" % MACHEADERFILE + """
+
+#if !ACCESSOR_CALLS_ARE_FUNCTIONS
+#define GetWindowSpareFlag(win) (((CWindowPeek)(win))->spareFlag)
+#define GetWindowFromPort(port) ((WindowRef)(port))
+#define GetWindowPortBounds(win, rectp) (*(rectp) = ((CWindowPeek)(win))->port.portRect)
+#endif
+
/* Function to dispose a window, with a "normal" calling sequence */
static void
PyMac_AutoDisposeWindow(WindowPtr w)
projects / python / commitdiff