pyobjc-core 11.0__tar.gz → 12.0__tar.gz

pyobjc_core-12.0/Examples/Scripts/HelloWorld.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env pythonw
+"""
+The original PyObjC interface example by Steve Majewski.
+
+A quick guide to runtime name mangling:
+
+   ObjC             becomes              Python
+   [obj method ]                         obj.method()
+   [obj method:arg ]                     obj.method_(arg)
+   [obj method:arg1 withOtherArgs:arg2]  obj.method_withOtherArgs_( arg1, arg2 )
+
+
+NOTE:  This is no longer the recommended way to build applications
+using the pyobjc bridge under with OS X.  In particular, applications
+work much better if they are constructed in a proper app wrapper.
+
+This app does demonstrate that it is possible to build full
+featured Cocoa apps without InterfaceBuilder.
+"""
+
+from Cocoa import NSObject, NSApplication, NSApp, NSWindow, NSButton, NSSound
+from PyObjCTools import AppHelper
+
+
+class AppDelegate(NSObject):
+    def applicationDidFinishLaunching_(self, aNotification):
+        print("Hello, World!")
+
+    def sayHello_(self, sender):
+        print("Hello again, World!")
+
+
+def main():
+    app = NSApplication.sharedApplication()
+
+    # we must keep a reference to the delegate object ourselves,
+    # NSApp.setDelegate_() doesn't retain it. A local variable is
+    # enough here.
+    delegate = AppDelegate.alloc().init()
+    NSApp().setDelegate_(delegate)
+
+    win = NSWindow.alloc()
+    frame = ((200.0, 300.0), (250.0, 100.0))
+    win.initWithContentRect_styleMask_backing_defer_(frame, 15, 2, 0)
+    win.setTitle_("HelloWorld")
+    win.setLevel_(3)  # floating window
+
+    hello = NSButton.alloc().initWithFrame_(((10.0, 10.0), (80.0, 80.0)))
+    win.contentView().addSubview_(hello)
+    hello.setBezelStyle_(4)
+    hello.setTitle_("Hello!")
+    hello.setTarget_(app.delegate())
+    hello.setAction_("sayHello:")
+
+    beep = NSSound.alloc()
+    beep.initWithContentsOfFile_byReference_("/System/Library/Sounds/Tink.Aiff", 1)
+    hello.setSound_(beep)
+
+    bye = NSButton.alloc().initWithFrame_(((100.0, 10.0), (80.0, 80.0)))
+    win.contentView().addSubview_(bye)
+    bye.setBezelStyle_(4)
+    bye.setTarget_(app)
+    bye.setAction_("stop:")
+    bye.setEnabled_(1)
+    bye.setTitle_("Goodbye!")
+
+    adios = NSSound.alloc()
+    adios.initWithContentsOfFile_byReference_("/System/Library/Sounds/Basso.aiff", 1)
+    bye.setSound_(adios)
+
+    win.display()
+    win.orderFrontRegardless()  # but this one does
+
+    AppHelper.runEventLoop()
+
+
+if __name__ == "__main__":
+    main()

pyobjc_core-12.0/Examples/Scripts/autoreadme.py

@@ -0,0 +1,55 @@
+#!/usr/bin/python
+"""
+This script is a daemon that will open the ReadMe file in the root of any
+(removable) volume that is inserted while this script is running.
+
+The script is part of an article at MacDevCenter:
+    http://www.macdevcenter.com/pub/a/mac/2003/01/31/pyobjc_one.html
+
+Usage:
+    python autoreadme.py
+"""
+import os
+import re
+
+from Cocoa import NSObject, NSLog, NSWorkspace, NSWorkspaceDidMountNotification
+from PyObjCTools import AppHelper
+
+readTheseFiles = re.compile(r"(.*read\s*me.*|.*release.*note.*|^about.*)", re.I)
+
+
+class NotificationHandler(NSObject):
+    """
+    Class that handles the mount notifications
+    """
+
+    def handleMountNotification_(self, aNotification):
+        # Find the path to the just inserted volume
+        path = aNotification.userInfo()["NSDevicePath"]
+
+        for fname in os.listdir(path):
+            if readTheseFiles.match(fname):
+                # Found a readme file, try to open it using the Workspace API
+
+                fullPath = os.path.join(path, fname)
+                success, app, _ = workspace.getInfoForFile_application_type_(fullPath)
+                if not success:
+                    NSLog("Failed to find application to open file %s", fullPath)
+                    return
+                workspace.openFile_withApplication_(fullPath, app)
+
+
+# Create an instance of our notification handler, and ask the workspace
+# notification center to tell us when a new volume is mounted.
+workspace = NSWorkspace.sharedWorkspace()
+notificationCenter = workspace.notificationCenter()
+notificationHandler = NotificationHandler.new()
+notificationCenter.addObserver_selector_name_object_(
+    notificationHandler,
+    "handleMountNotification:",
+    NSWorkspaceDidMountNotification,
+    None,
+)
+
+NSLog("Listening for mount notifications....")
+AppHelper.runConsoleEventLoop()

