def test_byref_out(self):
o = OC_TestDecimal.alloc().init()
self.assertArgIsOut(o.getDecimal_, 0)
r = o.getDecimal_(None)
self.assertIsInstance(r, tuple)
self.assertEqual(r[0], 1)
d = r[1]
self.assertIsInstance(d, objc.NSDecimal)
self.assertEqual(str(d), "2.5")
objc._updatingMetadata(True)
objc.registerMetaDataForSelector(b"OC_TestDecimal", b"getDecimal:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_OUT, type=b'^{_NSDecimal=b8b4b1b1b18[8S]}', null_accepted=False),
#2+0: dict(type=b'o^{_NSDecimal=b8b4b1b1b18[8S]}', null_accepted=False),
}
)
)
objc._updatingMetadata(False)
self.assertArgIsOut(o.getDecimal_, 0)
r = o.getDecimal_(None)
self.assertIsInstance(r, tuple)
self.assertEqual(r[0], 1)
d = r[1]
self.assertIsInstance(d, objc.NSDecimal)
self.assertEqual(str(d), "2.5")
def test_byref_out(self):
o = OC_TestDecimal.alloc().init()
self.assertArgIsOut(o.getDecimal_, 0)
r = o.getDecimal_(None)
self.assertIsInstance(r, tuple)
self.assertEqual(r[0], 1)
d = r[1]
self.assertIsInstance(d, objc.NSDecimal)
self.assertEqual(str(d), "2.5")
objc._updatingMetadata(True)
objc.registerMetaDataForSelector(
b"OC_TestDecimal",
b"getDecimal:",
dict(
arguments={
2 + 0:
dict(type_modifier=objc._C_OUT,
type=b'^{_NSDecimal=b8b4b1b1b18[8S]}',
null_accepted=False),
#2+0: dict(type=b'o^{_NSDecimal=b8b4b1b1b18[8S]}', null_accepted=False),
}))
objc._updatingMetadata(False)
self.assertArgIsOut(o.getDecimal_, 0)
r = o.getDecimal_(None)
self.assertIsInstance(r, tuple)
self.assertEqual(r[0], 1)
d = r[1]
self.assertIsInstance(d, objc.NSDecimal)
self.assertEqual(str(d), "2.5")
def test_byref_out(self):
o = OC_TestDecimal.alloc().init()
self.assertArgIsOut(o.getDecimal_, 0)
r = o.getDecimal_(None)
self.assertIsInstance(r, tuple)
self.assertEqual(r[0], 1)
d = r[1]
self.assertIsInstance(d, objc.NSDecimal)
self.assertEqual(str(d), "2.5")
objc._updatingMetadata(True)
objc.registerMetaDataForSelector(
b"OC_TestDecimal",
b"getDecimal:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_OUT,
"type": b"^{_NSDecimal=b8b4b1b1b18[8S]}",
"null_accepted": False,
}
}
},
)
objc._updatingMetadata(False)
self.assertArgIsOut(o.getDecimal_, 0)
r = o.getDecimal_(None)
self.assertIsInstance(r, tuple)
self.assertEqual(r[0], 1)
d = r[1]
self.assertIsInstance(d, objc.NSDecimal)
self.assertEqual(str(d), "2.5")
def run(options):
record_time = int(options["record_time"])
output_dir = options["output_dir"]
output_name = options["output_name"]
pool = NSAutoreleasePool.alloc().init()
# Construct audio URL
output_path = os.path.join(output_dir, output_name)
audio_path_str = NSString.stringByExpandingTildeInPath(output_path)
audio_url = NSURL.fileURLWithPath_(audio_path_str)
# Fix metadata for AVAudioRecorder
objc.registerMetaDataForSelector(
b"AVAudioRecorder",
b"initWithURL:settings:error:",
dict(arguments={4: dict(type_modifier=objc._C_OUT)}),
)
# Initialize audio settings
audio_settings = NSDictionary.dictionaryWithDictionary_({
"AVEncoderAudioQualityKey":
0,
"AVEncoderBitRateKey":
16,
"AVSampleRateKey":
44100.0,
"AVNumberOfChannelsKey":
2,
})
# Create the AVAudioRecorder
(recorder, error) = AVAudioRecorder.alloc().initWithURL_settings_error_(
audio_url,
audio_settings,
objc.nil,
)
if error:
print "Unexpected error: " + str(error)
else:
# Record audio for x seconds
recorder.record()
for i in range(0, record_time):
try:
time.sleep(1)
except SystemExit:
# Kill task called.
print "Recording cancelled, " + str(i) + " seconds were left."
break
recorder.stop()
del pool
# Done.
os.rename(output_path, output_path + ".mp3")
print "Finished recording, audio saved to: " + output_path + ".mp3"
def parseBridgeSupport(xmldata,
globals,
frameworkName,
dylib_path=None,
inlineTab=None):
if dylib_path:
lib = ctypes.cdll.LoadLibrary(dylib_path)
_libraries.append(lib)
objc._updatingMetadata(True)
try:
prs = _BridgeSupportParser(xmldata, frameworkName)
globals.update(prs.values)
for entry in prs.cftypes:
tp = objc.registerCFSignature(*entry)
globals[entry[0]] = tp
for name, typestr in prs.opaque:
globals[name] = objc.createOpaquePointerType(name, typestr)
for name, typestr, alias in prs.structs:
if alias is not None:
globals[name] = alias
objc.createStructAlias(name, typestr, alias)
else:
globals[name] = value = objc.createStructType(
name, typestr, None)
for name, typestr, magic in prs.constants:
try:
value = objc._loadConstant(name, _as_string(typestr), magic)
except AttributeError:
continue
globals[name] = value
for class_name, sel_name, is_class in prs.meta:
objc.registerMetaDataForSelector(
class_name, sel_name,
prs.meta[(class_name, sel_name, is_class)])
if prs.functions:
objc.loadBundleFunctions(None, globals, prs.functions)
if inlineTab is not None:
objc.loadFunctionList(inlineTab, globals, prs.functions)
for name, orig in prs.func_aliases:
try:
globals[name] = globals[orig]
except KeyError:
pass
finally:
objc._updatingMetadata(False)
def parseBridgeSupport(xmldata, globals, frameworkName, dylib_path=None, inlineTab=None):
if dylib_path:
lib = ctypes.cdll.LoadLibrary(dylib_path)
_libraries.append(lib)
objc._updatingMetadata(True)
try:
prs = _BridgeSupportParser(xmldata, frameworkName)
globals.update(prs.values)
for entry in prs.cftypes:
tp = objc.registerCFSignature(*entry)
globals[entry[0]] = tp
for name, typestr in prs.opaque:
globals[name] = objc.createOpaquePointerType(name, typestr)
for name, typestr, alias in prs.structs:
if alias is not None:
globals[name] = alias
objc.createStructAlias(name, typestr, alias)
else:
globals[name] = value = objc.createStructType(name, typestr, None)
for name, typestr, magic in prs.constants:
try:
value = objc._loadConstant(name, _as_string(typestr), magic)
except AttributeError:
continue
globals[name] = value
for class_name, sel_name, is_class in prs.meta:
objc.registerMetaDataForSelector(class_name, sel_name, prs.meta[(class_name, sel_name, is_class)])
if prs.functions:
objc.loadBundleFunctions(None, globals, prs.functions)
if inlineTab is not None:
objc.loadFunctionList(inlineTab, globals, prs.functions)
for name, orig in prs.func_aliases:
try:
globals[name] = globals[orig]
except KeyError:
pass
finally:
objc._updatingMetadata(False)
def R(selector, error_arg_num):
"""Register metadata for CWInterface selectors that return NSError values.
This tells the Objective-C bridge that the requested selector would normally
take a reference to an NSError as an argument and should instead return any
errors alongside the normal return values. This causes the method to return
a tuple of [Return value, Error or None].
Args:
selector: The selector as it's known in Objective-C
error_arg_num: Which numbered argument would the NSError be passed in
"""
objc.registerMetaDataForSelector(
'CWInterface', selector,
{'arguments': {error_arg_num + 1: {'type_modifier': 'o'}}})
import objc
if hasattr(objc, 'ObjCLazyModule'):
# `ObjCLazyModule` function is available for PyObjC version >= 2.4
io_bluetooth = objc.ObjCLazyModule("IOBluetooth",
frameworkIdentifier="com.apple.IOBluetooth",
frameworkPath=objc.pathForFramework(
"/System/Library/Frameworks/IOBluetooth.framework"
),
metadict=globals())
objc.registerMetaDataForSelector(b"IOBluetoothSDPServiceRecord",
b"getRFCOMMChannelID:",
dict(
arguments={
2: dict(type=objc._C_PTR + objc._C_CHAR_AS_INT, type_modifier=objc._C_OUT),
}
))
objc.registerMetaDataForSelector(b"IOBluetoothSDPServiceRecord",
b"getL2CAPPSM:",
dict(
arguments={
2: dict(type=objc._C_PTR + objc._C_CHAR_AS_INT, type_modifier=objc._C_OUT),
}
))
objc.registerMetaDataForSelector(b"IOBluetoothDevice",
b"openRFCOMMChannelSync:withChannelID:delegate:",
dict(
from __future__ import unicode_literals
from PyObjCTools.TestSupport import *
import objc
import copy
from PyObjCTest.fnd import *
objc.registerMetaDataForSelector(
b"NSObject", b"validateValue:forKey:error:",
dict(arguments={
2: dict(type_modifier=objc._C_INOUT),
4: dict(type_modifier=objc._C_OUT),
}, ))
class OCCopy(NSObject):
def copy(self):
return self.copyWithZone_(None)
def copyWithZone_(self, zone):
v = OCCopy.allocWithZone_(zone).init()
return v
class OCObserve(NSObject):
def init(self):
self = super(OCObserve, self).init()
self.values = []
self.registrations = []
return self
@property
import objc
from PyObjCTools.TestSupport import TestCase
NSObject = objc.lookUpClass("NSObject")
NSSortDescriptor = objc.lookUpClass("NSSortDescriptor")
objc.registerMetaDataForSelector(b"NSObject", b"selector",
{"retval": {
"type": objc._C_VOID
}})
class MetadataInheritanceHelper(NSObject):
def selector(self):
return 1
class TestMetadataInheritance(TestCase):
# These tests that PyObjC's signatures overrides don't
# kick in when the new signature is incompatible with
# the native signature.
def testPythonMeta(self):
o = MetadataInheritanceHelper.alloc().init()
self.assertResultHasType(o.selector, objc._C_VOID)
def testObjCMeta(self):
o = NSSortDescriptor.alloc().init()
self.assertResultHasType(o.selector, objc._C_SEL)
from PyObjCTools.TestSupport import *
import objc
from PyObjCTest.fnd import *
objc.registerMetaDataForSelector(
b"NSObject", b"validateValue:forKey:error:",
dict(
arguments={
2: dict(type_modifier=objc._C_INOUT),
4: dict(type_modifier=objc._C_OUT),
},
))
class OCCopy (NSObject):
def copy(self):
return self.copyWithZone_(None)
def copyWithZone_(self, zone):
v = OCCopy.allocWithZone_(zone).init()
return v
class OCObserve (NSObject):
def init(self):
self = super(OCObserve, self).init()
self.values = []
self.registrations = []
return self
def register(self, object, keypath):
object.addObserver_forKeyPath_options_context_(
from PyObjCTools.TestSupport import *
import objc
from PyObjCTest.testoutputinitializer import PyObjC_TestOutputInitializer
objc.registerMetaDataForSelector("PyObjC_TestOutputInitializer",
"initWithBooleanOutput:", dict(arguments={
2: dict(type_modifier='o')}))
class TestOutputInitializer(TestCase):
def testOutputInitializer(self):
robj, rtrue = PyObjC_TestOutputInitializer.alloc().initWithBooleanOutput_(None)
self.assertEquals(rtrue, objc.YES)
self.assertEquals(robj.isInitialized(), objc.YES)
if __name__ == '__main__':
main()
def __init__(self, window):
BrowserView.instances[window.uid] = self
self.uid = window.uid
self.pywebview_window = window
self.js_bridge = None
self._file_name = None
self._file_name_semaphore = Semaphore(0)
self._current_url_semaphore = Semaphore(0)
self.closed = window.closed
self.closing = window.closing
self.shown = window.shown
self.loaded = window.loaded
self.confirm_close = window.confirm_close
self.title = window.title
self.text_select = window.text_select
self.is_fullscreen = False
self.hidden = window.hidden
self.minimized = window.minimized
rect = AppKit.NSMakeRect(0.0, 0.0, window.initial_width,
window.initial_height)
window_mask = AppKit.NSTitledWindowMask | AppKit.NSClosableWindowMask | AppKit.NSMiniaturizableWindowMask
if window.resizable:
window_mask = window_mask | AppKit.NSResizableWindowMask
if window.frameless:
window_mask = window_mask | NSFullSizeContentViewWindowMask | AppKit.NSTexturedBackgroundWindowMask
# The allocated resources are retained because we would explicitly delete
# this instance when its window is closed
self.window = AppKit.NSWindow.alloc().\
initWithContentRect_styleMask_backing_defer_(rect, window_mask, AppKit.NSBackingStoreBuffered, False).retain()
self.window.setTitle_(window.title)
self.window.setMinSize_(
AppKit.NSSize(window.min_size[0], window.min_size[1]))
self.window.setAnimationBehavior_(
AppKit.NSWindowAnimationBehaviorDocumentWindow)
BrowserView.cascade_loc = self.window.cascadeTopLeftFromPoint_(
BrowserView.cascade_loc)
frame = self.window.frame()
frame.size.width = window.initial_width
frame.size.height = window.initial_height
self.window.setFrame_display_(frame, True)
self.webkit = BrowserView.WebKitHost.alloc().initWithFrame_(
rect).retain()
user_agent = settings.get('user_agent') or _user_agent
if user_agent:
self.webkit.setCustomUserAgent_(user_agent)
if window.initial_x is not None and window.initial_y is not None:
self.move(window.initial_x, window.initial_y)
else:
self.window.center()
if window.transparent:
self.window.setOpaque_(False)
self.window.setHasShadow_(False)
self.window.setBackgroundColor_(
BrowserView.nscolor_from_hex(window.background_color, 0))
self.webkit.setValue_forKey_(True, 'drawsTransparentBackground')
else:
self.window.setBackgroundColor_(
BrowserView.nscolor_from_hex(window.background_color))
self._browserDelegate = BrowserView.BrowserDelegate.alloc().init(
).retain()
self._windowDelegate = BrowserView.WindowDelegate.alloc().init(
).retain()
self.webkit.setUIDelegate_(self._browserDelegate)
self.webkit.setNavigationDelegate_(self._browserDelegate)
self.window.setDelegate_(self._windowDelegate)
self.frameless = window.frameless
self.easy_drag = window.easy_drag
if window.frameless:
# Make content full size and titlebar transparent
self.window.setTitlebarAppearsTransparent_(True)
self.window.setTitleVisibility_(NSWindowTitleHidden)
self.window.standardWindowButton_(
AppKit.NSWindowCloseButton).setHidden_(True)
self.window.standardWindowButton_(
AppKit.NSWindowMiniaturizeButton).setHidden_(True)
self.window.standardWindowButton_(
AppKit.NSWindowZoomButton).setHidden_(True)
else:
# Set the titlebar color (so that it does not change with the window color)
self.window.contentView().superview().subviews().lastObject(
).setBackgroundColor_(AppKit.NSColor.windowBackgroundColor())
if window.on_top:
self.window.setLevel_(AppKit.NSStatusWindowLevel)
try:
self.webkit.evaluateJavaScript_completionHandler_(
'', lambda a, b: None)
except TypeError:
registerMetaDataForSelector(
b'WKWebView', b'evaluateJavaScript:completionHandler:',
_eval_js_metadata)
config = self.webkit.configuration()
config.userContentController().addScriptMessageHandler_name_(
self._browserDelegate, 'browserDelegate')
try:
config.preferences().setValue_forKey_(
Foundation.NO, 'backspaceKeyNavigationEnabled')
except:
pass
if _debug:
config.preferences().setValue_forKey_(Foundation.YES,
'developerExtrasEnabled')
self.js_bridge = BrowserView.JSBridge.alloc().initWithObject_(window)
config.userContentController().addScriptMessageHandler_name_(
self.js_bridge, 'jsBridge')
if window.real_url:
self.url = window.real_url
self.load_url(window.real_url)
elif window.html:
self.load_html(window.html, '')
else:
self.load_html(default_html, '')
if window.fullscreen:
self.toggle_fullscreen()
self.shown.set()
def setupMetaData():
# Note to self: what we think of as the first argument of a method is
# actually the third one, the objc runtime implicitly passed 'self' and
# the selector as well. Therefore we need to start counting at 2 instead
# of 0.
#
# Note2: the code below would normally be done using a metadata file
# instead of hardcoding.
objc.registerMetaDataForSelector("OC_MetaDataTest", "make4Tuple:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_IN, c_array_of_fixed_length=4, null_accepted=False),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "null4Tuple:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_IN, c_array_of_fixed_length=4, null_accepted=True),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "makeObjectArray:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_IN, c_array_delimited_by_null=True, null_accepted=False),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "makeStringArray:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_IN, c_array_delimited_by_null=True, null_accepted=False),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "nullStringArray:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_IN, c_array_delimited_by_null=True, null_accepted=True),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "makeIntArray:count:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_IN, c_array_length_in_arg=2+1, null_accepted=False),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "makeIntArray:countPtr:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_IN, c_array_length_in_arg=2+1, null_accepted=False),
2+1: dict(type_modifier=objc._C_IN, null_accepted=False),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "nullIntArray:count:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_IN, c_array_length_in_arg=2+1, null_accepted=True),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "fillArray:uptoCount:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_OUT, c_array_length_in_arg=2+1, c_array_length_in_result=True, null_accepted=False),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "fillArray:count:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_OUT, c_array_length_in_arg=2+1, null_accepted=False),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "nullfillArray:count:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_OUT, c_array_length_in_arg=2+1, null_accepted=True),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "maybeFillArray:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_OUT, c_array_of_fixed_length=4, c_array_length_in_result=True, null_accepted=False),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "fill4Tuple:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_OUT, c_array_of_fixed_length=4, null_accepted=False),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "nullfill4Tuple:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_OUT, c_array_of_fixed_length=4, null_accepted=True),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "fillStringArray:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_OUT, c_array_delimited_by_null=True, null_accepted=False),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "nullfillStringArray:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_OUT, c_array_delimited_by_null=True, null_accepted=True),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "reverseArray:uptoCount:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_INOUT, c_array_length_in_arg=2+1, c_array_length_in_result=True, null_accepted=False),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "reverseArray:count:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_INOUT, c_array_length_in_arg=2+1, null_accepted=False),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "nullreverseArray:count:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_INOUT, c_array_length_in_arg=2+1, null_accepted=True),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "reverseStrings:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_INOUT, c_array_delimited_by_null=True, null_accepted=False),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "nullreverseStrings:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_INOUT, c_array_delimited_by_null=True, null_accepted=True),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "maybeReverseArray:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_INOUT, c_array_of_fixed_length=4, c_array_length_in_result=True, null_accepted=True),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "reverse4Tuple:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_INOUT, c_array_of_fixed_length=4, null_accepted=False),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "nullreverse4Tuple:on:",
dict(
arguments={
2+0: dict(type_modifier=objc._C_INOUT, c_array_of_fixed_length=4, null_accepted=True),
}
)
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "makeIntArrayOf5On:",
dict(
retval=dict(c_array_of_fixed_length=5)
),
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "makeStringArrayOn:",
dict(
retval=dict(c_array_delimited_by_null=True),
),
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "makeIntArrayOf:on:",
dict(
retval=dict(c_array_length_in_arg=2+0)
),
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "nullIntArrayOf5On:",
dict(
retval=dict(c_array_of_fixed_length=5)
),
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "nullStringArrayOn:",
dict(
retval=dict(c_array_delimited_by_null=True),
),
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "nullIntArrayOf:on:",
dict(
retval=dict(c_array_length_in_arg=2+0)
),
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "sumX:andY:on:",
dict(arguments={
2+0: dict(type_modifier=objc._C_IN, null_accepted=False),
2+1: dict(type_modifier=objc._C_IN, null_accepted=False),
}))
objc.registerMetaDataForSelector("OC_MetaDataTest", "divBy5:remainder:on:",
dict(arguments={
2+1: dict(type_modifier=objc._C_OUT, null_accepted=False),
}))
objc.registerMetaDataForSelector("OC_MetaDataTest", "swapX:andY:on:",
dict(arguments={
2+0: dict(type_modifier=objc._C_INOUT, null_accepted=False),
2+1: dict(type_modifier=objc._C_INOUT, null_accepted=False),
}))
objc.registerMetaDataForSelector("OC_MetaDataTest", "input:output:inputAndOutput:on:",
dict(arguments={
2+0: dict(type_modifier=objc._C_IN, null_accepted=True),
2+1: dict(type_modifier=objc._C_OUT, null_accepted=True),
2+2: dict(type_modifier=objc._C_INOUT, null_accepted=True),
}))
def applicationWillTerminate_(self, notification):
self.controller.app_will_terminate(notification.object())
# This may be removed if the app does not crash when the save panel is
# cancelled after quitting with unsaved documents.
# See also:
# [PyObjC-svn] r2350 - in trunk/pyobjc/pyobjc-framework-Cocoa: . Lib/AppKit PyObjCTest
# http://permalink.gmane.org/gmane.comp.python.pyobjc.cvs/2763
# Re: Crash when closing all documents
# http://permalink.gmane.org/gmane.comp.python.pyobjc.devel/5563
objc.registerMetaDataForSelector(
b'NSDocumentController', b'_documentController:shouldTerminate:context:',
{'arguments': {
4: {
'type': b'^v'
}
}})
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Document saving helper
class DocumentSavingDelegate(fn.NSObject):
"""Prompt to save each document by asking if it can be closed
Any Projects will be saved by calling saveIfNecessary() rather than
being asked to close.
"""
MYDIR = os.path.dirname(os.path.abspath(__file__))
NSArray = objc.lookUpClass("NSArray")
NSKeyedArchiver = objc.lookUpClass("NSKeyedArchiver")
NSUnarchiver = objc.lookUpClass("NSUnarchiver")
NSKeyedUnarchiver = objc.lookUpClass("NSKeyedUnarchiver")
NSSet = objc.lookUpClass("NSSet")
objc.registerMetaDataForSelector(
b"NSKeyedArchiver",
b"archivedDataWithRootObject:requiringSecureCoding:error:",
{
"arguments": {
2 + 1: {
"type": objc._C_NSBOOL
},
2 + 2: {
"type_modifier": objc._C_OUT
},
}
},
)
if os_level_key(os_release()) >= os_level_key("10.13"):
# Secure coding was introduced in 10.13.
class TestNSKeyedArchivingInterop(TestCase):
@classmethod
def setUpClass(cls):
src = os.path.join(MYDIR, "dump-nsarchive-securecoding.m")
dst = cls.progpath = os.path.join(MYDIR,
# Cannot import Foundation, we're in the framework loading code.
NSAutoreleasePool = objc.lookUpClass('NSAutoreleasePool')
_gBridgeSupportDirectories = (
'/System/Library/BridgeSupport',
# Don't use the rest of the default search path to avoid relying on data that
# might be on a single system. That would make it harder to create standalone
# apps in some cases.
# '/Library/BridgeSupport',
# os.path.expanduser('~/Library/BridgeSupport'),
)
for method in (b'alloc', b'copy', b'copyWithZone:', b'mutableCopy',
b'mutableCopyWithZone:'):
objc.registerMetaDataForSelector(
b'NSObject', method, dict(retval=dict(already_retained=True), ))
def _parseBridgeSupport(data, globals, frameworkName, *args, **kwds):
try:
try:
objc.parseBridgeSupport(data, globals, frameworkName, *args,
**kwds)
except objc.internal_error, e:
import warnings
warnings.warn(
"Error parsing BridgeSupport data for %s: %s" %
(frameworkName, e), RuntimeWarning)
finally:
# Add formal protocols to the protocols submodule, for backward
# compatibility with earlier versions of PyObjC
from PyObjCTools.TestSupport import *
import objc
NSObject = objc.lookUpClass("NSObject")
NSSortDescriptor = objc.lookUpClass("NSSortDescriptor")
objc.registerMetaDataForSelector(b"NSObject", b"selector",
dict(
retval=dict(type=objc._C_VOID)
))
class MetadataInheritanceHelper (NSObject):
def selector(self): return 1
class TestMetadataInheritance (TestCase):
# These tests that PyObjC's signatures overrides don't
# kick in when the new signature is incompatible with
# the native signature.
def testPythonMeta(self):
o = MetadataInheritanceHelper.alloc().init()
self.assertResultHasType(o.selector, objc._C_VOID)
def testObjCMeta(self):
o = NSSortDescriptor.alloc().init()
self.assertResultHasType(o.selector, objc._C_SEL)
if __name__ == "__main__":
main()
from PyObjCTools.TestSupport import *
import objc
objc.registerMetaDataForSelector(
b"OC_CallbackTest", b"selWithSEL:SEL:andObject:", {
"arguments": {
2: {
"sel_of_type": b"q@:q",
},
3: {
"sel_of_type": b"v@:@@^v",
}
}
}
)
objc.registerMetaDataForSelector(
b"OC_CallbackTest", b"selWithCallback:", {
"arguments": {
2: {
"callable": {
"retval": { "type": b"q", },
"arguments": {
"0": { "type": b"@", },
"1": { "type": b"i", },
}
}
},
}
}
def parseBridgeSupport(xmldata, globals, frameworkName, dylib_path=None, inlineTab=None):
if dylib_path:
lib = ctypes.cdll.LoadLibrary(dylib_path)
_libraries.append(lib)
objc._updatingMetadata(True)
try:
prs = _BridgeSupportParser(xmldata, frameworkName)
globals.update(prs.values)
for entry in prs.cftypes:
tp = objc.registerCFSignature(*entry)
globals[entry[0]] = tp
for name, typestr in prs.opaque:
globals[name] = objc.createOpaquePointerType(name, typestr)
for name, typestr, alias in prs.structs:
if alias is not None:
globals[name] = alias
objc.createStructAlias(name, typestr, alias)
else:
globals[name] = value = objc.createStructType(name, typestr, None)
for name, typestr, magic in prs.constants:
try:
value = objc._loadConstant(name, typestr, magic)
except AttributeError:
continue
globals[name] = value
for class_name, sel_name, is_class in prs.meta:
objc.registerMetaDataForSelector(class_name, sel_name, prs.meta[(class_name, sel_name, is_class)])
for name, method_list in prs.informal_protocols:
proto = objc.informal_protocol(name, method_list)
# XXX: protocols submodule should be deprecated
if "protocols" not in globals:
mod_name = "%s.protocols"%(frameworkName,)
m = globals["protocols"] = type(objc)(mod_name)
sys.modules[mod_name] = m
else:
m = globals["protocols"]
setattr(m, name, proto)
if prs.functions:
objc.loadBundleFunctions(None, globals, prs.functions)
if inlineTab is not None:
objc.loadFunctionList(inlineTab, globals, prs.functions)
for name, orig in prs.func_aliases:
try:
globals[name] = globals[orig]
except KeyError:
pass
finally:
objc._updatingMetadata(False)
from PyObjCTools.TestSupport import *
import objc
from PyObjCTest.sockaddr import PyObjCTestSockAddr
objc.registerMetaDataForSelector(
b"PyObjCTestSockAddr", b"sockAddrToValue:", dict(arguments={2 + 0: dict(type_modifier=objc._C_IN)})
)
objc.registerMetaDataForSelector(
b"PyObjCTestSockAddr", b"getIPv4Addr:", dict(arguments={2 + 0: dict(type_modifier=objc._C_OUT)})
)
objc.registerMetaDataForSelector(
b"PyObjCTestSockAddr", b"getIPv6Addr:", dict(arguments={2 + 0: dict(type_modifier=objc._C_OUT)})
)
class TestSockAddrSupport(TestCase):
def testToObjC(self):
o = PyObjCTestSockAddr
v = o.sockAddrToValue_(("1.2.3.4", 45))
self.assertEquals(v, ("IPv4", "1.2.3.4", 45))
v = o.sockAddrToValue_(("::1", 90, 4, 5))
self.assertEquals(v, ("IPv6", "::1", 90, 4, 5))
def testIPv4FromC(self):
o = PyObjCTestSockAddr
v = o.getIPv4Addr_(None)
self.assertEquals(v, (b"127.0.0.1", 80))
from PyObjCTools.TestSupport import *
import objc
from PyObjCTest.sockaddr import PyObjCTestSockAddr
objc.registerMetaDataForSelector(
b"PyObjCTestSockAddr", b"sockAddrToValue:",
dict(arguments={
2 + 0: dict(type_modifier=objc._C_IN),
}))
objc.registerMetaDataForSelector(
b"PyObjCTestSockAddr", b"getIPv4Addr:",
dict(arguments={
2 + 0: dict(type_modifier=objc._C_OUT),
}))
objc.registerMetaDataForSelector(
b"PyObjCTestSockAddr", b"getIPv6Addr:",
dict(arguments={
2 + 0: dict(type_modifier=objc._C_OUT),
}))
class TestSockAddrSupport(TestCase):
def testToObjC(self):
o = PyObjCTestSockAddr
v = o.sockAddrToValue_(('1.2.3.4', 45))
self.assertEqual(v, ('IPv4', '1.2.3.4', 45))
v = o.sockAddrToValue_(('::1', 90, 4, 5))
self.assertEqual(v, ('IPv6', '::1', 90, 4, 5))
def __init__(self, window):
BrowserView.instances[window.uid] = self
self.uid = window.uid
self.pywebview_window = window
self.js_bridge = None
self._file_name = None
self._file_name_semaphore = Semaphore(0)
self._current_url_semaphore = Semaphore(0)
self.closed = window.closed
self.closing = window.closing
self.shown = window.shown
self.loaded = window.loaded
self.confirm_close = window.confirm_close
self.title = window.title
self.text_select = window.text_select
self.is_fullscreen = False
self.hidden = window.hidden
self.minimized = window.minimized
rect = AppKit.NSMakeRect(0.0, 0.0, window.initial_width,
window.initial_height)
window_mask = AppKit.NSTitledWindowMask | AppKit.NSClosableWindowMask | AppKit.NSMiniaturizableWindowMask
if window.resizable:
window_mask = window_mask | AppKit.NSResizableWindowMask
if window.frameless:
window_mask = window_mask | NSFullSizeContentViewWindowMask | AppKit.NSTexturedBackgroundWindowMask
# The allocated resources are retained because we would explicitly delete
# this instance when its window is closed
self.window = AppKit.NSWindow.alloc(). \
initWithContentRect_styleMask_backing_defer_(rect, window_mask, AppKit.NSBackingStoreBuffered,
False).retain()
self.window.setTitle_(window.title)
self.window.setBackgroundColor_(
BrowserView.nscolor_from_hex(window.background_color))
self.window.setMinSize_(
AppKit.NSSize(window.min_size[0], window.min_size[1]))
self.window.setAnimationBehavior_(
AppKit.NSWindowAnimationBehaviorDocumentWindow)
BrowserView.cascade_loc = self.window.cascadeTopLeftFromPoint_(
BrowserView.cascade_loc)
frame = self.window.frame()
frame.size.width = window.initial_width
frame.size.height = window.initial_height
self.window.setFrame_display_(frame, True)
self.webkit = BrowserView.WebKitHost.alloc().initWithFrame_(
rect).retain()
ua = "Mozilla/5.0 (iPad; CPU OS 11_0 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) Version/11.0 Mobile/15A5341f Safari/604.1"
self.webkit.customUserAgent = ua # "Mozilla/5.0 (iPad; CPU OS 11_0 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) Version/11.0 Mobile/15A5341f Safari/604.1"
self.webkit.applicationNameForUserAgent = ua
if window.initial_x is not None and window.initial_y is not None:
self.move(window.initial_x, window.initial_y)
else:
self.window.center()
self._browserDelegate = BrowserView.BrowserDelegate.alloc().init(
).retain()
self._windowDelegate = BrowserView.WindowDelegate.alloc().init(
).retain()
self.webkit.setUIDelegate_(self._browserDelegate)
self.webkit.setNavigationDelegate_(self._browserDelegate)
self.window.setDelegate_(self._windowDelegate)
self.frameless = window.frameless
if window.frameless:
# Make content full size and titlebar transparent
self.window.setTitlebarAppearsTransparent_(True)
self.window.setTitleVisibility_(NSWindowTitleHidden)
else:
# Set the titlebar color (so that it does not change with the window color)
self.window.contentView().superview().subviews().lastObject(
).setBackgroundColor_(AppKit.NSColor.windowBackgroundColor())
#replace_ua = "Object.defineProperty(window.navigator, 'userAgent', {get: function () {return 'Mozilla/5.0 (iPad; CPU OS 11_0 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) Version/11.0 Mobile/15A5341f Safari/604.1'}});"
#self.webkit.evaluateJavaScript_completionHandler_(replace_ua, lambda a, b: None);
#print(replace_ua)
try:
self.webkit.evaluateJavaScript_completionHandler_(
'', lambda a, b: None)
except TypeError:
registerMetaDataForSelector(
b'WKWebView', b'evaluateJavaScript:completionHandler:',
_eval_js_metadata)
config = self.webkit.configuration()
config.userContentController().addScriptMessageHandler_name_(
self._browserDelegate, 'browserDelegate')
try:
config.preferences().setValue_forKey_(
Foundation.NO, 'backspaceKeyNavigationEnabled')
except:
pass
if _debug:
config.preferences().setValue_forKey_(Foundation.YES,
'developerExtrasEnabled')
self.js_bridge = BrowserView.JSBridge.alloc().initWithObject_(window)
config.userContentController().addScriptMessageHandler_name_(
self.js_bridge, 'jsBridge')
if window.url:
self.url = window.url
self.load_url(window.url)
elif window.html:
self.load_html(window.html, '')
else:
self.load_html(default_html, '')
if window.fullscreen:
self.toggle_fullscreen()
self.shown.set()
def __init__(self, window):
BrowserView.instances[window.uid] = self
self.uid = window.uid
self.pywebview_window = window
self.js_bridge = None
self._file_name = None
self._file_name_semaphore = Semaphore(0)
self._current_url_semaphore = Semaphore(0)
self.shown = window.shown
self.loaded = window.loaded
self.confirm_close = window.confirm_close
self.title = window.title
self.text_select = window.text_select
self.is_fullscreen = False
rect = AppKit.NSMakeRect(0.0, 0.0, window.width, window.height)
window_mask = AppKit.NSTitledWindowMask | AppKit.NSClosableWindowMask | AppKit.NSMiniaturizableWindowMask
if window.resizable:
window_mask = window_mask | AppKit.NSResizableWindowMask
# The allocated resources are retained because we would explicitly delete
# this instance when its window is closed
self.window = AppKit.NSWindow.alloc().\
initWithContentRect_styleMask_backing_defer_(rect, window_mask, AppKit.NSBackingStoreBuffered, False).retain()
self.window.setTitle_(window.title)
self.window.setBackgroundColor_(
BrowserView.nscolor_from_hex(window.background_color))
self.window.setMinSize_(
AppKit.NSSize(window.min_size[0], window.min_size[1]))
self.window.setAnimationBehavior_(
AppKit.NSWindowAnimationBehaviorDocumentWindow)
BrowserView.cascade_loc = self.window.cascadeTopLeftFromPoint_(
BrowserView.cascade_loc)
self.webkit = BrowserView.WebKitHost.alloc().initWithFrame_(
rect).retain()
self._browserDelegate = BrowserView.BrowserDelegate.alloc().init(
).retain()
self._windowDelegate = BrowserView.WindowDelegate.alloc().init(
).retain()
self.webkit.setUIDelegate_(self._browserDelegate)
self.webkit.setNavigationDelegate_(self._browserDelegate)
self.window.setDelegate_(self._windowDelegate)
self.frameless = window.frameless
if window.frameless:
# Make content full size and titlebar transparent
window_mask = window_mask | NSFullSizeContentViewWindowMask | AppKit.NSTexturedBackgroundWindowMask
self.window.setStyleMask_(window_mask)
self.window.setTitlebarAppearsTransparent_(True)
self.window.setTitleVisibility_(NSWindowTitleHidden)
else:
# Set the titlebar color (so that it does not change with the window color)
self.window.contentView().superview().subviews().lastObject(
).setBackgroundColor_(AppKit.NSColor.windowBackgroundColor())
try:
self.webkit.evaluateJavaScript_completionHandler_(
'', lambda a, b: None)
except TypeError:
registerMetaDataForSelector(
b'WKWebView', b'evaluateJavaScript:completionHandler:',
_eval_js_metadata)
config = self.webkit.configuration()
config.userContentController().addScriptMessageHandler_name_(
self._browserDelegate, 'browserDelegate')
try:
config.preferences().setValue_forKey_(
Foundation.NO, 'backspaceKeyNavigationEnabled')
except:
pass
if _debug:
config.preferences().setValue_forKey_(Foundation.YES,
'developerExtrasEnabled')
#config.preferences().setValue_forKey_(Foundation.YES, 'inlineMediaPlaybackRequiresPlaysInlineAttribute')
#config.preferences().setValue_forKey_(Foundation.YES, 'allowsInlineMediaPlayback')
#config.preferences().setValue_forKey_(Foundation.YES, 'mediaSourceEnabled')
#config.preferences().setValue_forKey_(Foundation.NO, 'invisibleMediaAutoplayNotPermitted')
self.js_bridge = BrowserView.JSBridge.alloc().initWithObject_(window)
config.userContentController().addScriptMessageHandler_name_(
self.js_bridge, 'jsBridge')
if window.url:
self.url = window.url
self.load_url(window.url)
elif window.html:
self.load_html(window.html, '')
else:
self.load_html(default_html, '')
if window.fullscreen:
self.toggle_fullscreen()
self.shown.set()
NSURL = objc.lookUpClass('NSURL')
NSBundle = objc.lookUpClass('NSBundle')
NSAutoreleasePool = objc.lookUpClass('NSAutoreleasePool')
NSArray = objc.lookUpClass('NSArray')
NSDictionary = objc.lookUpClass('NSDictionary')
NSLocale = objc.lookUpClass('NSLocale')
NSNumberFormatter = objc.lookUpClass('NSNumberFormatter')
# It's a little strange, but it seems like registerMetaDataForSelector required bytes for the first
# 2 arguments, but it needs str in its metadata dicts.
NSWorkspace = objc.lookUpClass('NSWorkspace')
objc.registerMetaDataForSelector(b'NSWorkspace', b'performFileOperation:source:destination:files:tag:',
{
'retval': {'type': objc._C_NSBOOL},
'arguments': {
2+4: {'type_modifier': objc._C_OUT,}
}
})
objc.registerMetaDataForSelector(b'NSWorkspace', b'typeOfFile:error:',
{
'arguments': {
2+1: {'type_modifier': objc._C_OUT,}
}
})
NSExceptionHandler = objc.lookUpClass('NSExceptionHandler')
objc.registerMetaDataForSelector(b'NSExceptionHandler', b'setExceptionHandlingMask:',
{
'arguments': {
2+0: {'type': objc._C_UINT,}
from PyObjCTools.TestSupport import *
import objc
objc.registerMetaDataForSelector(
b"OCTestNULL",
b"callOut:",
dict(arguments={2: dict(type_modifier=b"o", null_accepted=True)}),
)
objc.registerMetaDataForSelector(
b"OCTestNULL",
b"callList:andInOut2:",
dict(arguments={3: dict(type_modifier=b"o", null_accepted=True)}),
)
objc.registerMetaDataForSelector(
b"OCTestNULL",
b"callList:andInOut:",
dict(arguments={3: dict(type_modifier=b"N", null_accepted=True)}),
)
objc.registerMetaDataForSelector(
b"OCTestNULL",
b"callList:andIn:",
dict(arguments={3: dict(type_modifier=b"n", null_accepted=True)}),
)
objc.registerMetaDataForSelector(
b"OCTestNULL",
b"callList:andOut:",
dict(arguments={3: dict(type_modifier=b"o", null_accepted=True)}),
)
objc.registerMetaDataForSelector(
b"OCTestNULL",
b"on:callList:andInOut:",
def setupMetaData():
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"int8Value",
{"retval": {"type": objc._C_CHAR_AS_INT}},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"int8Array",
{
"retval": {
"type": objc._C_PTR + objc._C_CHAR_AS_INT,
"c_array_of_fixed_length": 4,
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"int8String",
{
"retval": {
"type": objc._C_PTR + objc._C_CHAR_AS_INT,
"c_array_delimited_by_null": True,
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"int8StringArg:",
{
"arguments": {
2: {
"type": objc._C_PTR + objc._C_CHAR_AS_INT,
"c_array_delimited_by_null": True,
"type_modifier": objc._C_IN,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"int8Arg:andint8Arg:",
{
"arguments": {
2: {"type": objc._C_CHAR_AS_INT},
3: {"type": objc._C_CHAR_AS_INT},
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"int8ArrayOf4In:",
{
"arguments": {
2: {
"type": objc._C_PTR + objc._C_CHAR_AS_INT,
"type_modifier": objc._C_IN,
"c_array_of_fixed_length": 4,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"int8ArrayOf4Out:",
{
"arguments": {
2: {
"type": objc._C_PTR + objc._C_CHAR_AS_INT,
"type_modifier": objc._C_OUT,
"c_array_of_fixed_length": 4,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"int8ArrayOf4InOut:",
{
"arguments": {
2: {
"type": objc._C_PTR + objc._C_CHAR_AS_INT,
"type_modifier": objc._C_INOUT,
"c_array_of_fixed_length": 4,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"int8ArrayOfCount:In:",
{
"arguments": {
3: {
"type": objc._C_PTR + objc._C_CHAR_AS_INT,
"type_modifier": objc._C_IN,
"c_array_of_lenght_in_arg": 2,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"int8ArrayOfCount:Out:",
{
"arguments": {
3: {
"type": objc._C_PTR + objc._C_CHAR_AS_INT,
"type_modifier": objc._C_OUT,
"c_array_of_lenght_in_arg": 2,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"int8ArrayOfCount:InOut:",
{
"arguments": {
3: {
"type": objc._C_PTR + objc._C_CHAR_AS_INT,
"type_modifier": objc._C_INOUT,
"c_array_of_lenght_in_arg": 2,
}
}
},
)
def setupMetaData():
objc.registerMetaDataForSelector(b"OC_TestSpecialTypeCode", b"BOOLValue",
{"retval": {
"type": objc._C_NSBOOL
}})
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"BOOLArray",
{
"retval": {
"type": objc._C_PTR + objc._C_NSBOOL,
"c_array_of_fixed_length": 4,
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"BOOLArg:andBOOLArg:",
{
"arguments": {
2: {
"type": objc._C_NSBOOL
},
3: {
"type": objc._C_NSBOOL
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"BOOLArrayOf4In:",
{
"arguments": {
2: {
"type": objc._C_PTR + objc._C_NSBOOL,
"type_modifier": objc._C_IN,
"c_array_of_fixed_length": 4,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"BOOLArrayOf4Out:",
{
"arguments": {
2: {
"type": objc._C_PTR + objc._C_NSBOOL,
"type_modifier": objc._C_OUT,
"c_array_of_fixed_length": 4,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"BOOLArrayOf4InOut:",
{
"arguments": {
2: {
"type": objc._C_PTR + objc._C_NSBOOL,
"type_modifier": objc._C_INOUT,
"c_array_of_fixed_length": 4,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"BOOLArrayOfCount:In:",
{
"arguments": {
3: {
"type": objc._C_PTR + objc._C_NSBOOL,
"type_modifier": objc._C_IN,
"c_array_of_lenght_in_arg": 2,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"BOOLArrayOfCount:Out:",
{
"arguments": {
3: {
"type": objc._C_PTR + objc._C_NSBOOL,
"type_modifier": objc._C_OUT,
"c_array_of_lenght_in_arg": 2,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode",
b"BOOLArrayOfCount:InOut:",
{
"arguments": {
3: {
"type": objc._C_PTR + objc._C_NSBOOL,
"type_modifier": objc._C_INOUT,
"c_array_of_lenght_in_arg": 2,
}
}
},
)
import objc
from PyObjCTest.NULL import OCTestNULL
from PyObjCTools.TestSupport import TestCase
objc.registerMetaDataForSelector(
b"OCTestNULL",
b"callOut:",
{"arguments": {
2: {
"type_modifier": b"o",
"null_accepted": True
}
}},
)
objc.registerMetaDataForSelector(
b"OCTestNULL",
b"callList:andInOut2:",
{"arguments": {
3: {
"type_modifier": b"o",
"null_accepted": True
}
}},
)
objc.registerMetaDataForSelector(
b"OCTestNULL",
b"callList:andInOut:",
{"arguments": {
3: {
"type_modifier": b"N",
"null_accepted": True
( b"passInULongLong:", { 2: dict(type_modifier=b'n')}),
( b"passInOutFloat:", { 2: dict(type_modifier=b'N')}),
( b"passOutFloat:", { 2: dict(type_modifier=b'o')}),
( b"passInFloat:", { 2: dict(type_modifier=b'n')}),
( b"passInOutDouble:", { 2: dict(type_modifier=b'N')}),
( b"passOutDouble:", { 2: dict(type_modifier=b'o')}),
( b"passInDouble:", { 2: dict(type_modifier=b'n')}),
( b"passInOutCharp:", { 2: dict(type_modifier=b'N')}),
( b"passOutCharp:", { 2: dict(type_modifier=b'o')}),
( b"passInCharp:", { 2: dict(type_modifier=b'n')}),
( b"passInOutID:", { 2: dict(type_modifier=b'N')}),
( b"passOutID:", { 2: dict(type_modifier=b'o')}),
( b"passInID:", { 2: dict(type_modifier=b'n')}),
]:
objc.registerMetaDataForSelector(b"OC_TestClass1", method,
dict(arguments=argmeta))
from PyObjCTest.testbndl import *
def makeCFloat(value):
"""
C floats and doubles have a different representation, this function returns
the result of converting a python float (== C double) to a C float and back.
"""
if sys.version_info[0] == 2:
struct_fmt = b'f'
else:
struct_fmt = 'f'
return struct.unpack(struct_fmt,struct.pack(struct_fmt, value))[0]
def setupMetaData():
# Note to self: what we think of as the first argument of a method is
# actually the third one, the objc runtime implicitly passed 'self' and
# the selector as well. Therefore we need to start counting at 2 instead
# of 0.
#
# Note2: the code below would normally be done using a metadata file
# instead of hardcoding.
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"make4Tuple:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_IN,
"c_array_of_fixed_length": 4,
"null_accepted": False,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"null4Tuple:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_IN,
"c_array_of_fixed_length": 4,
"null_accepted": True,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeObjectArray:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_IN,
"c_array_delimited_by_null": True,
"null_accepted": False,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeStringArray:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_IN,
"c_array_delimited_by_null": True,
"null_accepted": False,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullStringArray:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_IN,
"c_array_delimited_by_null": True,
"null_accepted": True,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeIntArray:count:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_IN,
"c_array_length_in_arg": 2 + 1,
"null_accepted": False,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeIntArray:countPtr:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_IN,
"c_array_length_in_arg": 2 + 1,
"null_accepted": False,
},
2 + 1: {
"type_modifier": objc._C_IN,
"null_accepted": False
},
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullIntArray:count:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_IN,
"c_array_length_in_arg": 2 + 1,
"null_accepted": True,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"fillArray:uptoCount:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_OUT,
"c_array_length_in_arg": 2 + 1,
"c_array_length_in_result": True,
"null_accepted": False,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"fillArray:count:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_OUT,
"c_array_length_in_arg": 2 + 1,
"null_accepted": False,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullfillArray:count:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_OUT,
"c_array_length_in_arg": 2 + 1,
"null_accepted": True,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"maybeFillArray:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_OUT,
"c_array_of_fixed_length": 4,
"c_array_length_in_result": True,
"null_accepted": False,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"fill4Tuple:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_OUT,
"c_array_of_fixed_length": 4,
"null_accepted": False,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullfill4Tuple:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_OUT,
"c_array_of_fixed_length": 4,
"null_accepted": True,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"fillStringArray:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_OUT,
"c_array_delimited_by_null": True,
"null_accepted": False,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullfillStringArray:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_OUT,
"c_array_delimited_by_null": True,
"null_accepted": True,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"reverseArray:uptoCount:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_INOUT,
"c_array_length_in_arg": 2 + 1,
"c_array_length_in_result": True,
"null_accepted": False,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"reverseArray:count:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_INOUT,
"c_array_length_in_arg": 2 + 1,
"null_accepted": False,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullreverseArray:count:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_INOUT,
"c_array_length_in_arg": 2 + 1,
"null_accepted": True,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"reverseStrings:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_INOUT,
"c_array_delimited_by_null": True,
"null_accepted": False,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullreverseStrings:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_INOUT,
"c_array_delimited_by_null": True,
"null_accepted": True,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"maybeReverseArray:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_INOUT,
"c_array_of_fixed_length": 4,
"c_array_length_in_result": True,
"null_accepted": True,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"reverse4Tuple:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_INOUT,
"c_array_of_fixed_length": 4,
"null_accepted": False,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullreverse4Tuple:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_INOUT,
"c_array_of_fixed_length": 4,
"null_accepted": True,
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeIntArrayOf5On:",
{"retval": {
"c_array_of_fixed_length": 5
}},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeStringArrayOn:",
{"retval": {
"c_array_delimited_by_null": True
}},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeIntArrayOf:on:",
{"retval": {
"c_array_length_in_arg": 2 + 0
}},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullIntArrayOf5On:",
{"retval": {
"c_array_of_fixed_length": 5
}},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullStringArrayOn:",
{"retval": {
"c_array_delimited_by_null": True
}},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullIntArrayOf:on:",
{"retval": {
"c_array_length_in_arg": 2 + 0
}},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"sumX:andY:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_IN,
"null_accepted": False
},
2 + 1: {
"type_modifier": objc._C_IN,
"null_accepted": False
},
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"divBy5:remainder:on:",
{
"arguments": {
2 + 1: {
"type_modifier": objc._C_OUT,
"null_accepted": False
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"swapX:andY:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_INOUT,
"null_accepted": False
},
2 + 1: {
"type_modifier": objc._C_INOUT,
"null_accepted": False
},
}
},
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"input:output:inputAndOutput:on:",
{
"arguments": {
2 + 0: {
"type_modifier": objc._C_IN,
"null_accepted": True
},
2 + 1: {
"type_modifier": objc._C_OUT,
"null_accepted": True
},
2 + 2: {
"type_modifier": objc._C_INOUT,
"null_accepted": True
},
}
},
)
from PyObjCTools.TestSupport import *
import objc
from PyObjCTest.testoutputinitializer import PyObjC_TestOutputInitializer
objc.registerMetaDataForSelector(b"PyObjC_TestOutputInitializer",
b"initWithBooleanOutput:",
dict(arguments={2: dict(type_modifier=b'o')}))
class TestOutputInitializer(TestCase):
def testOutputInitializer(self):
robj, rtrue = PyObjC_TestOutputInitializer.alloc(
).initWithBooleanOutput_(None)
self.assertEquals(rtrue, objc.YES)
self.assertEquals(robj.isInitialized(), objc.YES)
if __name__ == '__main__':
main()
self.controller.iter_dirty_documents(), callback)
saver.save_next_document()
def applicationWillTerminate_(self, notification):
self.controller.app_will_terminate(notification.object())
# This may be removed if the app does not crash when the save panel is
# cancelled after quitting with unsaved documents.
# See also:
# [PyObjC-svn] r2350 - in trunk/pyobjc/pyobjc-framework-Cocoa: . Lib/AppKit PyObjCTest
# http://permalink.gmane.org/gmane.comp.python.pyobjc.cvs/2763
# Re: Crash when closing all documents
# http://permalink.gmane.org/gmane.comp.python.pyobjc.devel/5563
objc.registerMetaDataForSelector(b'NSDocumentController',
b'_documentController:shouldTerminate:context:',
{'arguments': {4: {'type': b'^v'}}})
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Document saving helper
class DocumentSavingDelegate(fn.NSObject):
"""Prompt to save each document by asking if it can be closed
Any Projects will be saved by calling saveIfNecessary() rather than
being asked to close.
"""
registry = {}
def init_callback_(self, docs, callback):
from PyObjCTools.TestSupport import *
import objc
setSignature = objc.setSignatureForSelector
# setSignature("OCTestNULL", "callOut:", "i@:o^i")
# setSignature("OCTestNULL", "callList:andInOut2:", "i@:@^i")
# setSignature("OCTestNULL", "callList:andInOut:", "i@:@N^i")
# setSignature("OCTestNULL", "callList:andIn:", "i@:@n^i")
# setSignature("OCTestNULL", "callList:andOut:", "i@:@o^i")
# setSignature("OCTestNULL", "on:callList:andInOut:", "i@:@@N^i")
# setSignature("OCTestNULL", "on:callList:andIn:", "i@:@@n^i")
# setSignature("OCTestNULL", "on:callList:andOut:", "i@:@@N^i") # 'N' is by design
# setSignature("OCTestNULL", "on:callOut:", "v@:@N^i") # 'N' is by design
objc.registerMetaDataForSelector(
"OCTestNULL", "callOut:", dict(arguments={2: dict(type_modifier="o", null_accepted=True)})
)
objc.registerMetaDataForSelector(
"OCTestNULL", "callList:andInOut2:", dict(arguments={3: dict(type_modifier="o", null_accepted=True)})
)
objc.registerMetaDataForSelector(
"OCTestNULL", "callList:andInOut:", dict(arguments={3: dict(type_modifier="N", null_accepted=True)})
)
objc.registerMetaDataForSelector(
"OCTestNULL", "callList:andIn:", dict(arguments={3: dict(type_modifier="n", null_accepted=True)})
)
objc.registerMetaDataForSelector(
"OCTestNULL", "callList:andOut:", dict(arguments={3: dict(type_modifier="o", null_accepted=True)})
)
objc.registerMetaDataForSelector(
"OCTestNULL", "on:callList:andInOut:", dict(arguments={4: dict(type_modifier="N", null_accepted=True)})
import objc
# the following arcane incantation is in fact necessary to convert python callables
# to Objective-C blocks via PyObjC
objc.registerMetaDataForSelector(b"SPAsyncLoading", b"waitUntilLoaded:timeout:then:", {
"arguments": {
2 + 2: {
"type": "^@", "callable": {
"arguments": {
0: {"type": "^v"},
2: {"type": "@"},
3: {"type": "@"}
}
}
}
}
})
objc.registerMetaDataForSelector(b"SPPlaybackManager", b"playTrack:callback:", {
"arguments": {
2 + 1: {
"type": "^@", "callable": {
"arguments": {
0: {"type": "^v"},
2: {"type": "@"},
}
}
}
}
})
objc.registerMetaDataForSelector(b"SPSession", b"trackForURL:callback:", {
"arguments": {
from PyObjCTools.TestSupport import *
import objc
import warnings
import contextlib
from PyObjCTest.deprecations import *
objc.registerMetaDataForSelector(b"OCTestDeprecations", b"method1", dict())
objc.registerMetaDataForSelector(b"OCTestDeprecations", b"method2",
dict(deprecated=1004))
objc.registerMetaDataForSelector(b"OCTestDeprecations", b"method3",
dict(deprecated=1004))
objc.registerMetaDataForSelector(b"OCTestDeprecations", b"method4",
dict(deprecated=1005))
objc.registerMetaDataForSelector(b"OCTestDeprecations", b"method5",
dict(deprecated=1005))
objc.registerMetaDataForSelector(b"OCTestDeprecations", b"method6",
dict(deprecated=1006))
objc.registerMetaDataForSelector(b"OCTestDeprecations", b"method7",
dict(deprecated=1006))
objc.registerMetaDataForSelector(b"OCTestDeprecations", b"method8",
dict(deprecated=1010))
objc.registerMetaDataForSelector(b"OCTestDeprecations", b"method9",
dict(deprecated=1010))
_FunctionTable = [
("func1", b'i', '', dict()),
("func2", b'i', '', dict(deprecated=1004)),
("func3", b'i', '', dict(deprecated=1004)),
("func4", b'i', '', dict(deprecated=1005)),
("func5", b'i', '', dict(deprecated=1005)),
def setupMetaData():
# Note to self: what we think of as the first argument of a method is
# actually the third one, the objc runtime implicitly passed 'self' and
# the selector as well. Therefore we need to start counting at 2 instead
# of 0.
#
# Note2: the code below would normally be done using a metadata file
# instead of hardcoding.
objc.registerMetaDataForSelector(
"OC_MetaDataTest", "unknownLengthArray", dict(retval=dict(c_array_of_variable_length=True))
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest", "unknownLengthMutable", dict(retval=dict(c_array_of_variable_length=True))
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"makeVariableLengthArray:halfCount:",
dict(arguments={2 + 0: dict(c_array_of_variable_length=True, type_modifier=objc._C_IN)}),
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "varargsMethodWithObjects:", dict(variadic=True))
objc.registerMetaDataForSelector("OC_MetaDataTest", "ignoreMethod", dict(suggestion="please ignore me"))
objc.registerMetaDataForSelector(
"OC_MetaDataTest", "makeArrayWithFormat:", dict(variadic=True, arguments={2 + 0: dict(printf_format=True)})
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest", "makeArrayWithCFormat:", dict(variadic=True, arguments={2 + 0: dict(printf_format=True)})
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest", "makeArrayWithArguments:", dict(variadic=True, c_array_delimited_by_null=True)
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"make4Tuple:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_IN, c_array_of_fixed_length=4, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"null4Tuple:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_IN, c_array_of_fixed_length=4, null_accepted=True)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"makeObjectArray:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_IN, c_array_delimited_by_null=True, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"makeStringArray:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_IN, c_array_delimited_by_null=True, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"nullStringArray:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_IN, c_array_delimited_by_null=True, null_accepted=True)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"makeIntArray:count:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_IN, c_array_length_in_arg=2 + 1, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"makeIntArray:halfCount:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_IN, c_array_of_variable_length=True, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"makeIntArray:countPtr:",
dict(
arguments={
2 + 0: dict(type_modifier=objc._C_IN, c_array_length_in_arg=2 + 1, null_accepted=False),
2 + 1: dict(type_modifier=objc._C_IN, null_accepted=False),
}
),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"nullIntArray:count:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_IN, c_array_length_in_arg=2 + 1, null_accepted=True)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"fillArray:uptoCount:",
dict(
arguments={
2
+ 0: dict(
type_modifier=objc._C_OUT,
c_array_length_in_arg=2 + 1,
c_array_length_in_result=True,
null_accepted=False,
)
}
),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"fillArray:count:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_OUT, c_array_length_in_arg=2 + 1, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"nullfillArray:count:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_OUT, c_array_length_in_arg=2 + 1, null_accepted=True)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"maybeFillArray:",
dict(
arguments={
2
+ 0: dict(
type_modifier=objc._C_OUT,
c_array_of_fixed_length=4,
c_array_length_in_result=True,
null_accepted=False,
)
}
),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"fill4Tuple:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_OUT, c_array_of_fixed_length=4, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"nullfill4Tuple:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_OUT, c_array_of_fixed_length=4, null_accepted=True)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"fillStringArray:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_OUT, c_array_delimited_by_null=True, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"nullfillStringArray:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_OUT, c_array_delimited_by_null=True, null_accepted=True)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"reverseArray:uptoCount:",
dict(
arguments={
2
+ 0: dict(
type_modifier=objc._C_INOUT,
c_array_length_in_arg=2 + 1,
c_array_length_in_result=True,
null_accepted=False,
)
}
),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"reverseArray:count:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_INOUT, c_array_length_in_arg=2 + 1, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"nullreverseArray:count:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_INOUT, c_array_length_in_arg=2 + 1, null_accepted=True)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"reverseStrings:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_INOUT, c_array_delimited_by_null=True, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"nullreverseStrings:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_INOUT, c_array_delimited_by_null=True, null_accepted=True)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"maybeReverseArray:",
dict(
arguments={
2
+ 0: dict(
type_modifier=objc._C_INOUT,
c_array_of_fixed_length=4,
c_array_length_in_result=True,
null_accepted=False,
)
}
),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"reverse4Tuple:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_INOUT, c_array_of_fixed_length=4, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"nullreverse4Tuple:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_INOUT, c_array_of_fixed_length=4, null_accepted=True)}),
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "makeIntArrayOf5", dict(retval=dict(c_array_of_fixed_length=5)))
objc.registerMetaDataForSelector(
"OC_MetaDataTest", "makeStringArray", dict(retval=dict(c_array_delimited_by_null=True))
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest", "makeIntArrayOf:", dict(retval=dict(c_array_length_in_arg=2 + 0))
)
objc.registerMetaDataForSelector("OC_MetaDataTest", "nullIntArrayOf5", dict(retval=dict(c_array_of_fixed_length=5)))
objc.registerMetaDataForSelector(
"OC_MetaDataTest", "nullStringArray", dict(retval=dict(c_array_delimited_by_null=True))
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest", "nullIntArrayOf:", dict(retval=dict(c_array_length_in_arg=2 + 0))
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"sumX:andY:",
dict(
arguments={
2 + 0: dict(type_modifier=objc._C_IN, null_accepted=False),
2 + 1: dict(type_modifier=objc._C_IN, null_accepted=False),
}
),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"divBy5:remainder:",
dict(arguments={2 + 1: dict(type_modifier=objc._C_OUT, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"swapX:andY:",
dict(
arguments={
2 + 0: dict(type_modifier=objc._C_INOUT, null_accepted=False),
2 + 1: dict(type_modifier=objc._C_INOUT, null_accepted=False),
}
),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"input:output:inputAndOutput:",
dict(
arguments={
2 + 0: dict(type_modifier=objc._C_IN, null_accepted=True),
2 + 1: dict(type_modifier=objc._C_OUT, null_accepted=True),
2 + 2: dict(type_modifier=objc._C_INOUT, null_accepted=True),
}
),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"makeDataForBytes:count:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_IN, c_array_length_in_arg=2 + 1, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"makeDataForVoids:count:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_IN, c_array_length_in_arg=2 + 1, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"addOneToBytes:count:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_INOUT, c_array_length_in_arg=2 + 1, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"addOneToVoids:count:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_INOUT, c_array_length_in_arg=2 + 1, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"fillBuffer:count:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_OUT, c_array_length_in_arg=2 + 1, null_accepted=False)}),
)
objc.registerMetaDataForSelector(
"OC_MetaDataTest",
"fillVoids:count:",
dict(arguments={2 + 0: dict(type_modifier=objc._C_OUT, c_array_length_in_arg=2 + 1, null_accepted=False)}),
)
import pkg_resources
import objc
ctypes = None
for method in (
b"alloc",
b"copy",
b"copyWithZone:",
b"mutableCopy",
b"mutableCopyWithZone:",
):
objc.registerMetaDataForSelector(b"NSObject", method,
{"retval": {
"already_retained": True
}})
#
# The rest of this file contains support for bridgesupport
# XML files.
# NOTE: This search path only contains system locations to
# avoid accidently reiying on system-specific functionality.
BRIDGESUPPORT_DIRECTORIES = ["/System/Library/BridgeSupport"]
_SENTINEL = object()
_DEFAULT_SUGGESTION = "don't use this method"
_BOOLEAN_ATTRIBUTES = [
"already_retained",
"already_cfretained",
def setupMetaData():
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode", b"byteValue",
dict(retval=dict(type=objc._C_CHAR_AS_TEXT), ))
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode", b"byteArray",
dict(retval=dict(type=objc._C_PTR + objc._C_CHAR_AS_TEXT,
c_array_of_fixed_length=4), ))
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode", b"byteString",
dict(retval=dict(type=objc._C_PTR + objc._C_CHAR_AS_TEXT,
c_array_delimited_by_null=True), ))
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode", b"byteStringArg:",
dict(
arguments={
2:
dict(type=objc._C_PTR + objc._C_CHAR_AS_TEXT,
c_array_delimited_by_null=True,
type_modifier=objc._C_IN),
}))
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode", b"byteArg:andbyteArg:",
dict(
arguments={
2: dict(type=objc._C_CHAR_AS_TEXT),
3: dict(type=objc._C_CHAR_AS_TEXT),
}))
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode", b"byteArrayOf4In:",
dict(
arguments={
2:
dict(type=objc._C_PTR + objc._C_CHAR_AS_TEXT,
type_modifier=objc._C_IN,
c_array_of_fixed_length=4),
}))
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode", b"byteArrayOf4Out:",
dict(
arguments={
2:
dict(type=objc._C_PTR + objc._C_CHAR_AS_TEXT,
type_modifier=objc._C_OUT,
c_array_of_fixed_length=4),
}))
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode", b"byteArrayOf4InOut:",
dict(
arguments={
2:
dict(type=objc._C_PTR + objc._C_CHAR_AS_TEXT,
type_modifier=objc._C_INOUT,
c_array_of_fixed_length=4),
}))
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode", b"byteArrayOfCount:In:",
dict(
arguments={
3:
dict(type=objc._C_PTR + objc._C_CHAR_AS_TEXT,
type_modifier=objc._C_IN,
c_array_of_lenght_in_arg=2),
}))
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode", b"byteArrayOfCount:Out:",
dict(
arguments={
3:
dict(type=objc._C_PTR + objc._C_CHAR_AS_TEXT,
type_modifier=objc._C_OUT,
c_array_of_lenght_in_arg=2),
}))
objc.registerMetaDataForSelector(
b"OC_TestSpecialTypeCode", b"byteArrayOfCount:InOut:",
dict(
arguments={
3:
dict(type=objc._C_PTR + objc._C_CHAR_AS_TEXT,
type_modifier=objc._C_INOUT,
c_array_of_lenght_in_arg=2),
}))
from PyObjCTools.TestSupport import *
import objc
objc.registerMetaDataForSelector(
b"OC_CallbackTest",
b"selWithSEL:SEL:andObject:",
{"arguments": {2: {"sel_of_type": b"q@:q"}, 3: {"sel_of_type": b"v@:@@^v"}}},
)
objc.registerMetaDataForSelector(
b"OC_CallbackTest",
b"selWithCallback:",
{
"arguments": {
2: {
"callable": {
"retval": {"type": b"q"},
"arguments": {"0": {"type": b"@"}, "1": {"type": b"i"}},
}
}
}
},
)
objc.registerMetaDataForSelector(
b"OC_CallbackTest",
b"selWithCallback2:",
{"arguments": {2: {"callable": {"retval": {"type": b"d"}, "arguments": {}}}}},
)
__all__ = ('initFrameworkWrapper', 'parseBridgeSupport')
import sys
import xml.etree.ElementTree as ET
import ctypes
import objc
import re
import warnings
import functools
import pkg_resources
import os
for method in (b'alloc', b'copy', b'copyWithZone:', b'mutableCopy', b'mutableCopyWithZone:'):
objc.registerMetaDataForSelector(b'NSObject', method,
{
'retval': { 'already_retained': True },
})
#
# The rest of this file contains support for bridgesupport
# XML files.
# NOTE: This search path only contains system locations to
# avoid accidently reiying on system-specific functionality.
BRIDGESUPPORT_DIRECTORIES = [
'/System/Library/BridgeSupport',
]
_SENTINEL=object()
_DEFAULT_SUGGESTION="don't use this method"
import objc
if hasattr(objc, 'ObjCLazyModule'):
# `ObjCLazyModule` function is available for PyObjC version >= 2.4
io_bluetooth = objc.ObjCLazyModule(
"IOBluetooth",
frameworkIdentifier="com.apple.IOBluetooth",
frameworkPath=objc.pathForFramework(
"/System/Library/Frameworks/IOBluetooth.framework"),
metadict=globals())
objc.registerMetaDataForSelector(
b"IOBluetoothSDPServiceRecord", b"getRFCOMMChannelID:",
dict(
arguments={
2:
dict(type=objc._C_PTR + objc._C_CHAR_AS_INT,
type_modifier=objc._C_OUT),
}))
objc.registerMetaDataForSelector(
b"IOBluetoothSDPServiceRecord", b"getL2CAPPSM:",
dict(
arguments={
2:
dict(type=objc._C_PTR + objc._C_CHAR_AS_INT,
type_modifier=objc._C_OUT),
}))
objc.registerMetaDataForSelector(
b"IOBluetoothDevice", b"openRFCOMMChannelSync:withChannelID:delegate:",
import sys
import xml.etree.ElementTree as ET
import ctypes
import objc
import re
import warnings
import functools
import pkg_resources
import os
for method in (b'alloc', b'copy', b'copyWithZone:', b'mutableCopy',
b'mutableCopyWithZone:'):
objc.registerMetaDataForSelector(b'NSObject', method, {
'retval': {
'already_retained': True
},
})
#
# The rest of this file contains support for bridgesupport
# XML files.
# NOTE: This search path only contains system locations to
# avoid accidently reiying on system-specific functionality.
BRIDGESUPPORT_DIRECTORIES = [
'/System/Library/BridgeSupport',
]
_SENTINEL = object()
_DEFAULT_SUGGESTION = "don't use this method"
import objc
setSignature = objc.setSignatureForSelector
#setSignature(b"OCTestNULL", "callOut:", "i@:o^i")
#setSignature(b"OCTestNULL", "callList:andInOut2:", "i@:@^i")
#setSignature(b"OCTestNULL", "callList:andInOut:", "i@:@N^i")
#setSignature(b"OCTestNULL", "callList:andIn:", "i@:@n^i")
#setSignature(b"OCTestNULL", "callList:andOut:", "i@:@o^i")
#setSignature(b"OCTestNULL", "on:callList:andInOut:", "i@:@@N^i")
#setSignature(b"OCTestNULL", "on:callList:andIn:", "i@:@@n^i")
#setSignature(b"OCTestNULL", "on:callList:andOut:", "i@:@@N^i") # 'N' is by design
#setSignature(b"OCTestNULL", "on:callOut:", "v@:@N^i") # 'N' is by design
objc.registerMetaDataForSelector(b"OCTestNULL", b"callOut:", dict(
arguments={
2: dict(type_modifier=b'o', null_accepted=True),
},
))
objc.registerMetaDataForSelector(b"OCTestNULL", b"callList:andInOut2:", dict(
arguments={
3: dict(type_modifier=b'o', null_accepted=True),
},
))
objc.registerMetaDataForSelector(b"OCTestNULL", b"callList:andInOut:", dict(
arguments={
3: dict(type_modifier=b'N', null_accepted=True),
},
))
objc.registerMetaDataForSelector(b"OCTestNULL", b"callList:andIn:", dict(
arguments={
3: dict(type_modifier=b'n', null_accepted=True),
def setupMetaData():
objc.registerMetaDataForSelector(b"OC_TestSpecialTypeCode", b"byteValue",
dict(
retval=dict(type=objc._C_CHAR_AS_TEXT),
))
objc.registerMetaDataForSelector(b"OC_TestSpecialTypeCode", b"byteArray",
dict(
retval=dict(type=objc._C_PTR+objc._C_CHAR_AS_TEXT, c_array_of_fixed_length=4),
))
objc.registerMetaDataForSelector(b"OC_TestSpecialTypeCode", b"byteString",
dict(
retval=dict(type=objc._C_PTR + objc._C_CHAR_AS_TEXT, c_array_delimited_by_null=True),
))
objc.registerMetaDataForSelector(b"OC_TestSpecialTypeCode", b"byteStringArg:",
dict(
arguments={
2: dict(type=objc._C_PTR + objc._C_CHAR_AS_TEXT, c_array_delimited_by_null=True, type_modifier=objc._C_IN),
}
))
objc.registerMetaDataForSelector(b"OC_TestSpecialTypeCode", b"byteArg:andbyteArg:",
dict(
arguments={
2: dict(type=objc._C_CHAR_AS_TEXT),
3: dict(type=objc._C_CHAR_AS_TEXT),
}
))
objc.registerMetaDataForSelector(b"OC_TestSpecialTypeCode", b"byteArrayOf4In:",
dict(
arguments={
2: dict(type=objc._C_PTR+objc._C_CHAR_AS_TEXT, type_modifier=objc._C_IN, c_array_of_fixed_length=4),
}
))
objc.registerMetaDataForSelector(b"OC_TestSpecialTypeCode", b"byteArrayOf4Out:",
dict(
arguments={
2: dict(type=objc._C_PTR+objc._C_CHAR_AS_TEXT, type_modifier=objc._C_OUT, c_array_of_fixed_length=4),
}
))
objc.registerMetaDataForSelector(b"OC_TestSpecialTypeCode", b"byteArrayOf4InOut:",
dict(
arguments={
2: dict(type=objc._C_PTR+objc._C_CHAR_AS_TEXT, type_modifier=objc._C_INOUT, c_array_of_fixed_length=4),
}
))
objc.registerMetaDataForSelector(b"OC_TestSpecialTypeCode", b"byteArrayOfCount:In:",
dict(
arguments={
3: dict(type=objc._C_PTR+objc._C_CHAR_AS_TEXT, type_modifier=objc._C_IN, c_array_of_lenght_in_arg=2),
}
))
objc.registerMetaDataForSelector(b"OC_TestSpecialTypeCode", b"byteArrayOfCount:Out:",
dict(
arguments={
3: dict(type=objc._C_PTR+objc._C_CHAR_AS_TEXT, type_modifier=objc._C_OUT, c_array_of_lenght_in_arg=2),
}
))
objc.registerMetaDataForSelector(b"OC_TestSpecialTypeCode", b"byteArrayOfCount:InOut:",
dict(
arguments={
3: dict(type=objc._C_PTR+objc._C_CHAR_AS_TEXT, type_modifier=objc._C_INOUT, c_array_of_lenght_in_arg=2),
}
))
import copy
import objc
from PyObjCTest.fnd import NSObject
from PyObjCTools.TestSupport import TestCase, main
objc.registerMetaDataForSelector(
b"NSObject",
b"validateValue:forKey:error:",
{
"arguments": {
2: {
"type_modifier": objc._C_INOUT
},
4: {
"type_modifier": objc._C_OUT
},
}
},
)
class OCCopy(NSObject):
def copy(self):
return self.copyWithZone_(None)
def copyWithZone_(self, zone):
v = OCCopy.allocWithZone_(zone).init()
return v
# Cannot import Foundation, we're in the framework loading code.
NSAutoreleasePool = objc.lookUpClass('NSAutoreleasePool')
_gBridgeSupportDirectories = (
'/System/Library/BridgeSupport',
# Don't use the rest of the default search path to avoid relying on data that
# might be on a single system. That would make it harder to create standalone
# apps in some cases.
# '/Library/BridgeSupport',
# os.path.expanduser('~/Library/BridgeSupport'),
)
for method in (b'alloc', b'copy', b'copyWithZone:', b'mutableCopy', b'mutableCopyWithZone:'):
objc.registerMetaDataForSelector(b'NSObject', method,
dict(
retval=dict(already_retained=True),
))
def _parseBridgeSupport(data, globals, frameworkName, *args, **kwds):
try:
try:
objc.parseBridgeSupport(data, globals, frameworkName, *args, **kwds)
except objc.internal_error, e:
import warnings
warnings.warn("Error parsing BridgeSupport data for %s: %s" % (frameworkName, e), RuntimeWarning)
finally:
# Add formal protocols to the protocols submodule, for backward
# compatibility with earlier versions of PyObjC
if 'protocols' in globals:
for p in objc.protocolsForProcess():
setattr(globals['protocols'], p.__name__, p)
# see https://github.com/ronaldoussoren/pyobjc/issues/320#issuecomment-784278944
import objc
objc.registerCFSignature("SecIdentityRef", b"^{__SecIdentity=}",
SecIdentityGetTypeID())
objc.registerMetaDataForSelector(
b'NSURLCredential', b'credentialWithIdentity:certificates:persistence:', {
'arguments': {
2: {
'null_accepted': False,
'type': b'@'
},
3: {
'_template': True,
'type': b'@'
},
4: {
'_template': True,
'type': b'Q'
},
},
'classmethod': True,
'hidden': False,
'retval': {
'_template': True,
'type': b"@"
}
})
try:
from Foundation import NSURLSession, NSURLSessionConfiguration, NSURLCredentialPersistenceForSession
from CFNetwork import (kCFNetworkProxiesHTTPSEnable,
import objc
from Foundation import NSObject,NSLog,NSApplication
import re
objc.registerMetaDataForSelector('CSCaptureBase', 'updateLayersWithFramedataBlock:', {'arguments': {2: {'type': '@?', 'callable': {'arguments': {'0':'^v', '1':'@'}}}}})
CSCaptureBase = objc.lookUpClass('CSCaptureBase')
CSIOSurfaceLayer = objc.lookUpClass('CSIOSurfaceLayer')
CSAbstractCaptureDevice = objc.lookUpClass('CSAbstractCaptureDevice')
LayoutRenderer = objc.lookUpClass('LayoutRenderer')
CSCaptureSourceProtocol = objc.protocolNamed('CSCaptureSourceProtocol')
def getCaptureController():
my_app = NSApplication.sharedApplication()
app_delegate = my_app.delegate()
return app_delegate.captureController()
def getCurrentLayout():
return getCaptureController().activePreviewView().sourceLayout()
def setCITransition(name, inputMap={}, duration=0.25, **kwargs):
new_transition = CIFilter.filterWithName_withInputParameters_(name, inputMap)
my_layout = getCurrentLayout()
my_layout.setTransitionFilter_(new_transition)
my_layout.setTransitionDuration_(duration)
def setupMetaData():
# Note to self: what we think of as the first argument of a method is
# actually the third one, the objc runtime implicitly passed 'self' and
# the selector as well. Therefore we need to start counting at 2 instead
# of 0.
#
# Note2: the code below would normally be done using a metadata file
# instead of hardcoding.
objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"boolClassMethod",
dict(retval=dict(type=objc._C_NSBOOL)))
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"unknownLengthArray",
dict(retval=dict(c_array_of_variable_length=True)),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"unknownLengthMutable",
dict(retval=dict(c_array_of_variable_length=True)),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeVariableLengthArray:halfCount:",
dict(arguments={
2 + 0:
dict(c_array_of_variable_length=True, type_modifier=objc._C_IN)
}),
)
objc.registerMetaDataForSelector(b"OC_MetaDataTest",
b"varargsMethodWithObjects:",
dict(variadic=True))
objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"ignoreMethod",
dict(suggestion="please ignore me"))
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeArrayWithFormat:",
dict(variadic=True, arguments={2 + 0: dict(printf_format=True)}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeArrayWithCFormat:",
dict(variadic=True, arguments={2 + 0: dict(printf_format=True)}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeArrayWithArguments:",
dict(variadic=True, c_array_delimited_by_null=True),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"make4Tuple:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_IN,
c_array_of_fixed_length=4,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"null4Tuple:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_IN,
c_array_of_fixed_length=4,
null_accepted=True,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeObjectArray:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_IN,
c_array_delimited_by_null=True,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeStringArray:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_IN,
c_array_delimited_by_null=True,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullStringArray:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_IN,
c_array_delimited_by_null=True,
null_accepted=True,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeIntArray:count:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_IN,
c_array_length_in_arg=2 + 1,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeIntArray:halfCount:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_IN,
c_array_of_variable_length=True,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeIntArray:countPtr:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_IN,
c_array_length_in_arg=2 + 1,
null_accepted=False,
),
2 + 1:
dict(type_modifier=objc._C_IN, null_accepted=False),
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullIntArray:count:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_IN,
c_array_length_in_arg=2 + 1,
null_accepted=True,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"fillArray:uptoCount:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_OUT,
c_array_length_in_arg=2 + 1,
c_array_length_in_result=True,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"fillArray:count:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_OUT,
c_array_length_in_arg=2 + 1,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullfillArray:count:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_OUT,
c_array_length_in_arg=2 + 1,
null_accepted=True,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"maybeFillArray:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_OUT,
c_array_of_fixed_length=4,
c_array_length_in_result=True,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"fill4Tuple:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_OUT,
c_array_of_fixed_length=4,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullfill4Tuple:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_OUT,
c_array_of_fixed_length=4,
null_accepted=True,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"fillStringArray:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_OUT,
c_array_delimited_by_null=True,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullfillStringArray:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_OUT,
c_array_delimited_by_null=True,
null_accepted=True,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"reverseArray:uptoCount:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_INOUT,
c_array_length_in_arg=2 + 1,
c_array_length_in_result=True,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"reverseArray:count:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_INOUT,
c_array_length_in_arg=2 + 1,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullreverseArray:count:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_INOUT,
c_array_length_in_arg=2 + 1,
null_accepted=True,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"reverseStrings:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_INOUT,
c_array_delimited_by_null=True,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullreverseStrings:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_INOUT,
c_array_delimited_by_null=True,
null_accepted=True,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"maybeReverseArray:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_INOUT,
c_array_of_fixed_length=4,
c_array_length_in_result=True,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"reverse4Tuple:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_INOUT,
c_array_of_fixed_length=4,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullreverse4Tuple:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_INOUT,
c_array_of_fixed_length=4,
null_accepted=True,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeIntArrayOf5",
dict(retval=dict(c_array_of_fixed_length=5)),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeStringArray",
dict(retval=dict(c_array_delimited_by_null=True)),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeIntArrayOf:",
dict(retval=dict(c_array_length_in_arg=2 + 0)),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullIntArrayOf5",
dict(retval=dict(c_array_of_fixed_length=5)),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullStringArray",
dict(retval=dict(c_array_delimited_by_null=True)),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"nullIntArrayOf:",
dict(retval=dict(c_array_length_in_arg=2 + 0)),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"sumX:andY:",
dict(
arguments={
2 + 0: dict(type_modifier=objc._C_IN, null_accepted=False),
2 + 1: dict(type_modifier=objc._C_IN, null_accepted=False),
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"divBy5:remainder:",
dict(arguments={
2 + 1: dict(type_modifier=objc._C_OUT, null_accepted=False)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"swapX:andY:",
dict(
arguments={
2 + 0: dict(type_modifier=objc._C_INOUT, null_accepted=False),
2 + 1: dict(type_modifier=objc._C_INOUT, null_accepted=False),
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"input:output:inputAndOutput:",
dict(
arguments={
2 + 0: dict(type_modifier=objc._C_IN, null_accepted=True),
2 + 1: dict(type_modifier=objc._C_OUT, null_accepted=True),
2 + 2: dict(type_modifier=objc._C_INOUT, null_accepted=True),
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeDataForBytes:count:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_IN,
c_array_length_in_arg=2 + 1,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"makeDataForVoids:count:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_IN,
c_array_length_in_arg=2 + 1,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"addOneToBytes:count:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_INOUT,
c_array_length_in_arg=2 + 1,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"addOneToVoids:count:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_INOUT,
c_array_length_in_arg=2 + 1,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"fillBuffer:count:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_OUT,
c_array_length_in_arg=2 + 1,
null_accepted=False,
)
}),
)
objc.registerMetaDataForSelector(
b"OC_MetaDataTest",
b"fillVoids:count:",
dict(
arguments={
2 + 0:
dict(
type_modifier=objc._C_OUT,
c_array_length_in_arg=2 + 1,
null_accepted=False,
)
}),
)
def __init__(self, uid, title, url, width, height, resizable, fullscreen, min_size,
confirm_quit, background_color, debug, js_api, text_select, frameless, webview_ready):
BrowserView.instances[uid] = self
self.uid = uid
self.js_bridge = None
self._file_name = None
self._file_name_semaphore = Semaphore(0)
self._current_url_semaphore = Semaphore(0)
self.webview_ready = webview_ready
self.loaded = Event()
self.confirm_quit = confirm_quit
self.title = title
self.debug = debug
self.text_select = text_select
self.is_fullscreen = False
rect = AppKit.NSMakeRect(0.0, 0.0, width, height)
window_mask = AppKit.NSTitledWindowMask | AppKit.NSClosableWindowMask | AppKit.NSMiniaturizableWindowMask
if resizable:
window_mask = window_mask | AppKit.NSResizableWindowMask
# The allocated resources are retained because we would explicitly delete
# this instance when its window is closed
self.window = AppKit.NSWindow.alloc().\
initWithContentRect_styleMask_backing_defer_(rect, window_mask, AppKit.NSBackingStoreBuffered, False).retain()
self.window.setTitle_(title)
self.window.setBackgroundColor_(BrowserView.nscolor_from_hex(background_color))
self.window.setMinSize_(AppKit.NSSize(min_size[0], min_size[1]))
self.window.setAnimationBehavior_(AppKit.NSWindowAnimationBehaviorDocumentWindow)
BrowserView.cascade_loc = self.window.cascadeTopLeftFromPoint_(BrowserView.cascade_loc)
self.webkit = BrowserView.WebKitHost.alloc().initWithFrame_(rect).retain()
self._browserDelegate = BrowserView.BrowserDelegate.alloc().init().retain()
self._windowDelegate = BrowserView.WindowDelegate.alloc().init().retain()
self._appDelegate = BrowserView.AppDelegate.alloc().init().retain()
self.webkit.setUIDelegate_(self._browserDelegate)
self.webkit.setNavigationDelegate_(self._browserDelegate)
self.window.setDelegate_(self._windowDelegate)
BrowserView.app.setDelegate_(self._appDelegate)
self.frameless = frameless
if frameless:
# Make content full size and titlebar transparent
window_mask = window_mask | NSFullSizeContentViewWindowMask | AppKit.NSTexturedBackgroundWindowMask
self.window.setStyleMask_(window_mask)
self.window.setTitlebarAppearsTransparent_(True)
self.window.setTitleVisibility_(NSWindowTitleHidden)
# Hide standard buttons
self.window.standardWindowButton_(AppKit.NSWindowCloseButton).setHidden_(True)
self.window.standardWindowButton_(AppKit.NSWindowMiniaturizeButton).setHidden_(True)
self.window.standardWindowButton_(AppKit.NSWindowZoomButton).setHidden_(True)
else:
# Set the titlebar color (so that it does not change with the window color)
self.window.contentView().superview().subviews().lastObject().setBackgroundColor_(AppKit.NSColor.windowBackgroundColor())
if url:
self.url = url
self.load_url(url)
else:
self.loaded.set()
try:
self.webkit.evaluateJavaScript_completionHandler_('', lambda a, b: None)
except TypeError:
registerMetaDataForSelector(b'WKWebView', b'evaluateJavaScript:completionHandler:', _eval_js_metadata)
config = self.webkit.configuration()
config.userContentController().addScriptMessageHandler_name_(self._browserDelegate, 'browserDelegate')
try:
config.preferences().setValue_forKey_(Foundation.NO, 'backspaceKeyNavigationEnabled')
except:
pass
if self.debug:
config.preferences().setValue_forKey_(Foundation.YES, 'developerExtrasEnabled')
if js_api:
self.js_bridge = BrowserView.JSBridge.alloc().initWithObject_(js_api)
config.userContentController().addScriptMessageHandler_name_(self.js_bridge, 'jsBridge')
if url:
self.load_url(url)
else:
self.load_html(default_html, '')
if fullscreen:
self.toggle_fullscreen()
