def applicationDidFinishLaunching_ (self, aNotification):
"""
The application is ready. We start the DataListener threads
if needed.
"""
# Remove any leftover UNIX pipe.
try:
os.remove (UNIX_ADDR)
except:
pass
# Start the data listener threads
self.inetDataThread = DataListener (sockType='inet', controller=self)
self.inetDataThread.start ()
self.unixDataThread = DataListener (sockType='unix', controller=self)
self.unixDataThread.start ()
# Are we asked to check and see if a new version is out?
# if (PREFS['checkForNewVersion']):
# # Yes. Start a new thread and do the chack. We should
# # give the user the possibility to have the new version
# # downloaded automatically.
# v = VersionChecker ()
return
class AppDelegate (NibClassBuilder.AutoBaseClass):
"""
This, in a sense, is the main application. It is here that we
setup all the various bits and pieces that make up our app.
This class is defined in MainMenu.nib and, therefore is already
instantiated (it is like it has been pickled). This is why we do
not have a Python constructor method: it would never get called.
This class has some instance variables already defined in the NIB
file.
"""
def init (self):
"""
Initialization method. Sets instance variables ro defult
values. It also takes care of initializing the
preferences dictionary (PREFS).
This is the Cocoa init method, not the Python __init__.
"""
self.inetDataThread = None
self.unixDataThread = None
self.infoPanel = None
self.headerPanel = None
self.toolbarItems = {}
self.toolbarLabels = []
self.toolbar = None
# make sure that only one pref vindow will be open
self.showingPrefsWindow = False
# read the application preferences
prefs = NSUserDefaults.standardUserDefaults ()
# do we have a preferences file, already?
if (prefs.boolForKey_ ('HasPrefsFile')):
for key in PREFS.keys ():
if (key == 'irafRoot'):
value = prefs.stringForKey_ (key)
else:
value = prefs.boolForKey_ (key)
PREFS[key] = value
# Create a dict of FrameBuffer instances. These will hold
# the image data that we are going to display. At first, we
# just need to create one FrameBuffer object.
# The format of the dict is quite simple:
# {index: FrameBuffer}
#
# We use a dictionary so that we can remove frames without
# worrying about keeping them in order.
self.frameBuffers = {0: FrameBuffer ()}
self.currentFrame = 0
super (AppDelegate, self).init ()
return (self)
def awakeFromNib (self):
"""
The Application just finished loading from the NIB file. We
setup the main window (and create a toolbar).
"""
pool = NSAutoreleasePool.alloc ().init ()
# For each label in TOOLBAR_LABELS, create a toolbar item. We
# keep track of those items by using the self.toolbarItems
# dictionary.
for label in TOOLBAR_LABELS:
tbi = NSToolbarItem.alloc ().initWithItemIdentifier_ (label)
# Hook the toolbar item to a routine in self.imageView.
# The routine has to have the same name as label.
tbi.setAction_ (label)
tbi.setTarget_ (self.imageView)
# This is the label that will appear in the toolbar
tbi.setLabel_ (label)
# This is the label that will appear in the config panel
tbi.setPaletteLabel_ (label)
# Set the tooltip text
tbi.setToolTip_ (label)
# Setup the item's icon
path = os.path.abspath (RESOURCES_PATH + '/' + label + '.tiff')
image = NSImage.alloc ().initWithContentsOfFile_ (path)
tbi.setImage_ (image)
self.toolbarItems[label] = tbi
self.toolbarLabels.append (label)
# Add the two extra items we always want: flexible space
# and customize.
self.toolbarLabels.append (NSToolbarFlexibleSpaceItemIdentifier)
self.toolbarLabels.append (NSToolbarCustomizeToolbarItemIdentifier)
# Now that we have created the necessary toolbar items, we
# can create the toolbar itself.
self.toolbar = NSToolbar.alloc ().initWithIdentifier_ ('mainToolbar')
self.toolbar.setDelegate_ (self)
# make the toolbar configurable
self.toolbar.setAllowsUserCustomization_ (True)
self.toolbar.setAutosavesConfiguration_ (True)
# attach the toolbar to the window
self.mainWindow.setToolbar_ (self.toolbar)
# colormap stuff
self.lutNames = []
self.defaultLut = DEFAULT_LUT
pool.release ()
return
def applicationWillFinishLaunching_ (self, aNotification):
"""
Update/create menus (at startup) here!
"""
pool = NSAutoreleasePool.alloc ().init ()
# find the Image->Colormap submenu
mainMenu = NSApp ().mainMenu ()
imageMenu = mainMenu.itemWithTitle_ ('Image').submenu ()
colormapMenu = imageMenu.itemWithTitle_ ('Colormap').submenu ()
# Add the colormaps we found
if (not self.lutNames):
self.imageView.initColormaps ()
for lutName in self.lutNames:
newItem = NSMenuItem.allocWithZone_ (NSMenu.menuZone ())
newItem.initWithTitle_action_keyEquivalent_ (lutName, None, '')
newItem.setAction_ ('setColormap')
newItem.setTarget_ (self.imageView)
colormapMenu.addItem_ (newItem)
newItem.release ()
# select self.defaultLut menu item
theOne = colormapMenu.itemWithTitle_ (self.defaultLut).setState_ (NSOnState)
pool.release ()
return
def applicationDidFinishLaunching_ (self, aNotification):
"""
The application is ready. We start the DataListener threads
if needed.
"""
# Remove any leftover UNIX pipe.
try:
os.remove (UNIX_ADDR)
except:
pass
# Start the data listener threads
self.inetDataThread = DataListener (sockType='inet', controller=self)
self.inetDataThread.start ()
self.unixDataThread = DataListener (sockType='unix', controller=self)
self.unixDataThread.start ()
# Are we asked to check and see if a new version is out?
# if (PREFS['checkForNewVersion']):
# # Yes. Start a new thread and do the chack. We should
# # give the user the possibility to have the new version
# # downloaded automatically.
# v = VersionChecker ()
return
def setLuts (self, lutNames, defaultLut=DEFAULT_LUT):
"""
Set the instance variables self.lutNames and self.defaultLut.
It is invoked by self.imageView after it is done scanning the
colormaps directory.
"""
self.lutNames = lutNames
self.defaultLut = defaultLut
return
def checkVersion_ (self, sender):
"""
Check the main site (pyimtool.berlios.de) for new versions
of the software.
"""
# Start a new thread and do the check. We should
# give the user the possibility to have the new version
# downloaded automatically.
v = VersionChecker ()
return
def toolbarDefaultItemIdentifiers_ (self, toolbar):
"""
Create the default toolbar.
"""
return (self.toolbarLabels)
def toolbarAllowedItemIdentifiers_ (self, toolbar):
"""
List all the allowed toolbar items.
"""
items = self.toolbarItems.keys ()
items.sort ()
items.append (NSToolbarSeparatorItemIdentifier)
items.append (NSToolbarSpaceItemIdentifier)
items.append (NSToolbarFlexibleSpaceItemIdentifier)
items.append (NSToolbarPrintItemIdentifier)
items.append (NSToolbarShowColorsItemIdentifier)
items.append (NSToolbarShowFontsItemIdentifier)
items.append (NSToolbarCustomizeToolbarItemIdentifier)
return (items)
def toolbar_itemForItemIdentifier_willBeInsertedIntoToolbar_ (self,
toolbar,
identifier,
flag):
"""
Given an identifier, return the corresponding toolbar item.
"""
return (self.toolbarItems[identifier])
def displayImage (self, dump=False):
"""
This method gets called by the active RequestHandler object
as soon as it is done reading image data. This means that we
can be confident that the current frame buffer (identified by
self.curentFrame) is properly setup.
"""
if (dump):
try:
f = file ('/tmp/pyimtool.raw', 'wb')
f.write (self.frameBuffers[self.currentFrame].buffer)
f.close ()
except:
pass
# Since we are drawing into an OpenGL view, we need to flip the
# bitmap vertically
self.frameBuffers[self.currentFrame].buffer = \
self.frameBuffers[self.currentFrame].buffer[::-1]
# create the raw data repository
self.frameBuffers[self.currentFrame].raw = \
self.frameBuffers[self.currentFrame].buffer.tostring ()
self.imageView.display (self.frameBuffers[self.currentFrame],
self.currentFrame)
return
def initFrame (self, fbIndex):
"""
Erases the fbIndex-th FrameBuffer object in self.frameBuffers
and returns the (empty) FrameBuffer.
"""
n = len (self.frameBuffers)
if (fbIndex >= n):
# we need to create a new FrameBuffer object (and
# possibly intermediate FrameBuffers as well).
for i in range (n, fbIndex + 1):
self.frameBuffers[i] = FrameBuffer ()
else:
# The FrameBuffer object we are interested in already
# exists: erase it. Foe efficiency sake, we just delete
# it and create a new (empty) one.
del (self.frameBuffers[fbIndex])
self.frameBuffers[fbIndex] = FrameBuffer ()
# return the fbIndex-th frame.
return (self.frameBuffers[fbIndex])
def setCurrentFrame (self, fbIndex):
if (fbIndex >= len (self.frameBuffers)):
raise (IndexError, 'framebuffer index out of range')
else:
self.currentFrame = fbIndex
return
def getFrame (self, fbIndex):
if (fbIndex >= len (self.frameBuffers)):
raise (IndexError, 'framebuffer index out of range')
else:
return (self.frameBuffers[fbIndex])
return (None)
def showInfoWindow_ (self, sender):
"""
Simply opens a new panel with general information about the
image being displayed (self.currentFrame).
If the sender's title is "Hide Info Window" it closes the
panel.
"""
if (sender.title ()[0] == 'H'):
# close the info panel
self.infoPanel.closeWindow (self)
# set the menu item title to "Show..."
sender.setTitle_ ('Show Info Panel')
else:
self.infoPanel = InfoController.infoController (self, self.imageView)
self.infoPanel.showWindow_ (self)
# set the menu item title to "Hide..."
sender.setTitle_ ('Hide Info Panel')
return
def infoWindowWillClose (self):
"""
Called just before the infoWindow will close. It sets the
correct label for the corresponding menu item.
"""
self.infoPanelMenuItem.setTitle_ ('Show Info Panel')
return
def showHeaderWindow_ (self, sender):
"""
Opens a separate window wwith the header information from the
currently displayed image (if possible).
"""
if (sender.title ()[0] == 'H'):
# close the info panel
self.headerPanel.closeWindow (self)
# set the menu item title to "Show..."
sender.setTitle_ ('Show Image Header')
else:
self.headerPanel = HeaderController.headerController (self, self.imageView)
self.headerPanel.showWindow_ (self)
# set the menu item title to "Hide..."
sender.setTitle_ ('Hide Image Header')
return
def headerWindowWillClose (self):
"""
Called just before the headerWindow will close. It sets the
correct label for the corresponding menu item.
"""
self.headerPanelMenuItem.setTitle_ ('Show Image Header')
return
def showPrefsWindow_ (self, sender):
"""
Shows the Preferences window
"""
if (not self.showingPrefsWindow):
prefsController = PrefsController.prefsController (self)
prefsController.showWindow_ (self)
self.showingPrefsWindow = True
return
def prefsWindowClosed (self):
"""
Update self.showingPrefsWindow
"""
self.showingPrefsWindow = False
return
def updateProgressInfo (self, statusText, progressPercent):
"""
Update both the statusField at the bottom of the window and
the progress bar/wheel (progressIndicator).
progressPercent tells where to draw the progress bar. If it
is equal to -1, then the progress bar should be undetermined.
If it is equal to 2.0, then we should stop the animation
"""
pool = NSAutoreleasePool.alloc().init()
if (self.statusField.stringValue () != statusText):
self.statusField.setStringValue_ ('')
self.statusField.setStringValue_ (statusText)
if (progressPercent < 0):
if (not self.progressIndicator.isIndeterminate ()):
self.progressIndicator.setIndeterminate_ (True)
self.progressIndicator.startAnimation_ (self)
elif (progressPercent <= 1.0):
if (self.progressIndicator.isIndeterminate ()):
self.progressIndicator.setIndeterminate_ (False)
self.progressIndicator.incrementBy_ (progressPercent)
else:
if (not self.progressIndicator.isIndeterminate ()):
self.progressIndicator.setDoubleValue_ (self.progressIndicator.minValue ())
self.progressIndicator.setIndeterminate_ (True)
self.progressIndicator.stopAnimation_ (self)
self.progressIndicator.setNeedsDisplay_ (True)
pool.release ()
return
