Ejemplo n.º 1
0
# XXX It would be useful to add most of EasyDialogs here, and call
# this module EasyCocoaDialogs.py or something.


__all__ = ["AskString"]


from PyObjCTools import NibClassBuilder, AppHelper
from AppKit import NSApp


NibClassBuilder.extractClasses("AskString")


# class defined in AskString.nib
class AskStringWindowController(NibClassBuilder.AutoBaseClass):
    # the actual base class is NSWindowController
    # The following outlets are added to the class:
    # questionLabel
    # textField

    def __new__(cls, question, resultCallback, default="", parentWindow=None):
        self = cls.alloc().initWithWindowNibName_("AskString")
        self.question = question
        self.resultCallback = resultCallback
        self.default = default
        self.parentWindow = parentWindow
        if self.parentWindow is None:
            self.window().setFrameUsingName_("AskStringPanel")
            self.setWindowFrameAutosaveName_("AskStringPanel")
            self.showWindow_(self)
Ejemplo n.º 2
0
from Foundation import *
from AppKit import *
from PyObjCTools import NibClassBuilder
from objc import ivar

NibClassBuilder.extractClasses("CurrencyConvBindingDocument")


class Converter(NibClassBuilder.AutoBaseClass):

        # The input fields have formatters that convert the text
        # value to a number. If we wouldn't do that, exchangeRate
        # and dollarsToConvert would be set to strings.
        #
        # The alternative is using objc instance variables of the
        # right type (in this case doubles) and let the Cocoa 
        # implementation worry about the conversion:
	#   exchangeRate = ivar('exchangeRate', 'd')
	#   dollarsToConvert = ivar('dollarsToConvert', 'd')
	
	def init(self):
		self = super(Converter, self).init()
		self.exchangeRate = 3
		self.dollarsToConvert = 4
		return self
		
	def amountInOtherCurrency(self):
		return self.dollarsToConvert * self.exchangeRate