pyobjc_core-12.0/Examples/Scripts/signal-demo.py

@@ -0,0 +1,35 @@
+#!/usr/bin/python
+"""
+This script demonstrates using the PyObjCTools.Signals
+module to show a stacktrace when there's a fatal signal
+when running a script.
+"""
+
+import os
+import signal
+
+from PyObjCTools import Signals
+
+Signals.dumpStackOnFatalSignal()
+
+
+# all this does is set up an interesting stack to
+# to show that a backtrace really is being
+# generated.  Try commenting out the
+# Signals.dumpStackOnFatalSignal() line above and run
+# the script again.
+
+
+def badness():
+    os.kill(os.getpid(), signal.SIGQUIT)
+
+
+class Foo:
+    def baz(self):
+        badness()
+
+    def bar(self):
+        self.baz()
+
+
+Foo().bar()

pyobjc_core-12.0/Examples/Scripts/stdinreader.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+This script demonstrates how to use a Cocoa
+event loop to asynchronously read from an
+existing file descriptor.
+"""
+
+from Foundation import (
+    NSObject,
+    NSFileHandle,
+    NSNotificationCenter,
+    NSFileHandleReadCompletionNotification,
+    NSFileHandleNotificationDataItem,
+    NSFileHandleError,
+)
+from PyObjCTools import AppHelper
+
+
+class FileObserver(NSObject):
+    def initWithFileDescriptor_readCallback_errorCallback_(
+        self, fileDescriptor, readCallback, errorCallback
+    ):
+        self = self.init()
+        self.readCallback = readCallback
+        self.errorCallback = errorCallback
+        self.fileHandle = NSFileHandle.alloc().initWithFileDescriptor_(fileDescriptor)
+        self.nc = NSNotificationCenter.defaultCenter()
+        self.nc.addObserver_selector_name_object_(
+            self,
+            "fileHandleReadCompleted:",
+            NSFileHandleReadCompletionNotification,
+            self.fileHandle,
+        )
+        self.fileHandle.readInBackgroundAndNotify()
+        return self
+
+    def fileHandleReadCompleted_(self, aNotification):
+        ui = aNotification.userInfo()
+        newData = ui.objectForKey_(NSFileHandleNotificationDataItem)
+        if newData is None:
+            if self.errorCallback is not None:
+                self.errorCallback(self, ui.objectForKey_(NSFileHandleError))
+            self.close()
+        else:
+            self.fileHandle.readInBackgroundAndNotify()
+            if self.readCallback is not None:
+                self.readCallback(self, str(newData))
+
+    def close(self):
+        self.nc.removeObserver_(self)
+        if self.fileHandle is not None:
+            self.fileHandle.closeFile()
+            self.fileHandle = None
+        # break cycles in case these functions are closed over
+        # an instance of us
+        self.readCallback = None
+        self.errorCallback = None
+
+    def __del__(self):
+        # Without this, if a notification fires after we are GC'ed
+        # then the app will crash because NSNotificationCenter
+        # doesn't retain observers.  In this example, it doesn't
+        # matter, but it's worth pointing out.
+        self.close()
+
+
+def prompt():
+    sys.stdout.write("write something: ")
+    sys.stdout.flush()
+
+
+def gotLine(observer, line):
+    if line:
+        print("you wrote:", line.rstrip())
+        prompt()
+    else:
+        print("")
+        AppHelper.stopEventLoop()
+
+
+def gotError(observer, err):
+    print("error:", err)
+    AppHelper.stopEventLoop()
+
+
+if __name__ == "__main__":
+    import sys
+
+    observer = FileObserver.alloc().initWithFileDescriptor_readCallback_errorCallback_(
+        sys.stdin.fileno(), gotLine, gotError
+    )
+    prompt()
+    AppHelper.runConsoleEventLoop(installInterrupt=True)