return _res;
}
+static PyObject *CFMutableStringRefObj_CFStringAppendCharacters(CFMutableStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UniChar *chars__in__;
+ UniCharCount chars__len__;
+ int chars__in_len__;
+#ifndef CFStringAppendCharacters
+ PyMac_PRECHECK(CFStringAppendCharacters);
+#endif
+ if (!PyArg_ParseTuple(_args, "u#",
+ &chars__in__, &chars__in_len__))
+ return NULL;
+ chars__len__ = chars__in_len__;
+ CFStringAppendCharacters(_self->ob_itself,
+ chars__in__, chars__len__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *CFMutableStringRefObj_CFStringAppendPascalString(CFMutableStringRefObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
static PyMethodDef CFMutableStringRefObj_methods[] = {
{"CFStringAppend", (PyCFunction)CFMutableStringRefObj_CFStringAppend, 1,
"(CFStringRef appendedString) -> None"},
+ {"CFStringAppendCharacters", (PyCFunction)CFMutableStringRefObj_CFStringAppendCharacters, 1,
+ "(Buffer chars) -> None"},
{"CFStringAppendPascalString", (PyCFunction)CFMutableStringRefObj_CFStringAppendPascalString, 1,
"(Str255 pStr, CFStringEncoding encoding) -> None"},
{"CFStringAppendCString", (PyCFunction)CFMutableStringRefObj_CFStringAppendCString, 1,
return _res;
}
+static PyObject *CF_CFStringCreateWithCharacters(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ UniChar *chars__in__;
+ UniCharCount chars__len__;
+ int chars__in_len__;
+#ifndef CFStringCreateWithCharacters
+ PyMac_PRECHECK(CFStringCreateWithCharacters);
+#endif
+ if (!PyArg_ParseTuple(_args, "u#",
+ &chars__in__, &chars__in_len__))
+ return NULL;
+ chars__len__ = chars__in_len__;
+ _rv = CFStringCreateWithCharacters((CFAllocatorRef)NULL,
+ chars__in__, chars__len__);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
static PyObject *CF_CFStringCreateWithPascalStringNoCopy(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+static PyObject *CF_CFStringCreateWithCharactersNoCopy(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ UniChar *chars__in__;
+ UniCharCount chars__len__;
+ int chars__in_len__;
+#ifndef CFStringCreateWithCharactersNoCopy
+ PyMac_PRECHECK(CFStringCreateWithCharactersNoCopy);
+#endif
+ if (!PyArg_ParseTuple(_args, "u#",
+ &chars__in__, &chars__in_len__))
+ return NULL;
+ chars__len__ = chars__in_len__;
+ _rv = CFStringCreateWithCharactersNoCopy((CFAllocatorRef)NULL,
+ chars__in__, chars__len__,
+ (CFAllocatorRef)NULL);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
static PyObject *CF_CFStringCreateMutable(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
"(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
{"CFStringCreateWithCString", (PyCFunction)CF_CFStringCreateWithCString, 1,
"(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
+ {"CFStringCreateWithCharacters", (PyCFunction)CF_CFStringCreateWithCharacters, 1,
+ "(Buffer chars) -> (CFStringRef _rv)"},
{"CFStringCreateWithPascalStringNoCopy", (PyCFunction)CF_CFStringCreateWithPascalStringNoCopy, 1,
"(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
{"CFStringCreateWithCStringNoCopy", (PyCFunction)CF_CFStringCreateWithCStringNoCopy, 1,
"(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
+ {"CFStringCreateWithCharactersNoCopy", (PyCFunction)CF_CFStringCreateWithCharactersNoCopy, 1,
+ "(Buffer chars) -> (CFStringRef _rv)"},
{"CFStringCreateMutable", (PyCFunction)CF_CFStringCreateMutable, 1,
"(CFIndex maxLength) -> (CFMutableStringRef _rv)"},
{"CFStringCreateMutableCopy", (PyCFunction)CF_CFStringCreateMutableCopy, 1,
"CFStringGetCString",
"CFStringGetCharacters",
"CFURLCreateStringWithFileSystemPath", # Gone in later releases
+ "CFStringCreateMutableWithExternalCharactersNoCopy", # Not a clue...
+ "CFStringSetExternalCharactersNoCopy",
+ "CFStringGetCharacterAtIndex", # No format for single unichars yet.
]
def makegreylist(self):
"void_ptr", # Ditto for various array lookup methods
"CFArrayApplierFunction", # Callback function pointer
"CFDictionaryApplierFunction", # Callback function pointer
- "UniChar_ptr", # XXXX To be done
- "const_UniChar_ptr", # XXXX To be done
- "UniChar", # XXXX To be done
"va_list", # For printf-to-a-cfstring. Use Python.
"const_CFStringEncoding_ptr", # To be done, I guess
]
([("UInt8_ptr", "*", "InMode"), ("CFIndex", "*", "InMode")],
[("UcharInBuffer", "*", "*")]),
+ ([("UniChar_ptr", "*", "InMode"), ("CFIndex", "*", "InMode")],
+ [("UnicodeInBuffer", "*", "*")]),
+
# Some functions return a const char *. Don't worry, we won't modify it.
([("const_char_ptr", "*", "ReturnMode")],
[("return_stringptr", "*", "*")]),
CFStringEncoding = Type("CFStringEncoding", "l")
CFComparisonResult = Type("CFComparisonResult", "l") # a bit dangerous, it's an enum
CFURLPathStyle = Type("CFURLPathStyle", "l") # a bit dangerous, it's an enum
-FSRef_ptr = OpaqueType("FSRef", "PyMac_BuildFSRef", "PyMac_GetFSRef")
-FSRef = OpaqueByValueType("FSRef", "PyMac_BuildFSRef", "PyMac_GetFSRef")
char_ptr = stringptr
return_stringptr = Type("char *", "s") # ONLY FOR RETURN VALUES!!
return _res;
}
+static PyObject *TXNObj_TXNEchoMode(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ UniChar iEchoCharacter;
+ TextEncoding iEncoding;
+ Boolean iOn;
+#ifndef TXNEchoMode
+ PyMac_PRECHECK(TXNEchoMode);
+#endif
+ if (!PyArg_ParseTuple(_args, "hlb",
+ &iEchoCharacter,
+ &iEncoding,
+ &iOn))
+ return NULL;
+ _err = TXNEchoMode(_self->ob_itself,
+ iEchoCharacter,
+ iEncoding,
+ iOn);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *TXNObj_TXNDoFontMenuSelection(TXNObjectObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
"(TXNFrameID iTXNFrameID, WindowPtr iWindow, DragReference iDragReference, Boolean iDifferentObjectSameWindow) -> None"},
{"TXNActivate", (PyCFunction)TXNObj_TXNActivate, 1,
"(TXNFrameID iTXNFrameID, TXNScrollBarState iActiveState) -> None"},
+ {"TXNEchoMode", (PyCFunction)TXNObj_TXNEchoMode, 1,
+ "(UniChar iEchoCharacter, TextEncoding iEncoding, Boolean iOn) -> None"},
{"TXNDoFontMenuSelection", (PyCFunction)TXNObj_TXNDoFontMenuSelection, 1,
"(TXNFontMenuObject iTXNFontMenuObject, SInt16 iMenuID, SInt16 iMenuItem) -> None"},
{"TXNPrepareFontMenu", (PyCFunction)TXNObj_TXNPrepareFontMenu, 1,
"TXNTypeAttributes", #TBD
"TXNMatchTextRecord", #TBD
"TXNBackground", #TBD
- "UniChar", #TBD
- "UniCharCount", #TBD
- "UniChar_ptr", #TBD
"TXNFindUPP",
"ATSUStyle", #TBD
"TXNActionKeyMapperProcPtr",
OptFSSpecPtr = OpaqueByValueType("FSSpec *", "OptFSSpecPtr")
OptRectPtr = OpaqueByValueType("Rect *", "OptRectPtr")
+
+UniChar = Type("UniChar", "h") # XXXX For now...
# ADD object type here
execfile("mltetypetest.py")
return _res;
}
+static PyObject *Res_FSCreateResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ FSRef parentRef;
+ UniChar *nameLength__in__;
+ UniCharCount nameLength__len__;
+ int nameLength__in_len__;
+ FSRef newRef;
+ FSSpec newSpec;
+ if (!PyArg_ParseTuple(_args, "O&u#",
+ PyMac_GetFSRef, &parentRef,
+ &nameLength__in__, &nameLength__in_len__))
+ return NULL;
+ nameLength__len__ = nameLength__in_len__;
+ FSCreateResFile(&parentRef,
+ nameLength__len__, nameLength__in__,
+ 0,
+ (FSCatalogInfo *)0,
+ &newRef,
+ &newSpec);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&O&",
+ PyMac_BuildFSRef, newRef,
+ PyMac_BuildFSSpec, newSpec);
+ return _res;
+}
+
static PyObject *Res_FSResourceFileAlreadyOpen(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+static PyObject *Res_FSCreateResourceFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ FSRef parentRef;
+ UniChar *nameLength__in__;
+ UniCharCount nameLength__len__;
+ int nameLength__in_len__;
+ UniChar *forkNameLength__in__;
+ UniCharCount forkNameLength__len__;
+ int forkNameLength__in_len__;
+ FSRef newRef;
+ FSSpec newSpec;
+ if (!PyArg_ParseTuple(_args, "O&u#u#",
+ PyMac_GetFSRef, &parentRef,
+ &nameLength__in__, &nameLength__in_len__,
+ &forkNameLength__in__, &forkNameLength__in_len__))
+ return NULL;
+ nameLength__len__ = nameLength__in_len__;
+ forkNameLength__len__ = forkNameLength__in_len__;
+ _rv = FSCreateResourceFile(&parentRef,
+ nameLength__len__, nameLength__in__,
+ 0,
+ (FSCatalogInfo *)0,
+ forkNameLength__len__, forkNameLength__in__,
+ &newRef,
+ &newSpec);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("hO&O&",
+ _rv,
+ PyMac_BuildFSRef, newRef,
+ PyMac_BuildFSSpec, newSpec);
+ return _res;
+}
+
+static PyObject *Res_FSOpenResourceFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ FSRef ref;
+ UniChar *forkNameLength__in__;
+ UniCharCount forkNameLength__len__;
+ int forkNameLength__in_len__;
+ SignedByte permissions;
+ SInt16 refNum;
+ if (!PyArg_ParseTuple(_args, "O&u#b",
+ PyMac_GetFSRef, &ref,
+ &forkNameLength__in__, &forkNameLength__in_len__,
+ &permissions))
+ return NULL;
+ forkNameLength__len__ = forkNameLength__in_len__;
+ _rv = FSOpenResourceFile(&ref,
+ forkNameLength__len__, forkNameLength__in__,
+ permissions,
+ &refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("hh",
+ _rv,
+ refNum);
+ return _res;
+}
+
static PyObject *Res_Resource(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
#endif
{"FSOpenResFile", (PyCFunction)Res_FSOpenResFile, 1,
"(FSRef ref, SignedByte permission) -> (short _rv)"},
+ {"FSCreateResFile", (PyCFunction)Res_FSCreateResFile, 1,
+ "(FSRef parentRef, Buffer nameLength) -> (FSRef newRef, FSSpec newSpec)"},
{"FSResourceFileAlreadyOpen", (PyCFunction)Res_FSResourceFileAlreadyOpen, 1,
"(FSRef resourceFileRef) -> (Boolean _rv, Boolean inChain, SInt16 refNum)"},
+ {"FSCreateResourceFile", (PyCFunction)Res_FSCreateResourceFile, 1,
+ "(FSRef parentRef, Buffer nameLength, Buffer forkNameLength) -> (OSErr _rv, FSRef newRef, FSSpec newSpec)"},
+ {"FSOpenResourceFile", (PyCFunction)Res_FSOpenResourceFile, 1,
+ "(FSRef ref, Buffer forkNameLength, SignedByte permissions) -> (OSErr _rv, SInt16 refNum)"},
{"Resource", (PyCFunction)Res_Resource, 1,
"Convert a string to a resource object.\n\nThe created resource object is actually just a handle,\napply AddResource() to write it to a resource file.\nSee also the Handle() docstring.\n"},
{"Handle", (PyCFunction)Res_Handle, 1,
def makeblacklisttypes(self):
return [
- "UniCharCount", #TBD
]
def makegreylist(self):
[("OutBuffer", "*", "InOutMode")]),
([("SInt8", "*", "*")],
- [("SignedByte", "*", "*")])
+ [("SignedByte", "*", "*")]),
+
+
+ ([("UniCharCount", "*", "InMode"), ("UniChar_ptr", "*", "InMode")],
+ [("UnicodeReverseInBuffer", "*", "*")]),
]
if __name__ == "__main__":
from macsupport import *
-FSRef_ptr = OpaqueType("FSRef", "PyMac_BuildFSRef", "PyMac_GetFSRef")
-
class ResMixIn:
def checkit(self):
class ResMethod(ResMixIn, MethodGenerator): pass
RsrcChainLocation = Type("RsrcChainLocation", "h")
+FSCatalogInfoBitmap = FakeType("0") # Type("FSCatalogInfoBitmap", "l")
+FSCatalogInfo_ptr = FakeType("(FSCatalogInfo *)0")
# includestuff etc. are imported from macsupport
projects / python / commitdiff