Converter.setKeys_triggerChangeNotificationsForDependentKey_(
    [u"dollarsToConvert", u"exchangeRate"],
Ejemplo n.º 3
0
import keyword
import time
from code import InteractiveConsole, softspace
from StringIO import StringIO
import objc
from objc import YES, NO, selector
from Foundation import *
from AppKit import *
from PyObjCTools import NibClassBuilder, AppHelper
import os

myBundle = NSBundle.bundleWithPath_(
    os.path.dirname(os.path.dirname(
        os.environ['RESOURCEPATH'])).decode('utf8'))

NibClassBuilder.extractClasses("PyInterpreter.nib", bundle=myBundle)

try:
    sys.ps1
except AttributeError:
    sys.ps1 = ">>> "
try:
    sys.ps2
except AttributeError:
    sys.ps2 = "... "


class PseudoUTF8Output(object):
    softspace = 0

    def __init__(self, writemethod):
Ejemplo n.º 4
0
        FigureCanvasAgg.draw(self)

    def blit(self, bbox):
        pass

    def start_event_loop(self,timeout):
        FigureCanvasBase.start_event_loop_default(self,timeout)
    start_event_loop.__doc__=FigureCanvasBase.start_event_loop_default.__doc__

    def stop_event_loop(self):
        FigureCanvasBase.stop_event_loop_default(self)
    stop_event_loop.__doc__=FigureCanvasBase.stop_event_loop_default.__doc__



NibClassBuilder.extractClasses('Matplotlib.nib', mplBundle)

class MatplotlibController(NibClassBuilder.AutoBaseClass):
    # available outlets:
    #  NSWindow plotWindow
    #  PlotView plotView

    def awakeFromNib(self):
        # Get a reference to the active canvas
        NSApp().setDelegate_(self)
        self.app = NSApp()
        self.canvas = Gcf.get_active().canvas
        self.plotView.canvas = self.canvas
        self.canvas.plotView = self.plotView

        self.plotWindow.setAcceptsMouseMovedEvents_(True)
#
#  LogNotifier.py
#  LogNotifier
#

from PyObjCTools import NibClassBuilder, AppHelper
from Foundation import NSBundle, NSUserDefaults

info = NSBundle.mainBundle().infoDictionary()[u'PyObjCXcode']

for nibFile in info[u'NIBFiles']:
    NibClassBuilder.extractClasses(nibFile)

for pythonModule in info[u'Modules']:
    __import__(pythonModule)

if __name__ == '__main__':
    defaultValues = {
        u'MonitoredFiles':[
            { u'file'   : u'/var/log/system.log',
              u'sticky' : True}
        ]
    }
    NSUserDefaults.standardUserDefaults().registerDefaults_(defaultValues)
        
    AppHelper.runEventLoop()
Ejemplo n.º 6
0
sources.

Introduction

The module is used to avoid repeating class inheritance and outlet definitions
in both python sources and Interface Builder NIB files.

The module reads this information from NIB files and provides a magic meta
class that inserts the right superclass and outlet definitions.

Do not use this module for new developement, it will likely disappear in a
future version of PyObjC because it can no longer work with modern versions of
Xcode, and in particular not with XIB files and compiled NIB files.
'''

NibClassBuilder.extractClasses("MainMenu")
NibClassBuilder.extractClasses("TLayerDemo")

from PyObjCTools import AppHelper

import AppDelegate
import Circle
import Extras
import ShadowOffsetView
import TLayerDemo
import TLayerView

import objc
objc.setVerbose(True)

AppHelper.runEventLoop()
#
#  FilteringControllerDocument.py
#  FilteringController
#
#  Converted by u.fiedler on 05.02.05.
#
#  The original version was written in Objective-C by Malcolm Crawford
#  at http://homepage.mac.com/mmalc/CocoaExamples/controllers.html

from PyObjCTools import NibClassBuilder, AppHelper
import objc
from Foundation import NSKeyedArchiver, NSKeyedUnarchiver

NibClassBuilder.extractClasses("FilteringControllerDocument")


class FilteringControllerDocument(NibClassBuilder.AutoBaseClass):
    # the actual base class is NSDocument
    # The following outlets are added to the class:
    # peopleController

    def init(self):
        self = super(FilteringControllerDocument, self).init()
        if self is None: return None
        self._k_people = []
        return self

    def windowNibName(self):
        return u"FilteringControllerDocument"

    def windowControllerDidLoadNib_(self, controller):
Ejemplo n.º 8
0
from tagger.constants import *
from tagger.exceptions import *

import os, glob, types
import encodings

try:
    import cjkcodecs.aliases
    from cjkcodecs import *
except:
    pass

from encodings import aliases


NibClassBuilder.extractClasses("MusicTagger")

"""
TODO: have to deal properly with mixed encodings, like TRACK being one
      encoding and title's being another.

How to build:

python buildapp.py --standalone --package encodings build
"""


def uniq(list):
    last = None
    list.sort()
    result = []
#  GraphicsBindingsDocument.py
#  GraphicsBindings
#
#  Converted by u.fiedler on feb 2005
#  with great help from Bob Ippolito - Thank you Bob!
#
#  The original version was written in Objective-C by Malcolm Crawford
#  http://homepage.mac.com/mmalc/CocoaExamples/controllers.html

import objc
from PyObjCTools import NibClassBuilder, AppHelper

from RadiansToDegreesTransformer import RadiansToDegreesTransformer
from Foundation import *

NibClassBuilder.extractClasses("GraphicsBindingsDocument")


class GraphicsBindingsDocument(NibClassBuilder.AutoBaseClass):
    # the actual base class is NSDocument
    # The following outlets are added to the class:
    # graphicsView, shadowInspector, graphicsController

    graphics = objc.ivar('graphics')

    def init(self):
        self = super(GraphicsBindingsDocument, self).init()
        if self is None:
            return None
        self.graphics = []  # NSMutableArray.array()
        self.bindings = []
Ejemplo n.º 10
0
This creates a directory "dist" containing OpenGLDemo.app. (The
-A option causes the files to be symlinked to the .app bundle instead
of copied. This means you don't have to rebuild the app if you edit the
sources or nibs.)

This example requires PyOpenGL
"""

from PyObjCTools import NibClassBuilder, AppHelper
from objc import getClassList, objc_object
from AppKit import *
from Foundation import *
from OpenGL.GL import *


NibClassBuilder.extractClasses("OpenGLDemo")


ClearColors = redIndex, greenIndex, blueIndex, alphaIndex = range(4)

class OpenGLDemoView(NibClassBuilder.AutoBaseClass):
    def awakeFromNib(self):
        self.color_index = alphaIndex

    def initWithFrame_(self, frame):
        attribs = [
            NSOpenGLPFANoRecovery,
            NSOpenGLPFAWindow,
            NSOpenGLPFAAccelerated,
            NSOpenGLPFADoubleBuffer,
            NSOpenGLPFAColorSize, 24,
Ejemplo n.º 11
0
sources.

Introduction

The module is used to avoid repeating class inheritance and outlet definitions
in both python sources and Interface Builder NIB files.

The module reads this information from NIB files and provides a magic meta
class that inserts the right superclass and outlet definitions.

Do not use this module for new developement, it will likely disappear in a
future version of PyObjC because it can no longer work with modern versions of
Xcode, and in particular not with XIB files and compiled NIB files.
'''

NibClassBuilder.extractClasses("MainMenu")
NibClassBuilder.extractClasses("TLayerDemo")

from PyObjCTools import AppHelper

import AppDelegate
import Circle
import Extras
import ShadowOffsetView
import TLayerDemo
import TLayerView

import objc; objc.setVerbose(True)

AppHelper.runEventLoop()
Ejemplo n.º 12
0
    import AddressBook
except ImportError:
    pass

try:
    import PreferencePanes
except ImportError:
    pass

try:
    import InterfaceBuilder
except ImportError:
    pass


NibClassBuilder.extractClasses("ClassBrowser")


def _sortClasses(classList):
    classes = [(cls.__name__, cls) for cls in classList]
    classes.sort()
    return [cls for name, cls in classes]


# class defined in ClassBrowser.nib
class ClassBrowserDelegate(NibClassBuilder.AutoBaseClass):
    # the actual base class is NSObject
    # The following outlets are added to the class:
    # browser
    # pathLabel
    # table
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from Foundation import *
from AppKit import *
from PyObjCTools import NibClassBuilder
from BTAppController import NoTorrentSelected
from BitTorrent.ClientIdentifier import identify_client as client
from utils import *

NibClassBuilder.extractClasses("DetailView")

f = open('/tmp/unknown_clients', 'wb')


def spewval(d, v):
    if v == 'ip':
        return d['ip']
    elif v == 'cl':
        return "%s %s" % client(d['id'], f)
    elif v == 'lr':
        return d['initiation'][0]
    elif v == 'ui':
        if d['completed'] == 1.0:
            return '-'
        elif d['upload'][2]:
Ejemplo n.º 14
0
from PyObjCTools import NibClassBuilder

from loader import MHTLoader # XXX: integrate?

NibClassBuilder.extractClasses("MHTDocument")

class MHTDocument (NibClassBuilder.AutoBaseClass):

    path = None
    statusText = None

    def navigateHistory_(self, sender):
        if sender.selectedSegment() == 0:
            self.webview.goBack_(sender)
        else:
            self.webview.goForward_(sender)

    def windowNibName(self):
        return u"MHTDocument"

    def readFromFile_ofType_(self, path, tp):
        if self.webview is None:
            self.path = path
        else:
            self.readMHT_(path)

        return True

    def writeToFile_ofType_(self, path, tp):
        # TODO: 'save-as' functionality
        return False
Ejemplo n.º 15
0
from Foundation import *
from AppKit import *

from PyObjCTools import NibClassBuilder

from appscript import *

# We tell NibClassBuilder to examine and remember all
# classes from the CDInfoDocument NIB file. This way,
# we can subclass our ITunesCommunication from AutoBaseClass
# later on, and its actual baseclass will be ITunesCommunication
# from the NIB file.
# Since the NIB files are in the application, NOT the plugin, we
# need to specify this explicitly.  Typicaly, NIB files would be in the
# plugins.
NibClassBuilder.extractClasses("CDInfoDocument", bundle=NSBundle.mainBundle())

class ITunesCommunication(NibClassBuilder.AutoBaseClass):
    def init(self):
        self = super(ITunesCommunication, self).init()
        if self is None:
            return None
        return self

    def getITunesInfo(self):
        try:
            track = app('iTunes.app').current_track.get()
        except Exception:
            NSRunAlertPanel(
                u'iTunes Communication Error',
                u'iTunes failed to return the current track',
Ejemplo n.º 16
0
See also the iClass demo.
"""

from PyObjCTools import NibClassBuilder, AppHelper
import objc
from objc import getClassList, objc_object
from Foundation import *
from AppKit import *
import os

myBundle = NSBundle.bundleWithPath_(
    os.path.dirname(os.path.dirname(
        os.environ['RESOURCEPATH'])).decode('utf8'))

NibClassBuilder.extractClasses("ClassBrowser.nib", bundle=myBundle)


def _sortClasses(classList):
    classes = [(cls.__name__, cls) for cls in classList]
    classes.sort()
    return [cls for name, cls in classes]


# class defined in ClassBrowser.nib
class ClassBrowserDelegate(NibClassBuilder.AutoBaseClass):
    # the actual base class is NSObject
    # The following outlets are added to the class:
    # browser
    # pathLabel
    # table
Ejemplo n.º 17
0
from PyObjCTools import NibClassBuilder, AppHelper

import Foundation, AppKit, WebKit
from Foundation import *
from AppKit import *
import objc; objc.setVerbose(1)

import PyDocURLProtocol
import PyDocEvents

PyDocURLProtocol.setup()

NibClassBuilder.extractClasses('PyDocBrowser')

# the web browser doesn't have or need any code really

if __name__ == '__main__':
    AppHelper.runEventLoop()
Ejemplo n.º 18
0
#
#  redfoot.py
#  redfoot
#

from PyObjCTools import NibClassBuilder, AppHelper
from Foundation import NSBundle


info = NSBundle.mainBundle().infoDictionary()[u'PyObjCXcode']

for nibFile in info[u'NIBFiles']:
    print NibClassBuilder.extractClasses(nibFile)

for pythonModule in info[u'Modules']:
    __import__(pythonModule)


from Foundation import *
from AppKit import *

import redfootAppDelegate # so that it gets included in the .app

if __name__ == '__main__':
    AppHelper.runEventLoop()
Ejemplo n.º 19
0
STALLEDCOLOR_DEFAULT = NSArchiver.archivedDataWithRootObject_(
    NSColor.colorWithCalibratedHue_saturation_brightness_alpha_(
        .166, .3, 1.0, 1.0))
ERRORCOLOR_DEFAULT = NSArchiver.archivedDataWithRootObject_(
    NSColor.colorWithCalibratedHue_saturation_brightness_alpha_(
        1.0, .10, 1.0, 1.0))

VERSIONCHECK_DEFAULT = 1
from Foundation import *
from AppKit import *
from PyObjCTools import NibClassBuilder

import objc
import os

NibClassBuilder.extractClasses("Preferences")
appDefaults = {
    IP: IP_DEFAULT,
    MINPORT: MINPORT_DEFAULT,
    MAXULS: MAXULS_DEFAULT,
    MINULS: MINULS_DEFAULT,
    MAXULRATE: MAXULRATE_DEFAULT,
    DIRASK: DIRASK_DEFAULT,
    DLDIR: DLDIR_DEFAULT,
    MAXINITIATE: MAXINITIATE_DEFAULT,
    MAXACCEPT: MAXACCEPT_DEFAULT,
    DOQUEUE: DOQUEUE_DEFAULT,
    QUEUESTOP: QUEUESTOP_DEFAULT,
    STOPRATIO: STOPRATIO_DEFAULT,
    STOPTIME: STOPTIME_DEFAULT,
    QUEUESTART: QUEUESTART_DEFAULT,
Ejemplo n.º 20
0
#  Created by Drue Loewenstern on Sun Feb 15 2004.
#  Copyright (c) 2004 __MyCompanyName__. All rights reserved.
#

from threading import Event
from traceback import print_exc
import sys
sys.argv = ["BitTorrent.app"]
import os

from Foundation import *
from AppKit import *
from PyObjCTools import NibClassBuilder
from objc import selector
import objc
NibClassBuilder.extractClasses("Metainfo")

#from btmakemetafile import makeinfo
#from btcompletedir import completedir
from BitTorrent.makemetafile import make_meta_file, make_meta_file_dht, calcsize
from BitTorrent.bencode import bencode, bdecode

ANNOUNCEKEY = "AnnounceString"
GWINKEY= "GenerateFrame"
COMPLETEDIRKEY = "CompleteDir"
SWITCHKEY = "TrackerSwitch"

TRACKER = 0
TLAUTO = 1
TLNODES = 2
Ejemplo n.º 21
0
#
#  InfoController.py
#  PyImtool
#
#  Created by Francesco Pierfederici on Thu Jun 03 2004.
#  Copyright (c) 2004 Francesco Pierfederici. All rights reserved.
#
# globals and the like
from utilities import *


from PyObjCTools import NibClassBuilder

NibClassBuilder.extractClasses("InfoPanel")


# load the MagnifiedView class
path = os.path.abspath(os.path.join(PATH, "../Resources/MagnifiedView.bundle"))
import objc

objc.loadBundle("MagnifiedView", globals(), bundle_path=path)
MagnifiedView = objc.lookUpClass("MagnifiedView")
del objc


# class defined in InfoPanel.nib
class InfoController(NibClassBuilder.AutoBaseClass):
    # the actual base class is WSWindowController
    # The following outlets are added to the class:
    # window
    # [x|y|int|name|title|ext]Filed
Ejemplo n.º 22
0
import time
import sys
from Foundation import NSObject
from AppKit import NSApplicationMain
from PyObjCTools import NibClassBuilder
from AppKit import NSRunAlertPanel
from objc import *

NibClassBuilder.extractClasses('MainMenu.nib')

class Converter (NibClassBuilder.AutoBaseClass):
    def convertAmount(self, amt, rate):
        return amt*rate


class ConverterController (NibClassBuilder.AutoBaseClass):

    # First define the IB Outlets, the 'ivar' calls below define new
    # instance variables in the objective-C class (e.g. visible
    # for introspection in objective-C)

    def awakeFromNib(self):
        # Provide some defaults for the user...
        self.dollarField.setFloatValue_(2.0)
        self.rateField.setFloatValue_(3.0)

    def convert_(self, sender):
        rate = self.rateField.floatValue()
        amt = self.dollarField.floatValue()

        total = self.converter.convertAmount(rate, amt)
Ejemplo n.º 23
0
            work = self.queue.get()
            if work is None or not self.working:
                break
            func, args, kwargs = work
            pool = NSAutoreleasePool.alloc().init()
            try:
                func(*args, **kwargs)
            finally:
                # delete all local references; if they are the last refs they
                # may invoke autoreleases, which should then end up in our pool
                del func, args, kwargs, work
                del pool


from PyObjCTools import NibClassBuilder
NibClassBuilder.extractClasses( "WSTConnection" )

class WSTConnectionWindowController(NibClassBuilder.AutoBaseClass):
    """
    As per the definition in the NIB file,
    WSTConnectionWindowController is a subclass of
    NSWindowController.  It acts as a NSTableView data source and
    implements a standard toolbar.
    """
    __slots__ = ('_toolbarItems',
        '_toolbarDefaultItemIdentifiers',
        '_toolbarAllowedItemIdentifiers',
        '_methods',
        '_methodSignatures',
        '_methodDescriptions',
        '_server',
Ejemplo n.º 24
0
"""ASTranslate"""

import AppKit
from PyObjCTools import NibClassBuilder, AppHelper
from Foundation import NSUserDefaults

import MacOS

import osascript, aem

import eventformatter
import rubyrenderer, objcrenderer

NibClassBuilder.extractClasses("MainMenu")
NibClassBuilder.extractClasses("ASTranslateDocument")

_ci = osascript.Interpreter()

#######

_userDefaults = NSUserDefaults.standardUserDefaults()

if not _userDefaults.integerForKey_(u'defaultOutputLanguage'):
    _userDefaults.setInteger_forKey_(0, u'defaultOutputLanguage')

#######


class ASApplicationDelegate(NibClassBuilder.AutoBaseClass):
    pass
Ejemplo n.º 25
0
To build the demo program, run this line in Terminal.app:

    $ python setup.py py2app -A

This creates a directory "dist" containing PythonBrowser.app. (The
-A option causes the files to be symlinked to the .app bundle instead
of copied. This means you don't have to rebuild the app if you edit the
sources or nibs.)
"""

from Foundation import NSObject
from PyObjCTools import NibClassBuilder
import sys


NibClassBuilder.extractClasses("PythonBrowser")


# class defined in PythonBrowser.nib
class PythonBrowserWindowController(NibClassBuilder.AutoBaseClass):
    # the actual base class is NSWindowController
    # The following outlets are added to the class:
    # outlineView

    def __new__(cls, obj):
        # "Pythonic" constructor
        return cls.alloc().initWithObject_(obj)

    def initWithObject_(self, obj):
        from PythonBrowserModel import PythonBrowserModel
        self = self.initWithWindowNibName_("PythonBrowser")
import objc
from Foundation import *
from AppKit import *
from PyObjCTools import NibClassBuilder, AppHelper
NibClassBuilder.extractClasses( u"EYETest" )

class MethodListController(NibClassBuilder.AutoBaseClass):
   searchString = None

   def arrangeObjects_(self, objects):
      supermethod = super(MethodListController, self).arrangeObjects_
      if not self.searchString:
          return supermethod(objects)
      if len(self.searchString)==0:
         return supermethod(objects)
      sublist = []
      for obj in objects:
         for a in obj.keys():
            if obj[a].find(self.searchString) !=-1:
               sublist+=[obj]
               break
      return supermethod(sublist)

   def performSearch_(self, sender):
      self.searchString = unicode(sender.stringValue())
      self.rearrangeObjects()
Ejemplo n.º 27
0
#  Created by Drue Loewenstern on Sun Feb 15 2004.
#  Copyright (c) 2004 __MyCompanyName__. All rights reserved.
#

from threading import Event
from traceback import print_exc
import sys
sys.argv = ["BitTorrent.app"]
import os

from Foundation import *
from AppKit import *
from PyObjCTools import NibClassBuilder
from objc import selector
import objc
NibClassBuilder.extractClasses("Metainfo")

#from btmakemetafile import makeinfo
#from btcompletedir import completedir
from BitTorrent.makemetafile import make_meta_file, make_meta_file_dht, calcsize
from BitTorrent.bencode import bencode, bdecode

ANNOUNCEKEY = "AnnounceString"
GWINKEY = "GenerateFrame"
COMPLETEDIRKEY = "CompleteDir"
SWITCHKEY = "TrackerSwitch"

TRACKER = 0
TLAUTO = 1
TLNODES = 2
Ejemplo n.º 28
0
from Foundation import *
from AppKit import *
from PyObjCTools import NibClassBuilder
from objc import ivar

NibClassBuilder.extractClasses("CurrencyConvBindingDocument")


class Converter(NibClassBuilder.AutoBaseClass):

    # The input fields have formatters that convert the text
    # value to a number. If we wouldn't do that, exchangeRate
    # and dollarsToConvert would be set to strings.
    #
    # The alternative is using objc instance variables of the
    # right type (in this case doubles) and let the Cocoa
    # implementation worry about the conversion:
    #   exchangeRate = ivar('exchangeRate', 'd')
    #   dollarsToConvert = ivar('dollarsToConvert', 'd')

    def init(self):
        self = super(Converter, self).init()
        self.exchangeRate = 3
        self.dollarsToConvert = 4
        return self

    def amountInOtherCurrency(self):
        return self.dollarsToConvert * self.exchangeRate


Converter.setKeys_triggerChangeNotificationsForDependentKey_(
Ejemplo n.º 29
0
from bisect import bisect
import re
import objc
from Foundation import *
from AppKit import *
from PyObjCTools import NibClassBuilder
from nodebox.util.PyFontify import fontify
from nodebox.gui.mac.ValueLadder import ValueLadder

whiteRE = re.compile(r"[ \t]+")
commentRE = re.compile(r"[ \t]*(#)")

NibClassBuilder.extractClasses("NodeBoxDocument")


def findWhitespace(s, pos=0):
    m = whiteRE.match(s, pos)
    if m is None:
        return pos
    return m.end()


stringPat = r"q[^\\q\n]*(\\[\000-\377][^\\q\n]*)*q"
stringOrCommentPat = stringPat.replace("q", "'") + "|" + stringPat.replace(
    'q', '"') + "|#.*"
stringOrCommentRE = re.compile(stringOrCommentPat)


def removeStringsAndComments(s):
    items = []
    while 1:
Ejemplo n.º 30
0
from AppKit import *
from Foundation import *
from PyObjCTools import NibClassBuilder
from PyDETextView import getBasicTextAttributes, getSyntaxTextAttributes
from PyDETextView import setTextFont, setBasicTextAttributes, setSyntaxTextAttributes


NibClassBuilder.extractClasses("NodeBoxPreferences")


# class defined in PyDEPreferences.nib
class NodeBoxPreferencesController(NibClassBuilder.AutoBaseClass):
    # the actual base class is NSWindowController

    def init(self):
        self = self.initWithWindowNibName_("NodeBoxPreferences")
        self.setWindowFrameAutosaveName_("NodeBoxPreferencesPanel")
        self.timer = None
        return self

    def awakeFromNib(self):
        self.textFontChanged_(None)
        syntaxAttrs = syntaxAttrs = getSyntaxTextAttributes()
        self.stringsColorWell.setColor_(syntaxAttrs["string"][NSForegroundColorAttributeName])
        self.keywordsColorWell.setColor_(syntaxAttrs["keyword"][NSForegroundColorAttributeName])
        self.funcClassColorWell.setColor_(syntaxAttrs["identifier"][NSForegroundColorAttributeName])
        self.commentsColorWell.setColor_(syntaxAttrs["comment"][NSForegroundColorAttributeName])

        nc = NSNotificationCenter.defaultCenter()
        nc.addObserver_selector_name_object_(self, "textFontChanged:", "PyDETextFontChanged", None)
Ejemplo n.º 31
0
#  Bookmarks
#
#  Converted by u.fiedler on 10.02.05.
#
#  The original version was written in Objective-C by Malcolm Crawford
#  at http://homepage.mac.com/mmalc/CocoaExamples/controllers.html

import objc
from PyObjCTools import NibClassBuilder
from Foundation import *

# BookmarksDocument defines this as it may be used for copy and paste
# in addition to just drag and drop
CopiedRowsType = u"COPIED_ROWS_TYPE"

NibClassBuilder.extractClasses("BookmarksDocument")


class BookmarksDocument(NibClassBuilder.AutoBaseClass):
    # the actual base class is NSDocument
    # The following outlets are added to the class:
    # window??? is connected in IB but can not be accessed?

    bookmarksArray = objc.ivar('bookmarksArray')

    def init(self):
        self = super(BookmarksDocument, self).init()
        if self is None:
            return None
        self.bookmarksArray = NSMutableArray.array()
        return self
Ejemplo n.º 32
0
from PyObjCTools import NibClassBuilder
from CoreData import *
from AppKit import *

NibClassBuilder.extractClasses("MyDocument")

prioritySortDescriptions = NSArray.arrayWithObject_(
    NSSortDescriptor.alloc().initWithKey_ascending_("value", True))


class MyDocument(NibClassBuilder.AutoBaseClass):
    def initWithType_error_(self, tp, error):
        self, error = super(MyDocument, self).initWithType_error_(tp, error)
        if self is None:
            return (None, error)

        managedObjectContext = self.managedObjectContext()

        for aPriorityValue in range(5):
            aPriority = NSEntityDescription.insertNewObjectForEntityForName_inManagedObjectContext_(
                "Priority", managedObjectContext)
            aPriority.setValue_forKey_(aPriorityValue + 1, "value")

        NSEntityDescription.insertNewObjectForEntityForName_inManagedObjectContext_(
            "Note", managedObjectContext)

        managedObjectContext.processPendingChanges()
        managedObjectContext.undoManager().removeAllActions()
        self.updateChangeCount_(NSChangeCleared)

        return (self, None)
Ejemplo n.º 33
0
import objc
from Foundation import *
from AppKit import *
from PyObjCTools import NibClassBuilder, AppHelper
import cPickle

NibClassBuilder.extractClasses("GPDoc")

import sys

sys.path.append('/Users/mwh/Source/lsprof')

import lsprof


WRAPPED={}
class Wrapper (NSObject):
    """
    NSOutlineView doesn't retain values, which means we cannot use normal
    python values as values in an outline view.
    """
    def init_(self, value):
        self.value = value
        return self

    def __str__(self):
        return '<Wrapper for %s>'%self.value

    def description(self):
        return str(self)
import PythonCAD.Generic.circle
import PythonCAD.Generic.leader
import PythonCAD.Generic.polyline
import PythonCAD.Generic.segjoint
import PythonCAD.Generic.conobject
import PythonCAD.Generic.baseobject
import PythonCAD.Generic.dimension
import PythonCAD.Generic.units
import PythonCAD.Interface.Cocoa.ImageDocument
import PythonCAD.Interface.Cocoa.CADView
import PythonCAD.Interface.Cocoa.AppController

from PyObjCTools import NibClassBuilder, AppHelper

#Initialize NIB
NibClassBuilder.extractClasses("ImageDocument")

#
# set up global variables ...
#

PythonCAD.Generic.globals.prefs = PythonCAD.Generic.baseobject.LockedDict(str)
PythonCAD.Generic.globals.colors = PythonCAD.Generic.baseobject.TypedDict(
    PythonCAD.Generic.color.Color, PythonCAD.Generic.color.Color)
PythonCAD.Generic.globals.linetypes = PythonCAD.Generic.baseobject.TypedDict(
    PythonCAD.Generic.linetype.Linetype, PythonCAD.Generic.linetype.Linetype)
PythonCAD.Generic.globals.styles = PythonCAD.Generic.baseobject.TypedDict(
    PythonCAD.Generic.style.Style, PythonCAD.Generic.style.Style)
PythonCAD.Generic.globals.dimstyles = []

PythonCAD.Generic.globals.selectobj = PythonCAD.Generic.selections.Selection()
#
#  FilteringControllerDocument.py
#  FilteringController
#
#  Converted by u.fiedler on 05.02.05.
#
#  The original version was written in Objective-C by Malcolm Crawford
#  at http://homepage.mac.com/mmalc/CocoaExamples/controllers.html

from PyObjCTools import NibClassBuilder, AppHelper
import objc
from Foundation import NSKeyedArchiver, NSKeyedUnarchiver

NibClassBuilder.extractClasses("FilteringControllerDocument")

class FilteringControllerDocument(NibClassBuilder.AutoBaseClass):
    # the actual base class is NSDocument
    # The following outlets are added to the class:
    # peopleController

    def init(self):
        self = super(FilteringControllerDocument, self).init()
        if self is None: return None
        self._k_people = []
        return self

    def windowNibName(self):
        return u"FilteringControllerDocument"

    def windowControllerDidLoadNib_(self, controller):
        super(FilteringControllerDocument, self).windowControllerDidLoadNib_(controller)
Ejemplo n.º 36
0
from AppKit import *
from Foundation import *
from PyObjCTools import NibClassBuilder, AppHelper

NibClassBuilder.extractClasses('MainMenu.nib')
NibClassBuilder.extractClasses('PreferenceWindow.nib')
NibClassBuilder.extractClasses('MyDocument.nib')
from PreferencesWindowController import *
from MyDocument import *
from LaunchServices import *

PYTHON_EXTENSIONS = [u'py', 'pyw', u'pyc']

FILE_TYPE_BINDING_MESSAGE = u"""
%s is not the default application for all Python script types.  You should fix this with the Finder's "Get Info" command.

See "Changing the application that opens a file" in Mac Help for details.
""".strip()


class MyAppDelegate(NibClassBuilder.AutoBaseClass):
    def init(self):
        self = super(MyAppDelegate, self).init()
        self.initial_action_done = False
        self.should_terminate = False
        return self

    def showPreferences_(self, sender):
        PreferencesWindowController.getPreferencesWindow()

    def applicationDidFinishLaunching_(self, aNotification):
Ejemplo n.º 37
0
import sys
import traceback
import sets
import keyword
import time
from code import InteractiveConsole, softspace
from StringIO import StringIO
from objc import YES, NO, selector
from Foundation import *
from AppKit import *
from PyObjCTools import NibClassBuilder, AppHelper

NibClassBuilder.extractClasses("PyInterpreter.nib")

try:
    sys.ps1
except AttributeError:
    sys.ps1 = ">>> "
try:
    sys.ps2
except AttributeError:
    sys.ps2 = "... "


class PseudoUTF8Output(object):
    softspace = 0

    def __init__(self, writemethod):
        self._write = writemethod

    def write(self, s):
Ejemplo n.º 38
0
import traceback
import sets
import keyword
import time
from code import InteractiveConsole, softspace
from StringIO import StringIO
import objc
from objc import YES, NO, selector
from Foundation import *
from AppKit import *
from PyObjCTools import NibClassBuilder, AppHelper
import os

myBundle = NSBundle.bundleWithPath_(os.path.dirname(os.path.dirname(os.environ['RESOURCEPATH'])).decode('utf8'))

NibClassBuilder.extractClasses("PyInterpreter.nib", bundle=myBundle)

try:
    sys.ps1
except AttributeError:
    sys.ps1 = ">>> "
try:
    sys.ps2
except AttributeError:
    sys.ps2 = "... "

class PseudoUTF8Output(object):
    softspace = 0
    def __init__(self, writemethod):
        self._write = writemethod
Ejemplo n.º 39
0
from Foundation import *
from AppKit import *

from PyObjCTools import NibClassBuilder

import iTunes

# We tell NibClassBuilder to examine and remember all
# classes from the CDInfoDocument NIB file. This way,
# we can subclass our ITunesCommunication from AutoBaseClass
# later on, and its actual baseclass will be ITunesCommunication
# from the NIB file.
# Since the NIB files are in the application, NOT the plugin, we
# need to specify this explicitly.  Typicaly, NIB files would be in the
# plugins.
NibClassBuilder.extractClasses("CDInfoDocument", bundle=NSBundle.mainBundle())

class ITunesCommunication(NibClassBuilder.AutoBaseClass):
    def init(self):
        self = super(ITunesCommunication, self).init()
        if self is None:
            return None
        # subclass specific initialization here
        # nib not loaded yet
        self.itunes = iTunes.iTunes()
        return self

    def getITunesInfo(self):
        curtrk = self.itunes.current_track
        try:
            current_track = self.itunes.get(curtrk)
Ejemplo n.º 40
0
import objc
from Foundation import *
from AppKit import *
from PyObjCTools import NibClassBuilder, AppHelper

NibClassBuilder.extractClasses("editor")

from EditorController import EditorController
from ContextsController import ContextsController


if __name__ == "__main__":
    print "We already have one running"
    #AppHelper.runEventLoop()
Ejemplo n.º 41
0
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

## Copyright 2004, Andrew Loewenstern.  All Rights Reserved

from Foundation import *
from AppKit import *

from PyObjCTools import NibClassBuilder

NibClassBuilder.extractClasses("TorrentWindow")

from BTAppController import NoTorrentSelected
from Preferences import *

DEFAULT_RATE = 0
DEFAULT_SLOTS = 0
MIN_SLOTS = 1

class MyItem(NSToolbarItem):
    def validate(self):
        self.setEnabled_(self.target().enabled())
    
class QueueItem(NSToolbarItem):
    def validate(self):
        if defaults.integerForKey_(DOQUEUE) == 1:
Ejemplo n.º 42
0
"""ASTranslate"""

import AppKit
from PyObjCTools import NibClassBuilder, AppHelper

import osascript

import eventformatter


NibClassBuilder.extractClasses("ASTranslateDocument")

_ci = osascript.Interpreter()


class ASTranslateDocument(NibClassBuilder.AutoBaseClass):  # (NSDocument)
    # Outlets:
    # codeView
    # resultView

    _script = None  # an osascript.Script instance

    def _appendResult(self, s):
        self.resultView.textStorage().appendAttributedString_(
            AppKit.NSAttributedString.alloc().initWithString_(u"%s\n\n" % s)
        )

    def windowNibName(self):  # a default NSWindowController is created automatically
        return "ASTranslateDocument"

    def windowControllerDidLoadNib_(self, controller):
import traceback
import sets
import keyword
import time
import errno
import posix
from code import InteractiveConsole, softspace
from StringIO import StringIO
from objc import YES, NO, selector
from Foundation import *
from AppKit import *
from PyObjCTools import NibClassBuilder, AppHelper

from EmbeddedInterpreterPlugIn import InterpreterKeyController

NibClassBuilder.extractClasses("PyInterpreter.nib")

try:
    sys.ps1
except AttributeError:
    sys.ps1 = ">>> "
try:
    sys.ps2
except AttributeError:
    sys.ps2 = "... "

class PseudoUTF8Output(object):
    softspace = 0
    encoding = 'utf8'

    def __init__(self, writemethod):
Ejemplo n.º 44
0
def draw_if_interactive():
    if matplotlib.is_interactive():
        figManager = Gcf.get_active()
        if figManager is not None:
            figManager.show()


class FigureCanvasCocoaAgg(FigureCanvasAgg):
    def draw(self):
        FigureCanvasAgg.draw(self)

    def blit(self, bbox):
        pass


NibClassBuilder.extractClasses('Matplotlib.nib', mplBundle)


class MatplotlibController(NibClassBuilder.AutoBaseClass):
    # available outlets:
    #  NSWindow plotWindow
    #  PlotView plotView

    def awakeFromNib(self):
        # Get a reference to the active canvas
        NSApp().setDelegate_(self)
        self.app = NSApp()
        self.canvas = Gcf.get_active().canvas
        self.plotView.canvas = self.canvas
        self.canvas.plotView = self.plotView
Ejemplo n.º 45
0
from PyObjCTools import NibClassBuilder, AppHelper

NibClassBuilder.extractClasses('MainMenu.nib')

import CGraphController

AppHelper.runEventLoop()
Ejemplo n.º 46
0
from PyObjCTools import NibClassBuilder, AppHelper

import Foundation, AppKit, WebKit
from Foundation import *
from AppKit import *
import objc
objc.setVerbose(1)

import PyDocURLProtocol
import PyDocEvents

PyDocURLProtocol.setup()

NibClassBuilder.extractClasses('PyDocBrowser')

# the web browser doesn't have or need any code really

if __name__ == '__main__':
    AppHelper.runEventLoop()
Ejemplo n.º 47
0
#  GraphicsBindingsDocument.py
#  GraphicsBindings
#
#  Converted by u.fiedler on feb 2005
#  with great help from Bob Ippolito - Thank you Bob!
#
#  The original version was written in Objective-C by Malcolm Crawford
#  http://homepage.mac.com/mmalc/CocoaExamples/controllers.html

import objc
from PyObjCTools import NibClassBuilder, AppHelper

from RadiansToDegreesTransformer import RadiansToDegreesTransformer
from Foundation import * 

NibClassBuilder.extractClasses("GraphicsBindingsDocument")

class GraphicsBindingsDocument(NibClassBuilder.AutoBaseClass):
    # the actual base class is NSDocument
    # The following outlets are added to the class:
    # graphicsView, shadowInspector, graphicsController

    graphics = objc.ivar('graphics')

    def init(self):
        self = super(GraphicsBindingsDocument, self).init()
        if self is None:
            return None
        self.graphics = [] # NSMutableArray.array()
        self.bindings = []
        return self
Ejemplo n.º 48
0
    objc.loadBundle(
        "Keychain",
        Keychain.__dict__,
        bundle_path="%s/%s" % (NSBundle.mainBundle().bundlePath(),
                               "Contents/Frameworks/Keychain.framework"))
except ImportError: # we were built with --alias, perhaps
    objc.loadBundle(
        "Keychain",
        Keychain.__dict__,
        bundle_path="/Library/Frameworks/Keychain.framework")

INTERVALS = {'seconds': 1.0,
             'minutes': 60.0,
             'hours': 3600.0}

NibClassBuilder.extractClasses("Preferences")


class HostRecord(object):

    def __init__(self,
                 keychain,
                 hostname=u'talc.socialtext.net',
                 port=u'21010',
                 ssl=False,
                 username=u'',
                 interval_value=30,
                 interval_granularity=u'seconds',
                 active=True):
        self.keychain = keychain
        self.hostname = hostname
        toolbarItem.setView_(anItemContent)
        bounds = anItemContent.bounds()
        minSize = (100, bounds[1][1])
        maxSize = (1000, bounds[1][1])
        toolbarItem.setMinSize_( minSize )
        toolbarItem.setMaxSize_( maxSize )

    if aMenu:
        menuItem = NSMenuItem.alloc().init()
        menuItem.setSubmenu_(aMenu)
        menuItem.setTitle_( aMenu.title() )
        toolbarItem.setMenuFormRepresentation_(menuItem)

    aController._toolbarItems[anIdentifier] = toolbarItem

NibClassBuilder.extractClasses( "WSTConnection" )

class WSTConnectionWindowController(NibClassBuilder.AutoBaseClass):
    """
    As per the definition in the NIB file,
    WSTConnectionWindowController is a subclass of
    NSWindowController.  It acts as a NSTableView data source and
    implements a standard toolbar.
    """
    __slots__ = ('_toolbarItems',
        '_toolbarDefaultItemIdentifiers',
        '_toolbarAllowedItemIdentifiers',
        '_methods',
        '_methodSignatures',
        '_methodDescriptions',
        '_server',
Ejemplo n.º 50
0
"""
Support for Python source files
"""
from AppKit import *

from PyObjCTools import NibClassBuilder
import re

NIBNAME="PythonDocument"

NibClassBuilder.extractClasses(NIBNAME)

UNKNOWN_ENCODING_WR="""\
The source code specifies a source code encoding that is unknown to the
runtime system. Please specify a different encoding (such as utf-8).

Your file is not saved.
"""


ENCODING_FAILED="""\
The source file does not specify an encoding, or specifies an encoding that
cannot represent all characters used in the file. Please specify a different
encoding (such as utf-8).

Your file is not saved.
"""


class PyDEPythonDocument (NibClassBuilder.AutoBaseClass):
    """
#
# Define True & False in case this is Python < 2.2.1
#
try:
    True, False
except NameError:
    True, False = 1, 0

#
# Global variables
#
PythonCAD.Generic.globals.NSColors = {}
PythonCAD.Generic.globals.NSFonts = {}

NibClassBuilder.extractClasses("ImageDocument")


class CADView(NibClassBuilder.AutoBaseClass, PythonCAD.Generic.message.Messenger):
    """ Custom NSView for visual display & editing of a PythonCad CAD image.
    
A CADView is an NSView used for editing & display of a generic Image object.

    """

    #
    # Beginning of Cocoa methods
    #
    def init(self):
        """ NSView override for cocoa initializer of CADView
        
Ejemplo n.º 52
0
from PyObjCTools import AppHelper, NibClassBuilder
from AppKit import *
from Foundation import NSZeroPoint

from math import floor
import sys

NibClassBuilder.extractClasses("MainMenu")

class Controller(NibClassBuilder.AutoBaseClass):
    """."""
    def changeTransparency_(self, sender):
        """."""
        self.itsWindow.setAlphaValue_(sender.floatValue())
        self.itsWindow.display()

class CustomView(NibClassBuilder.AutoBaseClass):
    """."""
    def awakeFromNib(self):
        """."""
        self.circleImage = NSImage.imageNamed_("circle")
        if self.circleImage is None:
            sys.stderr.write('failed to access circle image\n')
            raise RuntimeError
        self.pentaImage = NSImage.imageNamed_("pentagram")
        if self.pentaImage is None:
            sys.stderr.write('failed to access pentagram image\n')
            raise RuntimeError
        self.setNeedsDisplay_(True)
    
    def drawRect_(self, rect):
Ejemplo n.º 53
0
from AppKit import *
from Foundation import *
from PyObjCTools import NibClassBuilder
from PyDETextView import getBasicTextAttributes, getSyntaxTextAttributes
from PyDETextView import setTextFont, setBasicTextAttributes, setSyntaxTextAttributes

NibClassBuilder.extractClasses("NodeBoxPreferences")


# class defined in PyDEPreferences.nib
class NodeBoxPreferencesController(NibClassBuilder.AutoBaseClass):
    # the actual base class is NSWindowController

    def init(self):
        self = self.initWithWindowNibName_("NodeBoxPreferences")
        self.setWindowFrameAutosaveName_("NodeBoxPreferencesPanel")
        self.timer = None
        return self

    def awakeFromNib(self):
        self.textFontChanged_(None)
        syntaxAttrs = syntaxAttrs = getSyntaxTextAttributes()
        self.stringsColorWell.setColor_(
            syntaxAttrs["string"][NSForegroundColorAttributeName])
        self.keywordsColorWell.setColor_(
            syntaxAttrs["keyword"][NSForegroundColorAttributeName])
        self.funcClassColorWell.setColor_(
            syntaxAttrs["identifier"][NSForegroundColorAttributeName])
        self.commentsColorWell.setColor_(
            syntaxAttrs["comment"][NSForegroundColorAttributeName])
Ejemplo n.º 54
0
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from Foundation import *
from AppKit import *
from PyObjCTools import NibClassBuilder
from BTAppController import NoTorrentSelected

from time import asctime, localtime

NibClassBuilder.extractClasses("MainMenu")


class LogController(NibClassBuilder.AutoBaseClass):
    def awakeFromNib(self):
        NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(
            self, self.incomingError, "DLControllerError", None)
        NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(
            self, self.selectionChanged, "TorrentSelectionChanged", None)

    def selectionChanged(self, note):
        self.logView.reloadData()
        self.logView.sizeToFit()
        self.logView.scrollRowToVisible_(self.logView.numberOfRows() - 1)

    def incomingError(self, note):
Ejemplo n.º 55
0
"""TinyTinyEdit -- A minimal Document-based Cocoa application."""
import sys
print 'PATH', sys.path
import urllib
import amiscore
import os
import sys

from PyObjCTools import NibClassBuilder, AppHelper

NibClassBuilder.extractClasses("AmisGuiDocument")


# class defined in AmisGuiDocument.nib
class AmisGuiDocument(NibClassBuilder.AutoBaseClass):
    # the actual base class is NSDocument
    # The following outlets are added to the class:
    # textView

    path = None

    def init(self):
        self.dtb = amiscore.Dtb()
        self.bmkdir = os.path.join(os.getenv("HOME"), "bmk")
        self.curphrase = None

    def windowNibName(self):
        return "AmisGuiDocument"

    def readFromFile_ofType_(self, path, tp):
        print 'readFromFile', path, tp
Ejemplo n.º 56
0
# This overrides PyObjC detection in ForgeryCommon, so that the
# wxPython version can be used on a Mac.  Set it to True to enable
# the override, or False to disable it.
__builtin__.preferWX = False

from ForgeryCommon import *

if usePyObjC:

    from PyObjCTools import NibClassBuilder, AppHelper
    from Foundation import NSBundle

    info = NSBundle.mainBundle().infoDictionary()[u'PyObjCXcode']

    for nibFile in info[u'NIBFiles']:
        NibClassBuilder.extractClasses(nibFile)
    del nibFile

    for pythonModule in info[u'Modules']:
        __import__(pythonModule)
    del pythonModule

    del info

import ForgeryApplication, ForgeryCursor


def main():
    if usePyObjC:
        ForgeryCursor.initCursors()
        AppHelper.runEventLoop()
Ejemplo n.º 57
0
"""
Example showing screen saver in PyObjC

Based on "Silly Balls.saver" by Eric Peyton <*****@*****.**>
    http://www.epicware.com/macosxsavers.html
"""
import objc

from AppKit import NSBezierPath, NSColor
from ScreenSaver import *
from random import random, randrange
from PyObjCTools import NibClassBuilder

NibClassBuilder.extractClasses("SillyBalls")

class SillyBalls (NibClassBuilder.AutoBaseClass):

    def animateOneFrame(self):
        # choose a random point.
        (x, y), (fw, fh) = self.frame()
        x, y = randrange(0.0, fw), randrange(0.0, fw)
        ballSize = randrange(10.0, 90.0)

        path = NSBezierPath.bezierPathWithOvalInRect_(((x, y), (ballSize, ballSize)))

        # make a random color.
        randomColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(random(), random(), random(), random())

        # set it.
        randomColor.set()