Hello,
The change to make the orthogonal scrollbar do what it should do is a bit
more complicated than the fixes below, so I've attached an updated
WindowPopup (which hopefully makes everything better and nothing worse,
although sod's law will tell you that something will probably get worse).
Wayne
On Thu, 30 Jun 2005, Tim Stevens wrote:
> > Adding a new strip makes the new strip active, but using "navigate
> > to" from another window sets the postition in both the new strip and
> > the last active strip. This is also true for other commands that
> > should go to just the active strip, like changing z-position using
> > the slider.
>
> Fixed for next release. Otherwise, in
> $CCPN_HOME/python/ccpnmr/analysis/WindowPopup.py at about line 3540 just
> after:
>
> if len(self.window.axisPanels[0].axisRegions) > 1:
> self.stripsButtons.buttons[1].enable()
>
> Add the lines:
>
> if col == -1:
> self.activateStrip(len(self.window.axisPanels[0].axisRegions)-1)
> else:
> self.activateStrip(col)
>
>
> > Using the "Find peak" button in the "Peak selection" Panel always
> > finds the peak in the first strip and not in the currently active.
>
> Ah. This function has pre-strip era code. Wayne is updating it now.
>
>
> > The "Remove" strip button in the spectrum window does not remove the
> > active strip, but the last strip.
>
> Fixed. Again in $CCPN_HOME/python/ccpnmr/analysis/WindowPopup.py in the
> function deleteCol(), just after:
>
> N = len(self.window.axisPanels[0].axisRegions)
> if N > 1:
> active_col = self.getActiveStrip()
>
> Add the lines:
>
> if (col == -1) and (active_col != 'all'):
> col = active_col
>
>
> > If the an active strip is removed, the new active strip gets the z-
> > position of the removed strip. (But the shown position is not altered
> > until the "slider" is moved.)
>
> Wayne is working on this one.
>
>
> > I also have a "wish list":
> >
> > It would be great if the assignment panel had an option to show only
> > possible assignments for which the sequence number is the same in two
> > or more dimensions. This would for example help if a 3D 15N-NOESY
> > spectrum is to be assigned, given a known HN and N assignment. Since
> > these resonances always come in pairs it would be great to be able to
> > remove all assignemt suggestions in which the HN and N belongs to
> > different residues in one of the H dimensions and in the N-dimension.
>
> This is already present in the latest versions of the Edit Assignment
> panel. There are two options for this sort of thing:
>
> 1, Restrict to repeated spin systems []
>
> 2, Bound resonances []
>
> These will limit the resonance possibilities for peak dimensions where a
> resonance is in the same spin system as (1) or bound to (2) a resonance in
> another dimension. Option (1) is useful if the resonances are in (possibly
> unassigned) spin systems. Option (2) is useful if the resonances carry
> atomic assignments.
>
> In the future, with the imminent inclusion of ExperimentPrototypes, there
> will be a further/replacement option to limit the resonances to only those
> that are allowed according to the types and connectivities possible for
> the peak's experiment.
>
>
> > I would like a feature in which a known assignment and structure
> > could be used to assign a NOESY-spectrum. Ansig for Windows has a
> > feature in which all distances up to a given distance can be plotted
> > in the NOESY spectrum as circles (larger circle = shorter distance)
> > with the assignments. This makes it easy to make and verify
> > assignemts in the spectrum.
>
> A structure 'predicted' NOESY is a good idea. Wayne and I will discuss how
> we might include this.
>
> At the moment you can load in a structure and display the distances from
> an assigned NOESY dimension to other possibilities in the Edit Assignment
> panel. Also, these possibilities can be superimposed on the structure with
> the [Show On Structure] function. Although, this is limited because you
> have to have one end on the NOE tied down, it should help until we have a
> better system.
>
>
> > Something which probably is alread on your "to do" list is to read
> > structures and compare them to constraint lists, make statistics and
> > then produce a peak list with all violations. It would be very useful
> > in stucture determinatinos!
>
> This wasn't on my "to do" list, but it is now. :)
>
> Tim
>
> -------------------------------------------------------------------------------
> Dr Tim Stevens Email: [log in to unmask]
> Department of Biochemistry [log in to unmask]
> University of Cambridge Phone: +44 1223 766022 (office)
> 80 Tennis Court Road +44 7816 338275 (mobile)
> Old Addenbrooke's Site +44 1223 364613 (home)
> Cambridge CB2 1GA WWWeb: http://www.bio.cam.ac.uk/~tjs23
> United Kingdom http://www.pantonia.co.uk
> -------------------------------------------------------------------------------
> ------ +NH3CH(CH(CH3)OH)C(O)NHCH(CH(CH3)CH2CH3)C(O)NHCH(CH2CH2SCH3)CO2- -------
> -------------------------------------------------------------------------------
>
"""
======================COPYRIGHT/LICENSE START==========================
WindowPopup.py: Part of the CcpNmr Analysis program
Copyright (C) 2005 Wayne Boucher and Tim Stevens (University of Cambridge)
=======================================================================
This file contains reserved and/or proprietary information
belonging to the author and/or organisation holding the copyright.
It may not be used, distributed, modified, transmitted, stored,
or in any way accessed, except by members or employees of the CCPN,
and by these people only until 31 December 2005 and in accordance with
the guidelines of the CCPN.
A copy of this license can be found in ../../../license/CCPN.license.
======================COPYRIGHT/LICENSE END============================
for further information, please contact :
- CCPN website (http://www.ccpn.ac.uk/)
- email: [log in to unmask]
- contact the authors: [log in to unmask], [log in to unmask]
=======================================================================
If you are using this software for academic purposes, we suggest
quoting the following references:
===========================REFERENCE START=============================
R. Fogh, J. Ionides, E. Ulrich, W. Boucher, W. Vranken, J.P. Linge, M.
Habeck, W. Rieping, T.N. Bhat, J. Westbrook, K. Henrick, G. Gilliland,
H. Berman, J. Thornton, M. Nilges, J. Markley and E. Laue (2002). The
CCPN project: An interim report on a data model for the NMR community
(Progress report). Nature Struct. Biol. 9, 416-418.
Wim F. Vranken, Wayne Boucher, Tim J. Stevens, Rasmus
H. Fogh, Anne Pajon, Miguel Llinas, Eldon L. Ulrich, John L. Markley, John
Ionides and Ernest D. Laue (2005). The CCPN Data Model for NMR Spectroscopy:
Development of a Software Pipeline. Proteins 59, 687 - 696.
===========================REFERENCE END===============================
"""
import math
import time
import Tkinter
from memops.general import Implementation
from memops.universal.Constants import True, False
from memops.universal.Region1D import Region1D
from memops.universal.Util import formatDecimals
from memops.gui.ButtonList import ButtonList
from memops.gui.Color import Color, hexRepr
from memops.gui.Label import Label
from memops.gui.MessageReporter import showError, showOkCancel
from memops.gui.PartitionedSelector import PartitionedSelector
from memops.gui.RegionSelector import RegionSelector
from memops.gui.ScrolledFrame import ScrolledFrame
from memops.gui.ScrolledWindow import ScrolledWindow, \
no_key_state, shift_key_state, ctrl_key_state
from memops.gui.ToggleLabel import ToggleLabel
from memops.gui.ValueRamp import ValueRamp
from memops.editor.Util import createHelpButtonList
from ccp.api import Nmr
from ccpnmr.api import Analysis
try:
import ccpnmr.c.ContourFile as ContourFile
import ccpnmr.c.ContourStyle as ContourStyle
import ccpnmr.c.ContourLevels as ContourLevels
import ccpnmr.c.PeakList as PeakList
import ccpnmr.c.SliceFile as SliceFile
import ccpnmr.c.WinPeakList as WinPeakList
except:
print 'Warning, the WindowPopup module will not work, you need to compile C code.'
ContourFile = ContourStyle = ContourLevels = PeakList = SliceFile = WinPeakList = None
from ccpnmr.analysis.BasePopup import BasePopup
try:
import memops.c.GlHandler as GlHandler
except:
GlHandler = None
try:
import memops.c.TkHandler as TkHandler
except:
TkHandler = None
if (not GlHandler and not TkHandler):
print 'Warning, the WindowPopup module will not work, you need to compile GlHandler or TkHandler C code.'
from ccpnmr.analysis.AssignmentBasic import addPeakResonancesToSeqSpinSystems, propagatePeakAssignments, addPeakResonancesToSpinSystem
from ccpnmr.analysis.GetCenterCoordsPopup import GetCenterCoordsPopup
from ccpnmr.analysis.MarkBasic import createPeakMark, createNonPeakMark, createRuler, \
removeMarks, removeRulers, createPeakDimRuler
from ccpnmr.analysis.PeakBasic import addPeak, addPeakToSelected, getPeakDimPosition, \
removePeakFromSelected, isPeakInRegion, findMatchingPeaks, \
setPeakPosition, findPeaks, searchPeaks, removePeaksAssignment, \
makePeakAnnotation, makeIntermediatePeak, propagatePeakUnaliasing, findPositionMatches
from ccpnmr.analysis.PeakFindParams import getPeakFindParams
from ccpnmr.analysis.SetReferencePopup import SetReferencePopup
from ccpnmr.analysis.SpectrumViewList import SpectrumViewList
from ccpnmr.analysis import Util
from ccpnmr.analysis.WindowDraw import WindowDraw
from ccpnmr.analysis.ExperimentBasic import changeSpectrumContourLevels
from ccpnmr.analysis.WindowBasic import getEquivalentWindows, isSpectrumInWindow, getSpectrumWindowView, createSpectrumWindow, centerAxisRegion, zoomToShowPeaks, findOrthogonalWindows, findWindowTransposes
# maximum time do double buffer before switch to single buffer
doubleBufferTimeout = 0.25 # seconds
slice_height_entries = [50, 100, 150, 200]
all_label = 'All'
# internal class
class WindowTimeoutException:
pass
# public class
# put BasePopup first so that lift() from that overrides lift() from WindowDraw
class WindowPopup(BasePopup, WindowDraw):
waitPeak = 0
waitStrips = 0
waitResize = 0
def __init__(self, parent, window, *args, **kw):
# TBD: temporary variables
self.drawCanvasCount = 0
self.doCanvasCount = 0
if (not GlHandler):
handlerClass = TkHandler.TkHandler
useGl = False
elif (not TkHandler):
handlerClass = GlHandler.GlHandler
useGl = True
else:
project = parent.getProject()
graphicsHandler = Util.getGraphicsHandler(project)
if (graphicsHandler == 'OpenGL'):
handlerClass = GlHandler.GlHandler
useGl = True
else:
handlerClass = TkHandler.TkHandler
useGl = False
if (useGl):
handlerExc = GlHandler.error
handlerXorColor = (0.0, 0.0, 0.0)
else:
handlerExc = TkHandler.error
handlerXorColor = (1.0, 1.0, 1.0)
self.handlerClass = handlerClass
self.handlerExc = handlerExc
self.handlerXorColor = handlerXorColor # for xor mode
#print 'handler info', handlerClass, handlerXorColor
WindowDraw.__init__(self, parent, window)
BasePopup.__init__(self, parent=parent, **kw)
def body(self, master):
self.widget_parent = master
self.font = '-schumacher-clean-medium-r-normal--14-140-75-75-c-70-iso646.1991-irv'
master.grid_rowconfigure(2, weight=1)
master.grid_columnconfigure(0, weight=1)
topFrame = ScrolledFrame(master, borderwidth=1, relief='raised', yscroll=False)
### hack
###from memops.gui.Frame import Frame
###topFrame = Frame(master, borderwidth=1, relief='raised')
###topFrame.frame = topFrame
###
topFrame.grid(row=0, column=0, sticky=Tkinter.EW)
self.lowerFrame = ScrolledFrame(master, borderwidth=2, relief='raised', yscroll=False)
#self.lowerFrame.grid(row=1, column=0, sticky=Tkinter.NW)
self.toggleLabels = []
col = 0
self.spectraToggleLabel = ToggleLabel(topFrame.frame, text='Spectra', callback=self.toggleSpectraFrame)
self.spectraToggleLabel.grid(row = 0, column=col, sticky=Tkinter.W)
self.toggleLabels.append(self.spectraToggleLabel)
col = col + 1
if (not self.hasValueAxis):
self.contourToggleLabel = ToggleLabel(topFrame.frame, text='Contours', callback=self.toggleContourFrame)
self.contourToggleLabel.grid(row = 0, column=col, sticky=Tkinter.W)
self.toggleLabels.append(self.contourToggleLabel)
col = col + 1
else:
self.contourToggleLabel = None
self.peaksToggleLabel = ToggleLabel(topFrame.frame, text='Peaks', callback=self.togglePeaksFrame)
self.peaksToggleLabel.grid(row = 0, column=col, sticky=Tkinter.W)
self.toggleLabels.append(self.peaksToggleLabel)
col = col + 1
self.stripsToggleLabel = ToggleLabel(topFrame.frame, text='Strips', callback=self.toggleStripsFrame)
self.stripsToggleLabel.grid(row = 0, column=col, sticky=Tkinter.W)
self.toggleLabels.append(self.stripsToggleLabel)
col = col + 1
topFrame.grid_columnconfigure(col, weight=1)
self.location_label = Label(topFrame.frame, font=self.font, text = 14*' ')
self.location_label.grid(row=0, column=col, sticky=Tkinter.E)
self.location_label.bind('<Double-1>', self.getCenterCoords)
col = col + 1
xname = self.window.axisPanels[0].axisType.name
yname = self.window.axisPanels[1].axisType.name
text = ' (%s,%s)' % (xname,yname)
label = Label(topFrame.frame, text=text, font=self.font)
label.grid(row=0, column=col, sticky=Tkinter.E)
col = col + 1
buttonList = createHelpButtonList(topFrame.frame, expands=1, help_url=self.help_url)
buttonList.grid(row=0, column=col, sticky=Tkinter.W)
col = col + 1
self.toggleWidgets = {}
frame = self.lowerFrame.frame
# lower frame widgets
if (self.contourToggleLabel):
self.contourLabel = label = Label(frame, text='Contour level:', font=self.font)
self.contourRamp = ValueRamp(frame, callback=self.changeScale)
self.contourButton = Tkinter.Button(frame, borderwidth=1, padx=2, pady=2, text='Detailed Settings', command=self.generalContours, font=self.font)
self.toggleWidgets[self.contourToggleLabel] = (self.contourLabel, self.contourRamp, self.contourButton)
self.spectrumToggleSelector = PartitionedSelector(frame, self.toggleSpectrum)
self.toggleWidgets[self.spectraToggleLabel] = (self.spectrumToggleSelector,)
self.peaksToggleSelector = PartitionedSelector(frame, self.togglePeaks)
self.peakListLabel = Label(frame, text='Peak List:', font=self.font)
self.toggleWidgets[self.peaksToggleLabel] = (self.peaksToggleSelector, self.peakListLabel)
self.stripsToggleSelector = PartitionedSelector(frame, self.toggleStrips, radio=True)
self.stripsButtons = ButtonList(frame, texts=['Add','Remove'],commands=[self.addCol, self.deleteCol],expands=1)
self.stripsLabel = Label(frame, text='Active strips:', font=self.font)
self.toggleWidgets[self.stripsToggleLabel] = (self.stripsToggleSelector,self.stripsButtons,self.stripsLabel,)
ncols = len(self.window.axisPanels[0].axisRegions)
nrows = len(self.window.axisPanels[1].axisRegions)
if ncols < 2:
self.stripsButtons.buttons[1].disable()
world_region = self.getWorldRegion()
xview_regions = self.getXviewRegions(world_region.x_region)
yview_regions = self.getYviewRegions(world_region.y_region)
xpanel = self.window.axisPanels[0]
ypanel = self.window.axisPanels[1]
width = [ axisRegion.size for axisRegion in xpanel.axisRegions ]
height = [ axisRegion.size for axisRegion in ypanel.axisRegions ]
xslice = xpanel.slicePanel
yslice = ypanel.slicePanel
show_xslices = xslice.isVisible
show_yslices = yslice.isVisible
xslice_size = Util.greaterOrEqualEntry(xslice.thickness, slice_height_entries)
yslice_size = Util.greaterOrEqualEntry(yslice.thickness, slice_height_entries)
show_xscrollbar = xpanel.isVisible
show_yscrollbar = ypanel.isVisible
self.scrolled_window = ScrolledWindow(master, ncols, nrows,
width=width, height=height,
world_region=world_region,
xview_regions=xview_regions,
yview_regions=yview_regions,
configure_func=self.resize,
expose_func=self.expose,
motion_func=self.motion,
leave_func=self.leave,
slice_configure_func=self.sliceResize,
slice_expose_func=self.sliceExpose,
slice_motion_func=self.sliceMotion,
slice_leave_func=self.leave,
view_set_func=self.viewSet,
key_func=self.keypress,
slice_key_func=self.sliceKeypress,
select_single_func=self.selectSingle,
select_multi_func=self.selectMulti,
drag_func=self.dragBox,
show_xslices=show_xslices,
show_yslices=show_yslices,
xslice_size=xslice_size,
yslice_size=yslice_size,
get_aspect_ratio = self.getAspectRatio,
get_geometry=self.getGeometry,
set_geometry=self.setGeometry,
has_value_axis=self.hasValueAxis,
show_xscrollbar=show_xscrollbar,
show_yscrollbar=show_yscrollbar)
self.scrolled_window.popup = self # needed for WindowBasic macros
for axisPanel in self.window.axisPanels[2:]:
self.createRegionSelector(axisPanel)
if (not self.hasValueAxis):
for slicePanel in self.window.slicePanels[2:]:
self.createSliceCanvas(slicePanel)
self.gridAll()
self.setWindowTitle()
#self.setHandlers()
#self.setHandlerBackground()
self.setViewWindowNames()
self.setMenuItems()
if (not self.hasValueAxis):
self.setSliceMenuItems()
self.menuPeak = None
self.firstPass = True
self.bind('<Configure>', self.getWindowLocation)
#self.bind('<FocusIn>', self.focusIn)
#self.bind('<Expose>', self.checkIconified)
self.bind('<ButtonPress-1>', self.unpostMenu)
self.scrolled_window.translateBind(button=2)
self.scrolled_window.zoomBind(button=2, state=shift_key_state)
self.scrolled_window.selectSingleBind(button=1)
self.scrolled_window.selectSingleBind(button=1, state=ctrl_key_state)
self.scrolled_window.selectMultiBind(button=1, state=shift_key_state)
self.scrolled_window.selectMultiBind(button=1, state=shift_key_state+ctrl_key_state)
self.scrolled_window.menuBind(button=3, menu_items=self.menu_items,
update_func=self.updateMenuState)
if (not self.hasValueAxis):
self.scrolled_window.sliceMenuBind(button=3, menu_items=self.slice_menu_items,
update_func=self.updateSliceMenuState)
self.setSpectrumSelector()
self.setStripsSelectorAfter()
#if (self.window.isIconified):
# self.after_idle(self.close)
Implementation.registerNotify(self.setWindowTitle, 'ccpnmr.Analysis.SpectrumWindow', 'setName')
Implementation.registerNotify(self.setWindowLocation, 'ccpnmr.Analysis.SpectrumWindow', 'setLocation')
Implementation.registerNotify(self.changedAxisTypeRegion, 'ccpnmr.Analysis.AxisType', 'setRegion')
Implementation.registerNotify(self.drawAll, 'ccpnmr.Analysis.AxisType', 'setPeakSize')
Implementation.registerNotify(self.changedBackgroundColor, 'ccpnmr.Analysis.SpectrumWindow', 'setBackground')
Implementation.registerNotify(self.changedAspectRatio, 'ccpnmr.Analysis.SpectrumWindow', 'setAspectRatio')
Implementation.registerNotify(self.changedSliceRange, 'ccpnmr.Analysis.SpectrumWindow', 'setSliceRange')
Implementation.registerNotify(self.changedIsIconified, 'ccpnmr.Analysis.SpectrumWindow', 'setIsIconified')
Implementation.registerNotify(self.changedAxisRegion, 'ccpnmr.Analysis.AxisRegion', 'setRegion')
Implementation.registerNotify(self.changedAxisSize, 'ccpnmr.Analysis.AxisRegion', 'setSize')
Implementation.registerNotify(self.setStripsSelectorAfter, 'ccpnmr.Analysis.AxisRegion', 'setIsActive')
for func in ('__init__', 'delete'):
Implementation.registerNotify(self.changedAxisRegions, 'ccpnmr.Analysis.AxisRegion', func)
Implementation.registerNotify(self.initSpectrumWindowView, 'ccpnmr.Analysis.SpectrumWindowView', '__init__')
Implementation.registerNotify(self.setSpectrumSelector, 'ccpnmr.Analysis.SpectrumWindowView', 'setIsInToolbar')
Implementation.registerNotify(self.changedSpectrumWindowView, 'ccpnmr.Analysis.SpectrumWindowView', 'setIsPosVisible')
Implementation.registerNotify(self.changedSpectrumWindowView, 'ccpnmr.Analysis.SpectrumWindowView', 'setIsNegVisible')
Implementation.registerNotify(self.changedSpectrumWindowViewSlice, 'ccpnmr.Analysis.SpectrumWindowView', 'setIsSliceVisible')
Implementation.registerNotify(self.deleteSpectrumWindowView, 'ccpnmr.Analysis.SpectrumWindowView', 'delete')
Implementation.registerNotify(self.changedPanelVisibility, 'ccpnmr.Analysis.AxisPanel', 'setIsVisible')
Implementation.registerNotify(self.initAxisPanel, 'ccpnmr.Analysis.AxisPanel', '__init__')
Implementation.registerNotify(self.deleteAxisPanel, 'ccpnmr.Analysis.AxisPanel', 'delete')
Implementation.registerNotify(self.createSliceCanvas, 'ccpnmr.Analysis.SlicePanel', '__init__')
Implementation.registerNotify(self.changedSliceVisibility, 'ccpnmr.Analysis.SlicePanel', 'setIsVisible')
Implementation.registerNotify(self.changedSliceThickness, 'ccpnmr.Analysis.SlicePanel', 'setThickness')
Implementation.registerNotify(self.changedSpectrum, 'ccp.Nmr.DataSource', 'setScale')
Implementation.registerNotify(self.setSpectrumSelector, 'ccp.Nmr.DataSource', 'setName')
Implementation.registerNotify(self.setSpectrumSelector, 'ccp.Nmr.Experiment', 'setName')
Implementation.registerNotify(self.changedPeakList, 'ccp.Nmr.PeakList', 'setPeakColor')
Implementation.registerNotify(self.changedPeakList, 'ccp.Nmr.PeakList', 'setPeakSymbol')
Implementation.registerNotify(self.setPeaksSelector, 'ccpnmr.Analysis.WindowPeakList', '__init__')
Implementation.registerNotify(self.setPeaksSelector, 'ccpnmr.Analysis.WindowPeakList', 'delete')
Implementation.registerNotify(self.changedWinPeakList, 'ccpnmr.Analysis.WindowPeakList', 'setIsSymbolDrawn')
Implementation.registerNotify(self.changedWinPeakList, 'ccpnmr.Analysis.WindowPeakList', 'setIsAnnotationDrawn')
Implementation.registerNotify(self.initPeak, 'ccp.Nmr.Peak', '__init__')
Implementation.registerNotify(self.deletePeak, 'ccp.Nmr.Peak', 'delete')
Implementation.registerNotify(self.changedPeak, 'ccp.Nmr.Peak', 'setAnnotation')
Implementation.registerNotify(self.changedPeakDim, 'ccp.Nmr.PeakDim', 'setPosition')
Implementation.registerNotify(self.changedPeakDim, 'ccp.Nmr.PeakDim', 'setAnnotation')
Implementation.registerNotify(self.changedMark, 'ccpnmr.Analysis.Mark', '')
Implementation.registerNotify(self.changedMark, 'ccpnmr.Analysis.MarkDim', '')
Implementation.registerNotify(self.changedMark, 'ccpnmr.Analysis.MarkDim', '__init__')
Implementation.registerNotify(self.changedMark, 'ccpnmr.Analysis.MarkDim', 'delete')
Implementation.registerNotify(self.changedRuler, 'ccpnmr.Analysis.Ruler', '')
Implementation.registerNotify(self.changedRuler, 'ccpnmr.Analysis.Ruler', '__init__')
Implementation.registerNotify(self.changedRuler, 'ccpnmr.Analysis.Ruler', 'delete')
Implementation.registerNotify(self.changedColor, 'ccpnmr.Analysis.Color', 'setR')
Implementation.registerNotify(self.changedColor, 'ccpnmr.Analysis.Color', 'setG')
Implementation.registerNotify(self.changedColor, 'ccpnmr.Analysis.Color', 'setB')
Implementation.registerNotify(self.changedColor, 'ccpnmr.Analysis.ColorScheme', 'setColorNames')
Implementation.registerNotify(self.changedReferencing, 'ccp.Nmr.ExpDimRef', '')
Implementation.registerNotify(self.changedReferencing, 'ccp.Nmr.DataDimRef', '')
Implementation.registerNotify(self.changedReferencing, 'ccp.Nmr.FreqDataDim', '')
for func in ('__init__', 'delete', 'setValue'):
for t in ('Int', 'Float', 'String', 'Boolean'):
clazz = 'memops.Implementation.AppData' + t
Implementation.registerNotify(self.changedAppData, clazz, func)
# following five functions just used to keep isIconified up-to-date
def open(self):
#print 'WindowPopup open'
self.window.isIconified = False
self.update_idletasks()
BasePopup.open(self)
def deiconify(self):
#print 'WindowPopup deiconify'
self.window.isIconified = False
BasePopup.deiconify(self)
def iconify(self):
#print 'WindowPopup iconify'
self.window.isIconified = True
BasePopup.iconify(self)
def close(self):
#print 'WindowPopup close'
self.window.isIconified = True
BasePopup.close(self)
def withdraw(self):
#print 'WindowPopup withdraw'
self.window.isIconified = True
BasePopup.withdraw(self)
"""
def checkIconified(self, *event):
# if you do this too early then window location is trampled when uniconified
# a bit of a pain because it leads to a flash of the window
if (self.firstPass):
self.firstPass = False
if (self.window.isIconified):
self.close()
"""
def changedIsIconified(self, window):
if (self.window == window):
if (window.isIconified):
self.close()
else:
self.open()
def getCenterCoords(self, *event):
popup = GetCenterCoordsPopup(self)
center = popup.center
region_number = popup.region_number
popup.destroy()
if (center):
(cx, cy) = center
(rx, ry) = region_number
xaxisPanel = self.window.axisPanels[0]
yaxisPanel = self.window.axisPanels[1]
(x0, x1) = xaxisPanel.axisRegions[rx].region
(y0, y1) = yaxisPanel.axisRegions[ry].region
tx = (cx - 0.5*(x0+x1)) / (x1 - x0)
ty = (cy - 0.5*(y0+y1)) / (y1 - y0)
if (xaxisPanel.axisUnit.isBackwards):
tx = - tx
if (yaxisPanel.axisUnit.isBackwards):
ty = - ty
canvas = self.scrolled_window.canvases[ry][rx]
self.scrolled_window.translate(canvas, tx, ty)
def setSpectrumSelector(self, *notifyObj):
spectra = []
colors = []
labels = []
views = []
refViews = list(self.window.spectrumWindowViews)
refViews.sort(self.compareViewOrder)
for view in refViews:
try:
# try needed for dodgy notifier for deleted spectrum - view still exists
spectrum = view.dataSource
###views.append(view) # moved by wb104 on 30 03 2005 to inside if statement below
# need below check because changing app date on delete calls this update before the view is removed
if spectrum and view.isInToolbar:
views.append(view)
colorName = Util.getSpectrumPosContourColor(spectrum)
scheme = self.window.root.findFirstColorScheme(name=colorName)
if scheme:
color = scheme.colors[int(len(scheme.colors)*0.8)]
specColor = hexRepr(color.r, color.g, color.b)
else:
specColor = 'grey83'
spectra.append( spectrum )
colors.append( specColor )
labels.append('%s:%s' % (spectrum.experiment.name,spectrum.name))
except:
pass
self.spectrumToggleSelector.update(objects=spectra,labels=labels,colors=colors)
n = 0
for view in views:
self.spectrumToggleSelector.setButtonState(n, view.isPosVisible)
n = n + 1
self.setPeaksSelector()
def setPeaksSelector(self, *notifyObj):
if self.window.isDeleted:
return
peakLists = []
colors = []
labels = []
views = []
winPeakLists = []
allViews = list(self.window.spectrumWindowViews)
allViews.sort(self.compareViewOrder)
for view in allViews:
try:
# try needed for dodgy notifier for deleted spectrum - view still exists
spectrum = view.dataSource
# need below check because changing app date on delete calls this update before the view is removed
if spectrum and view.isPosVisible and view.isInToolbar:
views.append( view )
if view.windowPeakLists:
colorName = Util.getSpectrumPosContourColor(spectrum)
scheme = self.window.root.findFirstColorScheme(name=colorName)
if scheme:
color = scheme.colors[int(len(scheme.colors)*0.8)]
specColor = hexRepr(color.r, color.g, color.b)
else:
specColor = 'grey83'
for winPeakList in view.windowPeakLists:
try:
peakList = winPeakList.peakList
except:
peakList = None
if not peakList or peakList.isDeleted:
continue
winPeakLists.append(winPeakList)
peakLists.append(peakList)
colors.append( specColor )
labels.append('%s:%s:%d' % (spectrum.experiment.name,spectrum.name,peakList.serial))
except:
pass
self.peaksToggleSelector.update(objects=peakLists,labels=labels,colors=colors)
n = 0
for winPeakList in winPeakLists:
self.peaksToggleSelector.setButtonState(n, winPeakList.isSymbolDrawn)
n += 1
def setStripsSelectorAfter(self, *notifyObj):
if self.waitStrips:
return
else:
self.waitStrips = 1
self.after_idle(self.setStripsSelector)
def setStripsSelector(self):
if self.window.isDeleted:
return
axisRegions = self.window.axisPanels[0].axisRegions
N = len(axisRegions)
if N == 0:
self.stripsToggleSelector.grid_forget()
elif N ==1:
self.stripsToggleSelector.update(objects=[axisRegions[0],],labels=['1',],colors=['#80A080',])
self.stripsToggleSelector.selectButton(0, doCallback=False)
else:
objects = ['all',]
labels = ['All',]
colors = ['#80A080',]
for i in range(N):
objects.append(axisRegions[i])
labels.append('%d' % (i+1))
colors.append('#80A080')
self.stripsToggleSelector.update(objects=objects,labels=labels,colors=colors)
for i in range(N):
axisRegion = axisRegions[i]
if axisRegion.isActive:
axisPanels = [panel for panel in axisRegion.axisPanel.spectrumWindow.axisPanels[2:] if not panel.isDeleted]
for axisPanel in axisPanels:
(r0, r1) = Util.checkSwapRegion(axisPanel.axisRegions[i].region, axisPanel.axisUnit)
axisPanel.region_selector.setViewRegion(r0, r1)
break
M = 0
I = 0
for i in range(N):
if axisRegions[i].isActive:
I = i
M += 1
if M == N:
for i in range(N):
self.stripsToggleSelector.selectButton(0, doCallback=False)
else:
self.stripsToggleSelector.selectButton(I+1, doCallback=False)
self.waitStrips = 0
def toggleSpectrum(self, spectrum):
self.parent.toggleSpectrum(self.window, spectrum=spectrum)
self.setPeaksSelector()
def togglePeaks(self, peakList):
self.parent.togglePeakList(self.window, peakList)
def toggleStrips(self, object):
axisRegions = list(self.window.axisPanels[0].axisRegions)
if object == 'all':
for axisRegion in axisRegions:
axisRegion.isActive = True
else:
for axisRegion in axisRegions:
axisRegion.isActive = False
axisRegion = object
axisRegion.isActive = True
col = axisRegions.index(axisRegion)
self.updateRegionSelectors(col)
def getActiveStrip(self):
axisRegions = self.window.axisPanels[0].axisRegions
for n in range(len(axisRegions)):
axisRegion = axisRegions[n]
if (axisRegion.isActive):
if (n == 0):
break
else:
return n
else:
return None
for m in range(1, len(axisRegions)):
axisRegion = axisRegions[m]
if (not axisRegion.isActive):
return n
return 'all'
def activateStrip(self, col):
#print 'activateStrip', col
axisRegions = self.window.axisPanels[0].axisRegions
N = len(axisRegions)
if col >= N:
col = 0
for i in range(N):
axisRegion = axisRegions[i]
if i == col:
axisRegion.isActive = True
else:
axisRegion.isActive = False
self.updateRegionSelectors(col)
def updateRegionSelectors(self, col):
for axisPanel in self.window.axisPanels[2:]:
axisRegion = axisPanel.axisRegions[col]
(r0, r1) = Util.checkSwapRegion(axisRegion.region, axisPanel.axisUnit)
axisPanel.region_selector.setViewRegion(r0, r1, do_callback=True)
def untoggleLabels(self, shownLabel):
self.waitResize = 1
for toggleLabel in self.toggleLabels:
if (toggleLabel is not shownLabel):
toggleLabel.arrowOff()
for widget in self.toggleWidgets[toggleLabel]:
widget.grid_forget()
self.update_idletasks()
self.waitResize = 0
def toggleContourFrame(self, isHidden):
self.waitResize = 1
if isHidden:
self.lowerFrame.grid_forget()
self.contourLabel.grid_forget()
self.contourRamp.grid_forget()
self.contourButton.grid_forget()
else:
self.contourLabel.grid (row = 0, column = 0,sticky=Tkinter.NW)
self.contourRamp.grid (row = 0, column = 1,sticky=Tkinter.NW)
self.contourButton.grid(row = 0, column = 2,sticky=Tkinter.NW)
self.lowerFrame.grid (row = 1, column = 0,sticky=Tkinter.EW)
self.untoggleLabels(self.contourToggleLabel)
def toggleSpectraFrame(self, isHidden):
self.waitResize = 1
if isHidden:
self.lowerFrame.grid_forget()
self.spectrumToggleSelector.grid_forget()
else:
self.spectrumToggleSelector.grid(row = 0, column = 0,sticky=Tkinter.NSEW)
self.lowerFrame.grid(row = 1, column = 0,sticky=Tkinter.EW)
self.untoggleLabels(self.spectraToggleLabel)
def togglePeaksFrame(self, isHidden):
self.waitResize = 1
if isHidden:
self.lowerFrame.grid_forget()
self.peaksToggleSelector.grid_forget()
self.peakListLabel.grid_forget()
else:
self.peakListLabel.grid(row = 0, column = 0,sticky=Tkinter.NSEW)
self.peaksToggleSelector.grid(row = 0, column = 1,sticky=Tkinter.NSEW)
self.lowerFrame.grid(row = 1, column = 0,sticky=Tkinter.EW)
self.untoggleLabels(self.peaksToggleLabel)
def toggleStripsFrame(self, isHidden):
self.waitResize = 1
if isHidden:
self.lowerFrame.grid_forget()
self.stripsToggleSelector .grid_forget()
self.stripsButtons.grid_forget()
self.stripsLabel.grid_forget()
else:
self.stripsLabel.grid(row = 0, column = 0,sticky=Tkinter.W)
self.stripsToggleSelector.grid(row = 0, column = 1,sticky=Tkinter.EW)
self.stripsButtons.grid(row = 0, column = 2,sticky=Tkinter.EW)
self.lowerFrame.grid(row = 1, column = 0,sticky=Tkinter.EW)
self.untoggleLabels(self.stripsToggleLabel)
def unpostMenu(self, *event):
self.scrolled_window.menu.unpost()
if (not self.hasValueAxis):
self.scrolled_window.sliceMenu.unpost()
def moveStripToWindow(self, sourceCol, window=None, targetCol=0):
if window is self.window:
self.shuffleAxisRegions(sourceCol=sourceCol, targetCol=targetCol)
return
strip = self.window.axisPanels[0].axisRegions[sourceCol]
if window:
popup = self.parent.getWindowPopup(window.name)
popup.open() # otherwise if window closed Python crashes
if targetCol >= len(window.axisPanels[0].axisRegions):
targetCol = len(window.axisPanels[0].axisRegions)
popup.addCol(col=targetCol)
else:
i = len(self.project.spectrumWindows)
name = 'window%s' % i
while self.project.findFirstSpectrumWindow(name = name):
i += 1
name = 'window%s' % i
axisTypes = []
for axisPanel in self.window.axisPanels:
axisTypes.append(axisPanel.axisType)
window = createSpectrumWindow(self.project, name, axisTypes, ncols=1, nrows=1)
if window is self.window:
if targetCol < sourceCol:
sourceCol += 1
for i in range(len(self.window.axisPanels)):
if sourceCol < len( self.window.axisPanels[i].axisRegions) \
and targetCol < len( window.axisPanels[i].axisRegions):
sourceStrip = self.window.axisPanels[i].axisRegions[sourceCol]
targetStrip = window.axisPanels[i].axisRegions[targetCol]
targetStrip.region = tuple(sourceStrip.region)
targetStrip.size = sourceStrip.size
self.deleteCol(col=sourceCol)
def getMoveStripItems(self, col):
items = [{ 'kind': 'command', 'label': 'New window', 'command': lambda event, s=col:self.moveStripToWindow(s) }]
windows = getEquivalentWindows(self.window)
for window in windows:
axisRegions = window.axisPanels[0].axisRegions
for i in range(len(axisRegions)+1):
if (window is self.window) and ( (i == col) or (i == len(axisRegions)) ):
continue
label = '%s strip %d' % (window.name,i+1)
item = { 'kind': 'command', 'label': label, 'command': lambda event, w=window, s=col, t=i: self.moveStripToWindow(s,w,t) }
items.append(item)
return items
# TBD: dangerous way this done here, using explicit indices into submenus
def updateMenuState(self):
event = self.scrolled_window.menu.menu_event
canvas = event.widget
(x, y, propX, propY) = self.scrolled_window.calcWorldCoord(canvas, event.x, event.y)
(row, col) = self.scrolled_window.getCanvasRowCol(canvas)
#print 'updateMenuState', row, col
xAxisRegion = self.window.axisPanels[0].axisRegions[col]
yAxisRegion = self.window.axisPanels[1].axisRegions[row]
# View option
if not self.hasValueAxis:
view_menu = self.scrolled_window.menu.submenuDict['View']
if self.window.spectrumWindowViews:
state = Tkinter.NORMAL
else:
state = Tkinter.DISABLED
view_menu.entryconfig(2, state=state)
# Strip option
strip_items = []
if not self.hasValueAxis:
if len(self.window.axisPanels[0].axisRegions) > 1:
move_strip_items = self.getMoveStripItems(col)
strip_items = [ \
{ 'kind': 'command', 'label': 'Add new strip','command': lambda event, col=col: self.addCol(col=col+1) },
{ 'kind': 'command', 'label': 'Remove strip', 'command': lambda event, col=col: self.deleteCol(col=col) },
{ 'kind': 'cascade', 'label': 'Change window','submenu': move_strip_items },
{ 'kind': 'command', 'label': 'Make active', 'command': lambda event, col=col: self.activateStrip(col) },
{ 'kind': 'command', 'label': 'Add horizontal separator', 'command': self.addRow },
]
else:
strip_items = [ \
{ 'kind': 'command', 'label': 'Add new strip', 'command': lambda event: self.addCol() },
{ 'kind': 'command', 'label': 'Add horizontal separator', 'command': self.addRow },
]
if self.scrolled_window.nrows > 1:
strip_items.append( { 'kind': 'command', 'label': 'Remove horizontal separator', 'command': lambda event: self.deleteRow() } )
stripMenu = self.scrolled_window.menu.submenuDict['Strip']
stripMenu.setMenuItems(strip_items)
# peak and assign options
if (not self.hasValueAxis):
position_region = self.findPositionRegion(x, y, col)
activeViews = self.getActiveSpectrumViews()
for view in activeViews:
peak = self.findNearbyViewPeak(view, position_region, xAxisRegion, yAxisRegion)
if (peak):
break
else:
peak = None
find_items = []
seqss_items = []
if peak:
label = 'Assign %s:%s:%s:%s' % (peak.peakList.dataSource.experiment.name,peak.peakList.dataSource.name, peak.peakList.serial, peak.serial)
state = Tkinter.NORMAL
i = 1
for peakDim in peak.peakDims:
expDimRef = peakDim.dataDim.expDim.expDimRefs[0]
isotopesCode = ''
for isotope in expDimRef.isotopeCodes:
isotopesCode = isotopesCode + isotope
text = 'F%d: %s %7.3f %s' % (i,isotopesCode,getPeakDimPosition(peakDim,toUnit=expDimRef.unit),expDimRef.unit)
find_items.append({'kind': 'command', 'label':text,
'command': lambda event, pd=peakDim: self.findClosePeaks(pd)})
i += 1
seqOffsets = []
N = len(peak.peakDims)
if N == 2:
seqOffsets = [(None, -1),(None,1)]
elif N == 3:
seqOffsets = [(None,-1,None),(None,1,None),(-1,None,None),(1,None,None)]
elif N == 4:
seqOffsets = [(-1,-1,None,None),(1,1,None,None),(None,-1,-1,None),(None,1,1,None)]
elif N == 5:
seqOffsets = [(-1,-1,None,None,None),(1,1,None,None,None),
(-1,-1,-1,None,None), (1,1,1,None,None)]
for seqOffset in seqOffsets:
text = []
f = 1
for j in seqOffset:
if j is None:
text.append('F%d 0' % (f) )
elif j > 0:
text.append('F%d +%d' % (f,j) )
else:
text.append('F%d %d' % (f,j) )
f += 1
seqss_items.append({'kind': 'command', 'label':','.join(text),
'command': lambda event, s=seqOffset: self.makeSeqSpinSystemConnections(s)})
else:
label = 'Assign peak'
state = Tkinter.DISABLED
self.menuPeak = peak
assn_menu = self.scrolled_window.menu.submenuDict['Assign']
assn_menu.entryconfig(0, state=state, label=label)
assn_menu.entryconfig(2, state=state)
assn_menu.entryconfig(5, state=state)
seqss_menu = assn_menu.submenuDict['Set sequential spin systems']
seqss_menu.setMenuItems(seqss_items)
peak_menu = self.scrolled_window.menu.submenuDict['Peak']
peak_menu.entryconfig(2, state=Tkinter.NORMAL)
peak_menu.entryconfig(3, state=state)
peak_menu.entryconfig(5, state=state)
peak_menu.entryconfig(7, state=state)
peak_menu.entryconfig(8, state=state)
peak_menu.entryconfig(9, state=state)
peak_menu.entryconfig(10, state=state)
peak_menu.entryconfig(13, state=state)
find_menu = peak_menu.submenuDict['Find close peaks']
find_menu.setMenuItems(find_items)
state = Tkinter.DISABLED
if peak:
for peakDim in peak.peakDims:
for contrib in peakDim.peakDimContribs:
if contrib.resonance.resonanceGroup:
state = Tkinter.NORMAL
break
else:
continue
break
assn_menu.entryconfig(3, state=state)
state = Tkinter.DISABLED
match_items = []
peakLists = self.getActivePeakLists()
if peakLists and self.parent.currentPeaks:
state = Tkinter.NORMAL
peak = self.parent.currentPeaks[0]
for peakList in peakLists:
spectrum = peakList.dataSource
specText = 'In %s:%s:%d' % (spectrum.experiment.name,spectrum.name,peakList.serial)
dim_items = []
# TBD: Automate this to give only options for non-aligned peakDims
for i in range(spectrum.numDim):
text = 'F%d' % (i+1)
dim_items.append({'kind': 'command', 'label':text,
'command': lambda event, p=self.parent.currentPeaks, i=i, pl=peakList: self.findPositionMatches(p,i,pl)})
match_items.append({'kind': 'cascade', 'label':specText, 'submenu': dim_items})
dim_items = []
for i in range(len(peak.peakDims)):
text = 'F%d' % (i+1)
dim_items.append({'kind': 'command', 'label':text,'command': lambda event, p=self.parent.currentPeaks, i=i: self.findPositionMatches(p,i)})
match_items.append({'kind': 'cascade', 'label':'In active spectra', 'submenu': dim_items})
match_menu = peak_menu.submenuDict['Match peaks']
match_menu.setMenuItems(match_items)
assn_menu.entryconfig(1, state=state)
assn_menu.entryconfig(2, state=state)
assn_menu.entryconfig(4, state=state)
peak_menu.entryconfig(0, state=state)
peak_menu.entryconfig(4, state=state)
peak_menu.entryconfig(6, state=state)
peak_menu.entryconfig(7, state=state)
peak_menu.entryconfig(9, state=state)
peak_menu.entryconfig(12, state=state)
state = Tkinter.DISABLED
if peak and self.parent.currentPeaks:
state = Tkinter.NORMAL
peak_menu.entryconfig(11, state=state)
# Navigate option
views = self.getActiveSpectrumViews()
goto_items = []
cursorPosition = self.findPosition(x,y,col,returnDict=False)
windowZplanes = findOrthogonalWindows(self.window, cursorPosition)
transposes = findWindowTransposes( self.window, cursorPosition)
if windowZplanes:
for (planeName, window, position) in windowZplanes:
goto_items.append({'kind': 'command',
'label': planeName,
'command': lambda event, window=window, position=position: self.gotoOrthogonalPlane(window, position)} )
if len(windowZplanes) > 1:
goto_items.append({'kind': 'command','label': 'All window positions',
'command': lambda event, wzps=windowZplanes: self.gotoOrthogonalAllPlanes(wzps)} )
if transposes:
if windowZplanes:
goto_items.append({ 'kind': 'separator'})
if len(transposes) > 1:
transpose_items = []
for label, position in transposes:
transpose_items.append({'kind': 'command', 'label': label,
'command': lambda event, w=self.window, pos=position, col=col: self.parent.gotoPosition(window_name=w.name, position=pos, col=col)})
goto_items.append({'kind': 'cascade', 'label':'Transpose', 'submenu': transpose_items})
else:
label, position = transposes[0]
goto_items.append({'kind': 'command', 'label': 'Transpose '+label,
'command': lambda event, w=self.window, pos=position, col=col: self.parent.gotoPosition(window_name=w.name, position=pos, col=col)})
goto_menu = self.scrolled_window.menu.submenuDict['Navigate']
goto_menu.setMenuItems(goto_items)
# mark & rulers options
mark_menu = self.scrolled_window.menu.submenuDict['Markers']
project = self.window.project
state = Tkinter.DISABLED
if project.marks:
state = Tkinter.NORMAL
mark_menu.entryconfig(3, state=state) # marks
state = Tkinter.DISABLED
if project.rulers:
state = Tkinter.NORMAL
mark_menu.entryconfig(4, state=state) # rulers
# macros options
argServer = self.parent.argumentServer
macro_menu = self.scrolled_window.menu.submenuDict['Macros']
macro_items = [{ 'kind': 'command', 'label': 'Reload macros', 'command': self.reloadMouseMacros, 'shortcut': 'R' }]
for macro in self.project.macros:
if Util.getIsMacroInMouseMenu(macro):
macro_items.append( {'kind': 'command', 'label': macro.name, 'command': lambda event, m=macro: Util.runMacro(m,argServer)} )
macro_menu.setMenuItems(macro_items)
state = Tkinter.DISABLED
if len(macro_items) > 1:
state = Tkinter.NORMAL
macro_menu.entryconfig(0, state=state)
self.setCurrentObjects(event)
self.parent.currentPeakLists = []
views = self.getActiveSpectrumViews()
for view in views:
for winPeakList in view.windowPeakLists:
if winPeakList.isSymbolDrawn:
try:
peakList = winPeakList.peakList
except:
peakList = None
if (peakList and not peakList.isDeleted):
self.parent.currentPeakLists.append(peakList)
self.parent.currentPosition = (x,y)
def setCurrentObjects(self, event):
canvas = event.widget
(row, col) = self.scrolled_window.getCanvasRowCol(canvas)
views = self.getActiveSpectrumViews()
self.parent.currentPeak = self.menuPeak
self.parent.currentWindow = self.window
self.parent.currentStrip = col
self.parent.currentWindowPopup = self
self.parent.currentSpectra = [view.dataSource for view in views]
self.parent.currentCanvas = canvas
self.parent.currentEvent = event
def reloadMouseMacros(self, *event):
for macro in self.project.macros:
if Util.getIsMacroInMouseMenu(macro):
Util.reloadMacro(macro, self.parent.argumentServer)
# TBD: more general
def setMenuItems(self):
zoom_items = [ \
{ 'kind': 'command', 'label': 'Out by 2', 'command': lambda event: self.zoom(event.widget, 2.0) },
{ 'kind': 'command', 'label': 'In by 2', 'command': lambda event: self.zoom(event.widget, 0.5) },
{ 'kind': 'command', 'label': 'Zoom to slected peaks', 'command': self.zoomToSelectedPeaks },
{ 'kind': 'command', 'label': 'Zoom to spin system peaks', 'command': self.zoomToSpinSystem },
]
mark_items = [ \
{ 'kind': 'command', 'label': 'Add Mark', 'command': self.createMark, 'shortcut': 'M' },
{ 'kind': 'command', 'label': 'Add Horizontal ruler', 'command': self.createHorizontalRuler, 'shortcut': 'H' },
{ 'kind': 'command', 'label': 'Add Vertical ruler', 'command': self.createVerticalRuler, 'shortcut': 'V' },
{ 'kind': 'command', 'label': 'Remove marks', 'command': self.clearMarks },
{ 'kind': 'command', 'label': 'Remove rulers', 'command': self.clearRulers },
]
strip_items = [ \
{ 'kind': 'command', 'label': 'Add new strip', 'command': lambda: self.addCol() },
{ 'kind': 'command', 'label': 'Add horizontal separator', 'command': self.addRow },
{ 'kind': 'command', 'label': 'Remove horizontal separator', 'command': lambda event: self.deleteRow() },
]
contour_items = []
if (not self.hasValueAxis):
find_items = [] # created properly when menu pops up
match_items = [] # created properly when menu pops up
macro_items = [] # created properly when menu pops up
seqss_items = [] # created properly when menu pops up
merit_items = []
merit_items.append({'kind': 'command', 'label':'0.0', 'command': lambda event, m=0.0: self.setPeakMerit(m)})
merit_items.append({'kind': 'command', 'label':'0.5', 'command': lambda event, m=0.5: self.setPeakMerit(m)})
merit_items.append({'kind': 'command', 'label':'1.0', 'command': lambda event, m=1.0: self.setPeakMerit(m)})
assn_items = [ \
{ 'kind': 'command', 'label': 'Assign peak', 'command': self.assignPeak },
{ 'kind': 'command', 'label': 'Propagate assignments', 'command': self.propagatePeakAssignments },
{ 'kind': 'command', 'label': 'Add to spin system', 'command': self.addPeakSpinSystem },
{ 'kind': 'command', 'label': 'Predict Spin System Type', 'command': self.predictSpinSystemType },
{ 'kind': 'command', 'label': 'Deassign selected peaks', 'command': self.clearPeakAssignments },
{ 'kind': 'cascade', 'label': 'Set sequential spin systems','submenu': seqss_items },
]
peak_items = [ \
{ 'kind': 'command', 'label': 'Selected peaks...', 'command': self.showSelectedPeaks },
{ 'kind': 'separator'},
{ 'kind': 'command', 'label': 'Add new peak', 'command': self.createPeak },
{ 'kind': 'command', 'label': 'Center z planes on peak', 'command': self.peakCenterOrthogonalPlanes },
{ 'kind': 'command', 'label': 'Delete selected peaks', 'command': self.deleteSelectedPeaks },
{ 'kind': 'cascade', 'label': 'Find close peaks', 'submenu': find_items },
{ 'kind': 'command', 'label': 'Make intermediate peak', 'command': self.makeIntermediatePeak },
{ 'kind': 'cascade', 'label': 'Match peaks', 'submenu': match_items },
{ 'kind': 'cascade', 'label': 'Set merit', 'submenu': merit_items },
{ 'kind': 'command', 'label': 'Show structure connections','command': self.showStructConnections },
{ 'kind': 'command', 'label': 'Unalias peak', 'command': self.unaliasPeak },
{ 'kind': 'command', 'label': 'Unaliasing propagate', 'command': self.propagatePeakUnaliasing },
{ 'kind': 'command', 'label': 'Zoom to slected peaks', 'command': self.zoomToSelectedPeaks },
{ 'kind': 'command', 'label': 'Zoom to spin system peaks', 'command': self.zoomToSpinSystem },
]
contour_items = [ \
{ 'kind': 'command', 'label': 'Up by 2', 'command': lambda event: self.changeScale(2.0) },
{ 'kind': 'command', 'label': 'Down by 2', 'command': lambda event: self.changeScale(0.5) },
{ 'kind': 'command', 'label': 'General...', 'command': lambda event: self.generalContours() },
]
#split_items = [ \
# { 'kind': 'command', 'label': 'Horizontally', 'command': self.splitWindowHorizontal },
# { 'kind': 'command', 'label': 'Vertically', 'command': self.splitWindowVertical },
#]
view_items = [ \
{ 'kind': 'cascade', 'label': 'Zoom', 'submenu' : zoom_items },
{ 'kind': 'command', 'label': 'Center here', 'command' : self.center },
{ 'kind': 'cascade', 'label': 'Contour levels', 'submenu' : contour_items },
{ 'kind': 'command', 'label': 'Window properties...', 'command' : self.editWindow },
]
goto_items = [] # created properly when menu pops up
if (not self.hasValueAxis):
self.menu_items = [ \
{ 'kind': 'cascade', 'label': 'Assign', 'submenu': assn_items },
{ 'kind': 'cascade', 'label': 'Peak', 'submenu': peak_items },
{ 'kind': 'cascade', 'label': 'View', 'submenu': view_items },
{ 'kind': 'cascade', 'label': 'Navigate', 'submenu': goto_items },
{ 'kind': 'cascade', 'label': 'Strip', 'submenu': strip_items },
{ 'kind': 'cascade', 'label': 'Markers', 'submenu': mark_items },
{ 'kind': 'separator'},
{ 'kind': 'cascade', 'label': 'Macros', 'submenu': macro_items },
#{ 'kind': 'cascade', 'label': 'Split screen', 'submenu': split_items },
]
else: # self.hasValueAxis
self.menu_items = [ \
{ 'kind': 'cascade', 'label': 'View', 'submenu': view_items },
{ 'kind': 'cascade', 'label': 'Navigate', 'submenu': goto_items },
{ 'kind': 'cascade', 'label': 'Strip', 'submenu': strip_items },
{ 'kind': 'cascade', 'label': 'Markers', 'submenu': mark_items },
{ 'kind': 'separator'},
{ 'kind': 'cascade', 'label': 'Macros', 'submenu': macro_items },
]
# TBD: dangerous way this done here, using explicit indices into submenus
def updateSliceMenuState(self):
slice_menu = self.scrolled_window.sliceMenu
views = self.getActiveSliceViews()
if (len(views) == 1):
state = Tkinter.NORMAL
else:
state = Tkinter.DISABLED
slice_menu.entryconfig(0, state=state) # reference
# TBD: more general
def setSliceMenuItems(self):
self.slice_menu_items = [ \
{ 'kind': 'command', 'label': 'Reference...', 'command' : self.reference },
]
def assignPeak(self, *event):
self.parent.assignmentPanel()
if (self.menuPeak):
self.parent.popups['edit_assignment'].update(self.menuPeak)
def unaliasPeak(self, event):
if (self.menuPeak):
self.parent.editPeakAliasing(peak=self.menuPeak)
def setPeakMerit(self, merit):
if (self.menuPeak):
self.menuPeak.figOfMerit = min(1,max(0,merit))
makePeakAnnotation(self.menuPeak)
def deleteSelectedPeaks(self, *event):
self.parent.queryDeleteSelected()
def showSelectedPeaks(self, *event):
self.parent.viewSelectedPeaks()
def findClosePeaks(self, peakDim):
project = peakDim.root
expDimRefs = peakDim.dataDim.expDim.expDimRefs
peaks = []
for experiment in project.nmrExperiments:
for spectrum in experiment.dataSources:
for peakList in spectrum.peakLists:
peaks.extend( findMatchingPeaks(peakList, peakDim) )
# tbd with isotope checks
peaks2 = []
ppm = peakDim.value
for peak in peaks:
minD = abs(peak.peakDims[0].value-ppm)
for peakDim2 in peak.peakDims[1:]:
d = abs(peakDim2.value-ppm)
if d < minD:
minD = d
peaks2.append( (minD, peak) )
peaks2.sort()
peaks = [x[1] for x in peaks2]
self.parent.viewPeaks(peaks)
def propagatePeakAssignments(self, event):
peaks = self.parent.currentPeaks
if peaks:
propagatePeakAssignments(peaks)
def propagatePeakUnaliasing(self, event):
refPeak = self.menuPeak
peaks = self.parent.currentPeaks
if refPeak and peaks:
message = 'Propagate unaliasing from peak\nto all selected peaks?\n'
i = 0
for peakDim in refPeak.peakDims:
i += 1
message += 'Dimension %d: Num aliasing %d\n(Ref peak position %f)\n' % (i,peakDim.numAliasing, peakDim.value)
if showOkCancel('Confirm',message):
propagatePeakUnaliasing(refPeak, peaks)
def addPeakSpinSystem(self, event):
peaks = self.parent.currentPeaks
if peaks:
addPeakResonancesToSpinSystem(peaks)
def clearPeakAssignments(self, event):
peaks = self.parent.currentPeaks
if peaks:
if showOkCancel('Warning','Clear assignments for %d selected peaks?' % len(peaks)):
removePeaksAssignment(peaks)
def createMark(self, event):
self.doCreateMark(event.widget, event.x, event.y)
def createHorizontalRuler(self, event):
self.doCreateHorizontalRuler(event.widget, event.x, event.y)
def createVerticalRuler(self, event):
self.doCreateVerticalRuler(event.widget, event.x, event.y)
def createPeak(self, event):
canvas = event.widget
(a, b, x, y) = self.scrolled_window.calcWorldCoord(canvas, event.x, event.y)
(row, col) = self.scrolled_window.getCanvasRowCol(canvas)
self.createNewPeak(a, b, col)
def clearMarks(self, *event):
removeMarks(self.window.project, removeAll=True)
def clearRulers(self, *event):
removeRulers(self.window.project, removeAll=True)
def changeScale(self, factor):
views = self.getActiveSpectrumViews()
for view in views:
spectrum = view.dataSource
changeSpectrumContourLevels(spectrum, factor)
def generalContours(self):
views = self.getActiveSpectrumViews()
if (views):
spectrum = views[0].dataSource
else:
spectrum = None
self.parent.editContourLevels(spectrum)
def center(self, event):
self.centerAtLocation(event.widget, event.x, event.y)
def centerAtLocation(self, canvas, x, y):
(a, b, s, t) = self.scrolled_window.calcWorldCoord(canvas, x, y)
#print 'center', a, b, s, t
s = s - 0.5
if (not self.hasValueAxis):
t = t - 0.5
else:
t = 0
#self.scrolled_window.translate(canvas, s, t)
self.translate(canvas, s, t)
def translate(self, canvas, sx, sy):
#f = 0.5
#self.scrolled_window.translate(canvas, f*sx, f*sy)
self.scrolled_window.translate(canvas, sx, sy)
def zoom(self, canvas, scale):
self.scrolled_window.zoom(canvas, scale)
def reference(self, event):
views = self.getActiveSpectrumViews()
if (len(views) != 1):
return
view = views[0]
slice = event.widget
if (slice.orient == Tkinter.HORIZONTAL):
w = slice.slice_width
x = event.x
s = (x + 0.5) / w
axisPanel = self.window.axisPanels[0]
else:
h = slice.slice_height
y = h - 1 - event.y
s = (y + 0.5) / h
axisPanel = self.window.axisPanels[1]
axisMapping = view.findFirstAxisMapping(label=axisPanel.label)
if (not axisMapping):
return
dataDim = axisMapping.dataDim
(t0, t1) = slice.view_region
t = t0 * (1 - s) + t1 * s
t = Util.convertPosition(t, dataDim.dataDimRefs[0], fromUnit=axisPanel.axisUnit.unit)
popup = SetReferencePopup(self, dataDim, t)
popup.destroy()
def editWindow(self, *event):
self.parent.editWindow(self.window)
def isInAllowedRegion(self, dataDim, label, region):
if label in ('x', 'y'):
r0 = r1 = region
else:
(r0, r1) = region
dataDimRef = dataDim.dataDimRefs[0]
expDimRef = dataDimRef.expDimRef
minAliasedFreq = expDimRef.minAliasedFreq
maxAliasedFreq = expDimRef.maxAliasedFreq
if (minAliasedFreq is None):
minFreq = Util.convertPosition(1.0, dataDimRef, toUnit='ppm')
else:
minFreq = minAliasedFreq
if r0 < minFreq:
return False
if (maxAliasedFreq is None):
maxFreq = Util.convertPosition(dataDim.numPoints, dataDimRef, toUnit='ppm')
else:
maxFreq = maxAliasedFreq
if r1 > maxFreq:
return False
return True
def findNearbyViewPeak(self, view, position_region, xAxisRegion, yAxisRegion):
spectrum = view.dataSource
peakList = Util.getSpectrumActivePeakList(spectrum)
if (not peakList):
return None
winPeakList = view.findFirstWindowPeakList(peakList=peakList)
if (not winPeakList):
return None
if not winPeakList.isSymbolDrawn:
return None
(xscale, yscale) = self.getPeakScale(view, xAxisRegion, yAxisRegion)
spectrum_region = spectrum.numDim * [0]
for axisMapping in view.axisMappings:
dataDim = axisMapping.dataDim
dim = axisMapping.dim - 1
label = axisMapping.label
if (not self.isInAllowedRegion(dataDim, label, position_region[label])):
return None
if (label == 'x'):
xdim = dim
elif (label == 'y'):
ydim = dim
axisPanel = self.window.findFirstAxisPanel(label=label)
spectrum_region[dim] = self.convertPositionRegion(position_region[label],
axisPanel, dataDim)
#print 'findNearbyViewPeak', spectrum.name, spectrum_region
peak = self.findNearbyPeak(peakList, spectrum_region, xdim, ydim, xscale, yscale)
return peak
def selectSingle(self, canvas, a, b, x, y, button = 1,
state = no_key_state, newSelection = True):
if (button != 1):
return
# TBD: something
if (self.hasValueAxis):
return
self.parent.startSelection()
if (newSelection):
self.parent.clearSelected()
(row, col) = self.scrolled_window.getCanvasRowCol(canvas)
if (state != ctrl_key_state):
xAxisRegion = self.window.axisPanels[0].axisRegions[col]
yAxisRegion = self.window.axisPanels[1].axisRegions[row]
position_region = self.findPositionRegion(a, b, col)
#print 'selectSingle1', position_region
activeViews = self.getActiveSpectrumViews()
for view in activeViews:
peak = self.findNearbyViewPeak(view, position_region, xAxisRegion, yAxisRegion)
if (peak):
if (not newSelection and self.parent.isSelected(peak)):
removePeakFromSelected(peak, self.parent)
else:
addPeakToSelected(peak, parent=self.parent)
else:
self.createNewPeak(a, b, col)
self.parent.endSelection()
self.drawCanvas(canvas)
def createNewPeak(self, a, b, n):
position = self.findPosition(a, b, n)
activeViews = self.getActiveSpectrumViews()
for view in activeViews:
spectrum = view.dataSource
peakList = Util.getSpectrumActivePeakList(spectrum)
if (not peakList):
continue
(spectrum_position, spectrum_tile) = self.determinePosition(view, position)
#print 'createNewPeak', position, spectrum_position, spectrum_tile
addPeak(peakList, position=spectrum_position, tile=spectrum_tile,
parent=self.parent)
def examineRegion(self, canvas, a0, b0, a1, b1, x0, y0, x1, y1, state=no_key_state):
# TBD: do more
#print 'examineRegion1', a0, b0, a1, b1, x0, y0, x1, y1
if (self.hasValueAxis):
return
(row, col) = self.scrolled_window.getCanvasRowCol(canvas)
region = self.findRegion(min(a0,a1), min(b0,b1), max(a0,a1), max(b0,b1), n=col)
#print 'examineRegion2', region
if (state == shift_key_state):
# TBD: check more, i.e. not just peaks
views = self.getActiveSpectrumViews()
for view in views:
spectrum = view.dataSource
spectrum_region = spectrum.numDim * [0]
for axisMapping in view.axisMappings:
dim = axisMapping.dataDim.dim - 1
label = axisMapping.label
spectrum_region[dim] = region[label]
peakList = Util.getSpectrumActivePeakList(spectrum)
if (peakList):
winPeakList = view.findFirstWindowPeakList(peakList=peakList)
if (winPeakList and winPeakList.isSymbolDrawn):
peakLists = [ peakList ]
searchPeaks(peakLists, region=spectrum_region, parent=self.parent)
elif (state == (shift_key_state + ctrl_key_state)):
params = getPeakFindParams(self.window.project)
thickness = params['thickness']
views = self.getActiveSpectrumViews()
for view in views:
spectrum = view.dataSource
spectrum_region = spectrum.numDim * [0]
spectrum_thickness = spectrum.numDim * [0]
peakList = Util.getSpectrumActivePeakList(spectrum)
if (not peakList):
continue
winPeakList = view.findFirstWindowPeakList(peakList=peakList)
if (not winPeakList):
continue
if not winPeakList.isSymbolDrawn:
continue
for axisMapping in view.axisMappings:
dim = axisMapping.dataDim.dim - 1
label = axisMapping.label
if (label in ('x', 'y')):
t = 0
else:
t = thickness
spectrum_region[dim] = region[label]
spectrum_thickness[dim] = t
findPeaks(peakList, region=spectrum_region, parent=self.parent,
thickness=spectrum_thickness)
# TBD: why was below here?
#canvas.handler.mapRanges(x0, y0, x1, y1, a0, b0, a1, b1)
# TBD: below might not be needed now because parent redraws all
# but clearXor seems necessary so leave both for now
#self.drawCanvas(canvas)
canvas.handler.clearXor()
def selectMulti(self, canvas, a0, b0, a1, b1, x0, y0, x1, y1,
button = 1, state = no_key_state):
if (self.hasValueAxis):
return
self.parent.startSelection()
if ((x0 == x1) and (y0 == y1)):
self.selectSingle(canvas, a0, b0, x0, y0, newSelection=False)
else:
self.examineRegion(canvas, a0, b0, a1, b1, x0, y0, x1, y1, state=state)
self.parent.endSelection(redraw=True)
self.drawCanvas(canvas)
def dragBox(self, canvas, a0, b0, a1, b1, x0, y0, x1, y1,
button = 1, state = no_key_state):
if (self.hasValueAxis):
return
#print 'dragBox', a0, b0, a1, b1, x0, y0, x1, y1
canvas.handler.makeCurrent()
canvas.handler.mapRanges(x0, y0, x1, y1, a0, b0, a1, b1)
# TBD: more general color
color = (0.0, 0.0, 1.0)
canvas.handler.setColor(color)
canvas.handler.drawXorBox(a0, b0, a1, b1)
# TBD: checks in "changed" functions below are not very clever
# (or very useful) but at some point something better could perhaps be done
def changedSpectrum(self, spectrum):
if isSpectrumInWindow(self.window, spectrum):
self.drawAll()
def changedPeakList(self, peakList):
if isSpectrumInWindow(self.window, peakList.dataSource):
self.drawAll()
def changedWinPeakList(self, winPeakList):
if (self.window == winPeakList.spectrumWindowView.spectrumWindow):
self.setPeaksSelector()
self.drawAll()
def changedPeak(self, peak):
if isSpectrumInWindow(self.window, peak.peakList.dataSource):
self.drawAll()
def changedPeakDim(self, peakDim):
if isSpectrumInWindow(self.window, peakDim.peak.peakList.dataSource):
self.drawAll()
def changedMark(self, *markOrMarkDim):
#self.after_idle(self.drawAll)
self.drawAll()
def changedRuler(self, *ruler):
#self.after_idle(self.drawAll)
self.drawAll()
def changedAppData(self, appData):
if (appData.application != self.window.project.application.name):
return
keyword = appData.keyword
if (keyword not in ('maxMarks', 'maxRulers',
'contourScale', 'contourLevel',
'posContourColor', 'negContourColor',
'sliceColor', 'isSpectrumBoxShown',
'color', 'symbol', 'order',
'peakDrawMethod', 'peakPixelSize',
'peakIntensityScale', 'peakVolumeScale')):
return
if (keyword == 'order'):
self.setSpectrumSelector()
return
if (keyword == 'maxMarks'):
removeMarks(self.window.project)
elif (keyword == 'maxRulers'):
removeRulers(self.window.project)
self.drawAll()
def changedReferencing(self, *extra):
self.setMinThickness()
self.updateOrthogonalWorlds()
self.drawAll()
def changedColor(self, *color):
self.setHandlerBackground()
#self.after_idle(self.drawAll)
self.drawAll()
def setViewWindowNames(self):
self.setSpectrumSelector()
for view in self.window.spectrumWindowViews:
self.setViewWindowName(view)
def setViewWindowName(self, spectrumWindowView):
# this set only so that deletion has something to check
if (spectrumWindowView.spectrumWindow == self.window):
spectrumWindowView.window_name = self.window.name
def initSpectrumWindowView(self, spectrumWindowView):
if (not spectrumWindowView.spectrumWindow == self.window):
return
self.setViewWindowName(spectrumWindowView)
self.after_idle(self.setMinThickness)
self.after_idle(lambda spectrumWindowView=spectrumWindowView: \
self.changedSpectrumWindowView(spectrumWindowView))
self.after_idle(self.updateOrthogonalWorlds)
def setMinThickness(self):
for axisPanel in self.window.axisPanels[2:]:
if (hasattr(axisPanel, 'region_selector')):
min_thickness = self.minAxisPanelThickness(axisPanel)
axisPanel.region_selector.setMinThickness(min_thickness)
def deleteSpectrumWindowView(self, spectrumWindowView):
#print 'WindowPopup1: deleteSpectrumWindowView', self.window.name, self.window.spectrumWindowViews, spectrumWindowView
# links of spectrumWindowView cut when deleted so use window_name
if hasattr(spectrumWindowView, 'window_name') and (spectrumWindowView.window_name == self.window.name):
#print 'WindowPopup3: deleteSpectrumWindowView', self.window.name
# check that window itself not being deleted
# TBD: change when API code is changed to drop first condition
if (not hasattr(self.window, 'deleted') or not self.window.deleted):
#print 'WindowPopup4: deleteSpectrumWindowView', self.window.name
self.after_idle(self.drawAll)
self.after_idle(self.setMinThickness)
#print 'WindowPopup2: deleteSpectrumWindowView', self.window.name
def changedSpectrumWindowView(self, spectrumWindowView):
if (spectrumWindowView.spectrumWindow == self.window):
self.drawAll()
def changedSpectrumWindowViewSlice(self, spectrumWindowView):
if (spectrumWindowView.spectrumWindow == self.window):
self.drawAllSlices()
def changedBackgroundColor(self, window):
if (window != self.window):
return
self.setHandlerBackground()
self.drawAll()
def changedAxisTypeRegion(self, *axisType):
world_region = self.getWorldRegion()
xview_regions = self.getXviewRegions(world_region.x_region)
yview_regions = self.getYviewRegions(world_region.y_region)
self.scrolled_window.setWorldRegion(world_region, xview_regions, yview_regions)
self.drawAll()
def changedViewRegion(self, axisRegion):
# TBD: not sure if below is good enough
panel = axisRegion.axisPanel
#print 'changedViewRegion', panel.label, axisRegion.region, panel.spectrumWindow.name, self.window.name
if (panel.spectrumWindow == self.window):
world_region = self.getWorldRegion()
#print 'changedViewRegion0', self.window.name, axisRegion.region
view_region = Util.checkSwapRegion(axisRegion.region, panel.axisUnit)
#print 'changedViewRegion1', self.window.name, view_region, axisRegion.region
axisRegions = list(panel.axisRegions)
n = axisRegions.index(axisRegion)
#print 'changedViewRegion2', self.window.name, n, panel.label
if (panel.label == 'x'):
Util.fitViewInWorld(view_region, world_region.x_region)
#self.scrolled_window.setXviewRegion(view_region, n)
(a0, a1) = view_region
self.scrolled_window.setXviewRegion(Region1D(a0, a1), n)
self.drawCol(n)
else:
Util.fitViewInWorld(view_region, world_region.y_region)
#self.scrolled_window.setYviewRegion(view_region, n)
(b0, b1) = view_region
self.scrolled_window.setYviewRegion(Region1D(b0, b1), n)
self.drawRow(n)
def changedAxisSize(self, axisRegion):
panel = axisRegion.axisPanel
label = panel.label
if (label not in ('x', 'y')):
return
(w, h, x, y) = self.getGeometry()
size = axisRegion.size
if (panel.spectrumWindow == self.window):
if (label == 'x'):
col = list(panel.axisRegions).index(axisRegion)
ww = self.scrolled_window.canvases[0][col].winfo_width()
#self.scrolled_window.zeroColWeights(col=col)
#self.scrolled_window.gridAll(col=col)
#self.scrolled_window.zeroWeights(col=col)
#self.setGeometry(w+size-ww, h, x, y)
#for j in range(self.scrolled_window.nrows):
# self.scrolled_window.canvases[j][col].config(width=size)
#self.scrolled_window.canvases[0][col].config(width=size)
#self.after_idle(self.scrolled_window.oneColWeights)
#self.after_idle(self.scrolled_window.gridAll)
#print 'changedAxisSize1', list(panel.axisRegions).index(axisRegion), w, ww, size, w+size-ww
elif (label == 'y'):
row = list(panel.axisRegions).index(axisRegion)
hh = self.scrolled_window.canvases[row][0].winfo_height()
#self.scrolled_window.zeroRowWeights(row=row)
#self.scrolled_window.gridAll(row=row)
#self.scrolled_window.zeroWeights(row=row)
#self.setGeometry(w, h+size-hh, x, y)
#for i in range(self.scrolled_window.ncols):
# self.scrolled_window.canvases[row][i].config(height=size)
#self.scrolled_window.canvases[row][0].config(height=size)
#self.after_idle(self.scrolled_window.oneRowWeights)
#self.after_idle(self.scrolled_window.gridAll)
#print 'changedAxisSize2', list(panel.axisRegions).index(axisRegion), h, hh, size, h+size-hh
#self.drawAll()
def changedOrthogonalRegion(self, axisRegion):
#print 'changedOrthogonalRegion'
axisPanel = axisRegion.axisPanel
if (axisPanel.spectrumWindow == self.window):
self.drawAll()
axisRegions = list(axisPanel.axisRegions)
n = axisRegions.index(axisRegion)
# check if corresponding x axis region is active, if so change selector
if len(axisRegions) == 1:
self.window.axisPanels[0].axisRegions[n].isActive = True
if (self.window.axisPanels[0].axisRegions[n].isActive):
(r0, r1) = Util.checkSwapRegion(axisRegion.region, axisPanel.axisUnit)
axisPanel.region_selector.setViewRegion(r0, r1, do_callback=True)
def changedAxisRegion(self, axisRegion):
axisPanel = axisRegion.axisPanel
#print 'WindowPopup.changedAxisRegion', axisPanel.label, axisRegion.region, list(axisPanel.axisRegions).index(axisRegion)
if (axisPanel.spectrumWindow != self.window):
return
if (axisPanel.label in ('x', 'y')):
self.changedViewRegion(axisRegion)
else:
self.changedOrthogonalRegion(axisRegion)
# some axisRegion has been created or deleted
def changedAxisRegions(self, axisRegion):
axisPanel = axisRegion.axisPanel
window = axisPanel.spectrumWindow
if (window != self.window):
return
self.setStripsSelectorAfter()
if (axisPanel.label in ('x', 'y')):
return
def changedPanelVisibility(self, panel):
if (panel.spectrumWindow == self.window):
if (panel.label in ('x', 'y')):
#print 'changedPanel', panel.label
if (panel.label == 'x'):
self.scrolled_window.setIsShownXScrollbar(panel.isVisible)
else: # (panel.label == 'y')
self.scrolled_window.setIsShownYScrollbar(panel.isVisible)
else:
self.gridAll()
def changedSliceVisibility(self, panel):
if (panel.spectrumWindow == self.window):
if (panel.label == 'x'):
self.scrolled_window.setIsShownXSlice(panel.isVisible)
elif (panel.label == 'y'):
self.scrolled_window.setIsShownYSlice(panel.isVisible)
else:
self.gridAll()
if (panel.isVisible):
self.drawAllSlices()
def changedSliceThickness(self, panel):
if (panel.spectrumWindow == self.window):
if (panel.label == 'x'):
t = Util.greaterOrEqualEntry(panel.thickness, slice_height_entries)
self.scrolled_window.setSizeXSlice(t)
elif (panel.label == 'y'):
t = Util.greaterOrEqualEntry(panel.thickness, slice_height_entries)
self.scrolled_window.setSizeYSlice(t)
#draw automatically happens
if (panel.isVisible):
self.drawAllSlices()
def minAxisPanelThickness(self, axisPanel):
label = axisPanel.label
unit = axisPanel.axisUnit.unit
min_thickness = None
for view in self.window.spectrumWindowViews:
axisMapping = view.findFirstAxisMapping(label=label)
if (axisMapping):
t = Util.convertPosition(1.0, axisMapping.dataDim.dataDimRefs[0],
toUnit=unit, relative=True)
t = abs(t)
if min_thickness is None:
min_thickness = t
else:
min_thickness = min(min_thickness, t)
return min_thickness
def getOrthogonalWorldRegion(self, axisPanel):
# TBD: some assumptions in here that working with ppm...
axisType = axisPanel.axisType
label = axisPanel.label
possViews = self.window.spectrumWindowViews
views = []
# try to protect against deleted or messed up views
for view in possViews:
if not view.isDeleted:
try:
axisMapping = view.findFirstAxisMapping(label=label)
if axisMapping:
views.append(view)
except:
pass
if not views:
# if no views just use the default axisType world region
region = Util.checkSwapRegion(axisType.region, axisType.axisUnits[0])
return region
r0 = None
r1 = None
for view in views:
axisMapping = view.findFirstAxisMapping(label=label)
dataDim = axisMapping.dataDim
dataDimRef = dataDim.dataDimRefs[0]
expDimRef = dataDimRef.expDimRef
minAliasedFreq = expDimRef.minAliasedFreq
if minAliasedFreq is None:
minAliasedFreq = Util.convertPosition(float(dataDim.numPoints), dataDimRef, toUnit=axisType.axisUnits[0].unit)
if r0 is None:
r0 = minAliasedFreq
else:
r0 = min(r0, minAliasedFreq)
maxAliasedFreq = expDimRef.maxAliasedFreq
if maxAliasedFreq is None:
maxAliasedFreq = Util.convertPosition(1.0, dataDimRef, toUnit=axisType.axisUnits[0].unit)
if r1 is None:
r1 = maxAliasedFreq
else:
r1 = max(r1, maxAliasedFreq)
(r0, r1) = Util.checkSwapRegion((r0, r1), axisType.axisUnits[0])
return Region1D(r0, r1)
def updateOrthogonalWorlds(self):
for axisPanel in self.window.axisPanels[2:]:
world_region = self.getOrthogonalWorldRegion(axisPanel)
axisPanel.region_selector.setWorldRegion(world_region)
def createRegionSelector(self, axisPanel):
if (axisPanel.spectrumWindow != self.window):
return
self.deleteRegionSelector(axisPanel)
master = self.widget_parent
axisType = axisPanel.axisType
label = axisType.name
callback = lambda view_region, axisPanel=axisPanel: \
self.regionSelectorCallback(view_region, axisPanel)
#(r0, r1) = Util.checkSwapRegion(axisType.region, axisType.axisUnits[0])
#world_region = Region1D(r0, r1)
(w0, w1) = world_region = self.getOrthogonalWorldRegion(axisPanel)
(v0, v1) = Util.checkSwapRegion(axisPanel.axisRegions[0].region, axisPanel.axisUnit)
if (w0 < w1):
if v0 < w0:
d = v1 - v0
v0 = w0
v1 = min(v0+d, w1)
elif v1 > w1:
d = v1 - v0
v1 = w1
v0 = max(v1-d, w0)
else:
if v0 > w0:
d = v1 - v0
v0 = w0
v1 = max(v0+d, w1)
elif v1 < w1:
d = v1 - v0
v1 = w1
v0 = min(v1-d, w0)
view_region = Region1D(v0, v1)
min_thickness = self.minAxisPanelThickness(axisPanel)
#print 'createRegionSelector', label, world_region, view_region
axisPanel.region_selector = RegionSelector(master, label=label,
callback=callback, text_decimals=axisType.numDecimals,
world_region=world_region, view_region=view_region,
min_thickness=min_thickness)
def deleteRegionSelector(self, axisPanel):
if (hasattr(axisPanel, 'region_selector')):
axisPanel.region_selector.destroy()
del axisPanel.region_selector
def createSliceCanvas(self, slicePanel):
if (slicePanel.spectrumWindow != self.window):
return
self.deleteSliceCanvas(slicePanel)
# TBD: more
def deleteSliceCanvas(self, slicePanel):
if (hasattr(slicePanel, 'slice_canvas')):
slicePanel.slice_canvas.destroy()
del slicePanel.slice_canvas
def gridAll(self):
row = 1
#self.scrolledFrame.grid(row=row, column=0, sticky=Tkinter.EW)
row = row + 1
self.scrolled_window.grid(row=row, column=0, sticky=Tkinter.NSEW)
row = row + 1
for axisPanel in self.window.axisPanels[2:]:
if (axisPanel.isVisible):
axisPanel.region_selector.grid(row=row, column=0, sticky=Tkinter.EW)
row = row + 1
else:
axisPanel.region_selector.grid_forget()
# TBD: uncomment this (after modifying)
#for slicePanel in self.window.slicePanels[2:]:
# if (slicePanel.isVisible):
# slicePanel.region_selector.grid(row=row, column=0, sticky=Tkinter.EW)
# row = row + 1
# else:
# slicePanel.region_selector.grid_forget()
def regionSelectorCallback(self, view_region, axisPanel):
if (not hasattr(axisPanel, 'region_selector')):
return
#print 'regionSelectorCallback1', view_region
view_region = Util.checkSwapRegion(view_region, axisPanel.axisUnit)
#print 'regionSelectorCallback2', view_region
axisRegions = axisPanel.axisRegions
xaxisRegions = self.window.axisPanels[0].axisRegions
if len(xaxisRegions) == 1:
xaxisRegions[0].isActive = True
for n in range(len(xaxisRegions)):
if (xaxisRegions[n].isActive):
try:
axisRegions[n].region = view_region
except:
pass # can fail when orthogonal axis being created
#self.drawAll()
def destroy(self):
Implementation.unregisterNotify(self.setWindowTitle, 'ccpnmr.Analysis.SpectrumWindow', 'setName')
Implementation.unregisterNotify(self.setWindowLocation, 'ccpnmr.Analysis.SpectrumWindow', 'setLocation')
Implementation.unregisterNotify(self.changedAxisTypeRegion, 'ccpnmr.Analysis.AxisType', 'setRegion')
Implementation.unregisterNotify(self.drawAll, 'ccpnmr.Analysis.AxisType', 'setPeakSize')
Implementation.unregisterNotify(self.changedBackgroundColor, 'ccpnmr.Analysis.SpectrumWindow', 'setBackground')
Implementation.unregisterNotify(self.changedAspectRatio, 'ccpnmr.Analysis.SpectrumWindow', 'setAspectRatio')
Implementation.unregisterNotify(self.changedSliceRange, 'ccpnmr.Analysis.SpectrumWindow', 'setSliceRange')
Implementation.unregisterNotify(self.changedIsIconified, 'ccpnmr.Analysis.SpectrumWindow', 'setIsIconified')
Implementation.unregisterNotify(self.changedAxisRegion, 'ccpnmr.Analysis.AxisRegion', 'setRegion')
Implementation.unregisterNotify(self.setStripsSelectorAfter, 'ccpnmr.Analysis.AxisRegion', 'setIsActive')
for func in ('__init__', 'delete'):
Implementation.unregisterNotify(self.changedAxisRegions, 'ccpnmr.Analysis.AxisRegion', func)
Implementation.unregisterNotify(self.changedAxisSize, 'ccpnmr.Analysis.AxisRegion', 'setSize')
Implementation.unregisterNotify(self.initSpectrumWindowView, 'ccpnmr.Analysis.SpectrumWindowView', '__init__')
Implementation.unregisterNotify(self.setSpectrumSelector, 'ccpnmr.Analysis.SpectrumWindowView', 'setIsInToolbar')
Implementation.unregisterNotify(self.changedSpectrumWindowView, 'ccpnmr.Analysis.SpectrumWindowView', 'setIsPosVisible')
Implementation.unregisterNotify(self.changedSpectrumWindowView, 'ccpnmr.Analysis.SpectrumWindowView', 'setIsNegVisible')
Implementation.unregisterNotify(self.changedSpectrumWindowViewSlice, 'ccpnmr.Analysis.SpectrumWindowView', 'setIsSliceVisible')
Implementation.unregisterNotify(self.deleteSpectrumWindowView, 'ccpnmr.Analysis.SpectrumWindowView', 'delete')
Implementation.unregisterNotify(self.changedPanelVisibility, 'ccpnmr.Analysis.AxisPanel', 'setIsVisible')
Implementation.unregisterNotify(self.initAxisPanel, 'ccpnmr.Analysis.AxisPanel', '__init__')
Implementation.unregisterNotify(self.deleteAxisPanel, 'ccpnmr.Analysis.AxisPanel', 'delete')
Implementation.unregisterNotify(self.createSliceCanvas, 'ccpnmr.Analysis.SlicePanel', '__init__')
Implementation.unregisterNotify(self.changedSliceVisibility, 'ccpnmr.Analysis.SlicePanel', 'setIsVisible')
Implementation.unregisterNotify(self.changedSliceThickness, 'ccpnmr.Analysis.SlicePanel', 'setThickness')
Implementation.unregisterNotify(self.changedSpectrum, 'ccp.Nmr.DataSource', 'setScale')
Implementation.unregisterNotify(self.setSpectrumSelector, 'ccp.Nmr.DataSource', 'setName')
Implementation.unregisterNotify(self.setSpectrumSelector, 'ccp.Nmr.Experiment', 'setName')
Implementation.unregisterNotify(self.changedPeakList, 'ccp.Nmr.PeakList', 'setPeakColor')
Implementation.unregisterNotify(self.changedPeakList, 'ccp.Nmr.PeakList', 'setPeakSymbol')
Implementation.unregisterNotify(self.setPeaksSelector, 'ccpnmr.Analysis.WindowPeakList', '__init__')
Implementation.unregisterNotify(self.setPeaksSelector, 'ccpnmr.Analysis.WindowPeakList', 'delete')
Implementation.unregisterNotify(self.changedWinPeakList, 'ccpnmr.Analysis.WindowPeakList', 'setIsSymbolDrawn')
Implementation.unregisterNotify(self.changedWinPeakList, 'ccpnmr.Analysis.WindowPeakList', 'setIsAnnotationDrawn')
Implementation.unregisterNotify(self.initPeak, 'ccp.Nmr.Peak', '__init__')
Implementation.unregisterNotify(self.deletePeak, 'ccp.Nmr.Peak', 'delete')
Implementation.unregisterNotify(self.changedPeak, 'ccp.Nmr.Peak', 'setAnnotation')
Implementation.unregisterNotify(self.changedPeakDim, 'ccp.Nmr.PeakDim', 'setPosition')
Implementation.unregisterNotify(self.changedPeakDim, 'ccp.Nmr.PeakDim', 'setAnnotation')
Implementation.unregisterNotify(self.changedMark, 'ccpnmr.Analysis.Mark', '')
Implementation.unregisterNotify(self.changedMark, 'ccpnmr.Analysis.MarkDim', '')
Implementation.unregisterNotify(self.changedMark, 'ccpnmr.Analysis.MarkDim', '__init__')
Implementation.unregisterNotify(self.changedMark, 'ccpnmr.Analysis.MarkDim', 'delete')
Implementation.unregisterNotify(self.changedRuler, 'ccpnmr.Analysis.Ruler', '')
Implementation.unregisterNotify(self.changedRuler, 'ccpnmr.Analysis.Ruler', '__init__')
Implementation.unregisterNotify(self.changedRuler, 'ccpnmr.Analysis.Ruler', 'delete')
Implementation.unregisterNotify(self.changedColor, 'ccpnmr.Analysis.Color', 'setR')
Implementation.unregisterNotify(self.changedColor, 'ccpnmr.Analysis.Color', 'setG')
Implementation.unregisterNotify(self.changedColor, 'ccpnmr.Analysis.Color', 'setB')
Implementation.unregisterNotify(self.changedColor, 'ccpnmr.Analysis.ColorScheme', 'setColorNames')
Implementation.unregisterNotify(self.changedReferencing, 'ccp.Nmr.ExpDimRef', '')
Implementation.unregisterNotify(self.changedReferencing, 'ccp.Nmr.DataDimRef', '')
Implementation.unregisterNotify(self.changedReferencing, 'ccp.Nmr.FreqDataDim', '')
for func in ('__init__', 'delete', 'setValue'):
for t in ('Int', 'Float', 'String', 'Boolean'):
clazz = 'memops.Implementation.AppData' + t
Implementation.unregisterNotify(self.changedAppData, clazz, func)
self.deleteHandlers()
BasePopup.destroy(self)
def setWindowTitle(self, window = None):
if ((window == None) or (window == self.window)):
self.setTitle(self.window.name)
def setWindowLocation(self, window):
if (window == self.window):
#print 'setWindowLocation1', self.geometry(), window.location
location = '+%s+%s' % (window.location[0], window.location[1])
self.geometry(location)
#print 'setWindowLocation2', self.geometry()
def getWindowLocation(self, *event):
location = self.geometry()
self.drawAll()
#print 'getWindowLocation1', location
# below only so that geometry manager does not resize without being told to
#w = int(location.split('x')[0])
#if ((w > 1) and self.firstPass):
# self.geometry(location)
# self.firstPass = False
# TBD: below supposedly does not give location on all platforms
# (when called because of binding to 'Configure')
n = location.find('+')
xy = location[n+1:]
(x, y) = map(int, xy.split('+'))
#print 'getWindowLocation2', (x, y)
if not self.window.isDeleted:
Implementation.unregisterNotify(self.setWindowLocation, 'ccpnmr.Analysis.SpectrumWindow', 'setLocation')
self.window.location = (x, y)
Implementation.registerNotify(self.setWindowLocation, 'ccpnmr.Analysis.SpectrumWindow', 'setLocation')
# the above would have in turn called setWindowLocation() if (x, y) had changed
# but there is no point in doing that and can cause windows to judder back to previous location
def setupWidgetHandler(self, widget, isCanvas = True):
if (not hasattr(widget, 'handler')):
#print 'setupWidgetHandler'
widget.handler = self.handlerClass(widget)
if (isCanvas):
(j, i) = self.scrolled_window.getCanvasRowCol(widget)
widget.xview = self.window.axisPanels[0].axisRegions[i]
widget.yview = self.window.axisPanels[1].axisRegions[j]
self.setWidgetHandlerBackground(widget)
def setHandlers(self):
for j in range(self.scrolled_window.nrows):
for i in range(self.scrolled_window.ncols):
canvas = self.scrolled_window.canvases[j][i]
canvas.handler = self.handlerClass(canvas)
canvas.xview = self.window.axisPanels[0].axisRegions[i]
canvas.yview = self.window.axisPanels[1].axisRegions[j]
if (self.hasValueAxis):
return
for i in range(self.scrolled_window.ncols):
slice = self.scrolled_window.xslices[i]
slice.handler = self.handlerClass(slice)
for j in range(self.scrolled_window.nrows):
slice = self.scrolled_window.yslices[j]
slice.handler = self.handlerClass(slice)
def deleteHandlers(self):
# force C world clean-up
#print 'deleteHandlers'
#for j in range(self.scrolled_window.nrows):
# for i in range(self.scrolled_window.ncols):
# canvas = self.scrolled_window.canvases[j][i]
# canvas.handler = None
#print 'deleteHandlers'
for j in range(self.scrolled_window.nrows):
if j >= len(self.scrolled_window.canvases):
print "Cleanup called on non-existant canvases"
continue
for i in range(self.scrolled_window.ncols):
if i >= len(self.scrolled_window.canvases[j]):
print "Cleanup called on non-existant canvases"
continue
canvas = self.scrolled_window.canvases[j][i]
canvas.handler = None
if (self.hasValueAxis):
return
for i in range(self.scrolled_window.ncols):
slice = self.scrolled_window.xslices[i]
slice.handler = None
for j in range(self.scrolled_window.nrows):
slice = self.scrolled_window.yslices[j]
slice.handler = None
def setHandlersRow(self, row):
for i in range(self.scrolled_window.ncols):
canvas = self.scrolled_window.canvases[row][i]
canvas.handler = self.handlerClass(canvas)
canvas.xview = self.window.axisPanels[0].axisRegions[i]
canvas.yview = self.window.axisPanels[1].axisRegions[row]
if (self.hasValueAxis):
return
slice = self.scrolled_window.yslices[row]
slice.handler = self.handlerClass(slice)
def setHandlersCol(self, col = -1):
#print 'setHandlersCol', col
for j in range(self.scrolled_window.nrows):
canvas = self.scrolled_window.canvases[j][col]
canvas.handler = self.handlerClass(canvas)
canvas.xview = self.window.axisPanels[0].axisRegions[col]
canvas.yview = self.window.axisPanels[1].axisRegions[j]
if (self.hasValueAxis):
return
slice = self.scrolled_window.xslices[col]
slice.handler = self.handlerClass(slice)
def setWidgetHandlerBackground(self, widget):
background = self.window.background
color = (background.r, background.g, background.b)
widget.handler.setBackground(color)
def setHandlerBackground(self):
background = self.window.background
color = (background.r, background.g, background.b)
#print 'setHandlerBackground', self.window.name, (background.r, background.g, background.b)
self.scrolled_window.setBackground(color)
for j in range(self.scrolled_window.nrows):
for i in range(self.scrolled_window.ncols):
canvas = self.scrolled_window.canvases[j][i]
self.setupWidgetHandler(canvas, isCanvas=True)
canvas.handler.setBackground(color)
if (self.hasValueAxis):
return
for i in range(self.scrolled_window.ncols):
slice = self.scrolled_window.xslices[i]
self.setupWidgetHandler(slice, isCanvas=False)
slice.handler.setBackground(color)
for j in range(self.scrolled_window.nrows):
slice = self.scrolled_window.yslices[j]
self.setupWidgetHandler(slice, isCanvas=False)
slice.handler.setBackground(color)
def changedAspectRatio(self, window, doDraw = True):
if (window != self.window):
return
self.updateAspectRatio(doDraw=doDraw)
def updateAspectRatio(self, doDraw = True):
if (self.hasValueAxis):
return
for j in range(self.scrolled_window.nrows):
self.checkAspectRatio(self.scrolled_window.canvases[j][0])
for i in range(1, self.scrolled_window.ncols):
self.checkAspectRatio(self.scrolled_window.canvases[0][i])
if (doDraw):
self.drawAll()
def changedSliceRange(self, window):
if (window != self.window):
return
self.drawAllSlices()
def setMaxExtent(self, canvas):
r = self.window.aspectRatio
w = float(canvas.canvas_width)
h = float(canvas.canvas_height)
(x0, x1) = canvas.parent.world_region.x_region
(y0, y1) = canvas.parent.world_region.y_region
rr = abs(((y1-y0)/h) / ((x1-x0)/w))
if (rr > r):
d = y0 + y1
e = r * (x1-x0) * h / w
y0 = 0.5 * (d - e)
y1 = 0.5 * (d + e)
else:
d = x0 + x1
e = (y1-y0) * w / (h * r)
x0 = 0.5 * (d - e)
x1 = 0.5 * (d + e)
canvas.xmax_extent = abs(x1-x0)
canvas.ymax_extent = abs(y1-y0)
#print 'setWorldRegion0', canvas.parent.world_region.x_region, canvas.xmax_extent
#print 'setWorldRegion1', canvas.parent.world_region.y_region, canvas.ymax_extent
def checkAspectRatio(self, canvas):
if (self.hasValueAxis):
return True
r = self.window.aspectRatio
w = float(canvas.canvas_width)
h = float(canvas.canvas_height)
(x0, x1) = canvas.xview_region
(y0, y1) = canvas.yview_region
#print 'checkAspectRatio0', x0, x1, y0, y1, w, h, r
(row, col) = self.scrolled_window.getCanvasRowCol(canvas)
xgroup = self.window.axisPanels[0].axisRegions[col].axisRegionGroup
ygroup = self.window.axisPanels[1].axisRegions[row].axisRegionGroup
if (xgroup is not None and ygroup is not None): # ignore aspect ratio
return
#print 'WindowPopup.checkAspectRatio0', row, col, x0, x1, y0, y1, xgroup, ygroup, self.scrolled_window.nrows, self.scrolled_window.ncols
if ((not ygroup) and (self.scrolled_window.ncols == 1)): # resize y direction
d = y0 + y1
e = r * (x1-x0) * h / w
yy0 = 0.5 * (d - e)
yy1 = 0.5 * (d + e)
if ((yy0 == y0) and (yy1 == y1)):
return False
#print 'checkAspectRatio1', yy0, yy1, row, col
canvas.yview_region.set(yy0, yy1)
axisRegion = self.window.axisPanels[1].axisRegions[row]
#print 'WindowPopup.checkAspectRatio1', (min(yy0, yy1), max(yy0, yy1))
axisRegion.region = (min(yy0, yy1), max(yy0, yy1))
else: # resize x direction
d = x0 + x1
e = (y1-y0) * w / (r * h)
xx0 = 0.5 * (d - e)
xx1 = 0.5 * (d + e)
if ((xx0 == x0) and (xx1 == x1)):
return False
#print 'checkAspectRatio2', xx0, xx1, row, col
canvas.xview_region.set(xx0, xx1)
axisRegion = self.window.axisPanels[0].axisRegions[col]
#print 'WindowPopup.checkAspectRatio2', (min(xx0, xx1), max(xx0, xx1))
axisRegion.region = (min(xx0, xx1), max(xx0, xx1))
self.setMaxExtent(canvas)
# not sure why after_idle required but otherwise get blank
#canvas.after_idle(lambda self=self, canvas=canvas: self.scrolled_window.updateView(canvas))
self.scrolled_window.updateView(canvas)
return True
def focusIn(self, event):
if (self != event.widget):
return
#print 'focusIn', self.window.name
#self.scrolled_window.oneWeights()
def resize(self, event):
#if self.waitResize:
# return
#print 'in resize', self.window.name
canvas = event.widget
width = event.width
height = event.height
(row, col) = self.scrolled_window.getCanvasRowCol(canvas)
#print 'resize', row, col, width, height, canvas.winfo_width(), canvas.winfo_height()
self.window.axisPanels[0].axisRegions[col].size = width
self.window.axisPanels[1].axisRegions[row].size = height
self.setupWidgetHandler(canvas, isCanvas=True)
canvas.canvas_width = width
canvas.canvas_height = height
canvas.handler.resize(width, height)
redrawn = self.checkAspectRatio(canvas)
if (not redrawn):
# not sure why after_idle required but otherwise get blank
#canvas.after_idle(lambda self=self, canvas=canvas: self.drawCanvas(canvas))
self.drawCanvas(canvas)
def expose(self, event):
#print 'in expose', self.window.name
canvas = event.widget
self.drawCanvas(canvas)
def showMotion(self, x, y, canvas = None):
self.window.axisPanels[0].pointLocation = x
self.window.axisPanels[1].pointLocation = y
for axisPanel in self.window.axisPanels[2:]:
if (canvas):
(row, col) = self.scrolled_window.getCanvasRowCol(canvas)
axisRegion = axisPanel.axisRegions[col]
axisPanel.pointLocation = self.calcAxisMidpoint(axisRegion)
else:
axisPanel.pointLocation = None
self.setLocationLabel(x, y)
n = len(self.window.axisPanels)
typeLocation = n * [0]
typeLocation = [ (axisPanel.panelType, axisPanel.pointLocation) for axisPanel in self.window.axisPanels ]
self.parent.drawCrosshair(typeLocation)
def motion(self, event):
canvas = event.widget
w = canvas.canvas_width
h = canvas.canvas_height
x = event.x
y = h - 1 - event.y
(x0, x1) = canvas.xview_region
(y0, y1) = canvas.yview_region
r = (x + 0.5) / w
s = (y + 0.5) / h
x = x0 * (1 - r) + x1 * r
y = y0 * (1 - s) + y1 * s
self.showMotion(x, y, canvas)
if (not self.hasValueAxis):
self.drawAllSlices()
def setLocationLabel(self, x = None, y = None):
nonetext = 'undef'
if (x is None):
xtext = nonetext
else:
xdecimals = self.window.axisPanels[0].axisType.numDecimals
xtext = formatDecimals(x, decimals=xdecimals)
if (y is None):
ytext = nonetext
else:
ydecimals = self.window.axisPanels[1].axisType.numDecimals
ytext = formatDecimals(y, decimals=ydecimals)
text = '%6s, %6s' % (xtext,ytext)
self.location_label.set(text)
def drawCanvasCrosshair(self, canvas, x, y):
if (self.scrolled_window.isDeleting):
return
(x0, x1) = canvas.xview_region
(y0, y1) = canvas.yview_region
self.setupWidgetHandler(canvas, isCanvas=True)
handler = canvas.handler
handler.makeCurrent()
handler.mapRanges(0, 0, 1, 1, 0, 0, 1, 1)
handler.startXor()
handler.setColor(self.handlerXorColor)
# above in xor mode means that below will appear in inverse colors
if (x is not None):
x = float(x - x0) / (x1 - x0)
handler.drawLine(x, 0, x, 1)
if (y is not None):
y = float(y - y0) / (y1 - y0)
handler.drawLine(0, y, 1, y)
handler.finishXor()
def drawCrosshair(self, typeLocation):
if (self.scrolled_window.isDeleting):
return
if (self.state() != 'normal'):
return
x = None
y = None
for n in range(2):
axisPanel = self.window.axisPanels[n]
for (panelType, pointLocation) in typeLocation:
if (panelType is axisPanel.panelType):
if (n == 0):
if (pointLocation is None):
x = None
else:
x = float(pointLocation)
else:
if (pointLocation is None):
y = None
else:
y = float(pointLocation)
self.setLocationLabel(x, y)
if (x is None and y is None):
return
for j in range(self.scrolled_window.nrows):
for i in range(self.scrolled_window.ncols):
self.drawCanvasCrosshair(self.scrolled_window.canvases[j][i], x, y)
if (x is not None):
for i in range(self.scrolled_window.ncols):
ticks = self.scrolled_window.xticks[i]
ticks.drawCrosshair(x)
if (y is not None):
for j in range(self.scrolled_window.nrows):
ticks = self.scrolled_window.yticks[j]
ticks.drawCrosshair(y)
def leave(self, event):
for i in range(2):
self.window.axisPanels[i].pointLocation = None
self.parent.endCrosshair()
def endCanvasCrosshair(self, canvas):
if (self.scrolled_window.isDeleting):
return
self.setupWidgetHandler(canvas, isCanvas=True)
handler = canvas.handler
handler.makeCurrent()
handler.clearXor()
def endSliceCrosshair(self, slice):
if (self.scrolled_window.isDeleting):
return
self.setupWidgetHandler(slice, isCanvas=False)
handler = slice.handler
handler.makeCurrent()
handler.clearXor()
def endCrosshair(self):
if (self.scrolled_window.isDeleting):
return
if (self.state() != 'normal'):
return
for j in range(self.scrolled_window.nrows):
for i in range(self.scrolled_window.ncols):
self.endCanvasCrosshair(self.scrolled_window.canvases[j][i])
for i in range(self.scrolled_window.ncols):
ticks = self.scrolled_window.xticks[i]
ticks.clearCrosshair()
for j in range(self.scrolled_window.nrows):
ticks = self.scrolled_window.yticks[j]
ticks.clearCrosshair()
if (self.hasValueAxis):
return
for i in range(self.scrolled_window.ncols):
self.endSliceCrosshair(self.scrolled_window.xslices[i])
for j in range(self.scrolled_window.nrows):
self.endSliceCrosshair(self.scrolled_window.yslices[j])
def sliceResize(self, event):
#print 'in sliceResize'
slice = event.widget
width = event.width
height = event.height
self.setupWidgetHandler(slice, isCanvas=False)
slice.slice_width = width
slice.slice_height = height
slice.handler.resize(width, height)
def sliceExpose(self, event):
#print 'in sliceExpose'
slice = event.widget
self.drawSlice(slice)
def sliceMotion(self, event):
slice = event.widget
if (slice.orient == Tkinter.HORIZONTAL):
w = slice.slice_width
x = event.x
(x0, x1) = slice.view_region
r = (x + 0.5) / w
x = x0 * (1 - r) + x1 * r
y = None
else:
h = slice.slice_height
y = h - 1 - event.y
(y0, y1) = slice.view_region
s = (y + 0.5) / h
y = y0 * (1 - s) + y1 * s
x = None
self.showMotion(x, y)
#self.drawSliceCrosshair(slice, x=x, y=y)
self.drawAllSlices()
def viewSet(self, canvas, xview_region, yview_region):
#print 'viewSet1', self.window.name, xview_region[0], xview_region[1], yview_region[0], yview_region[1]
# first time viewSet called setHandlers has not yet been called so xview, yview not set
if (hasattr(canvas, 'xview')):
#print 'viewSet2', self.window.name
axisUnit = canvas.xview.axisPanel.axisType.axisUnits[0]
canvas.xview.region = Util.checkSwapRegion(xview_region, axisUnit)
#print 'viewSet3', canvas.xview.region[0], canvas.xview.region[1]
axisUnit = canvas.yview.axisPanel.axisType.axisUnits[0]
canvas.yview.region = Util.checkSwapRegion(yview_region, axisUnit)
#print 'viewSet4', canvas.yview.region[0], canvas.yview.region[1]
else:
pass # TBD: anything one should do?
#print 'viewSet5', self.window.name
#print 'viewSet6', self.window.name
# TBD: is this needed, and when?
#self.drawCanvas(canvas)
#print 'viewSet7', self.window.name
def doCreateHorizontalRuler(self, canvas, x, y):
(a, b, x, y) = self.scrolled_window.calcWorldCoord(canvas, x, y)
createRuler(b, self.window.axisPanels[1].panelType)
#print 'doCreateHorizontalRuler', len(self.window.root.rulers)
def doCreateVerticalRuler(self, canvas, x, y):
(a, b, x, y) = self.scrolled_window.calcWorldCoord(canvas, x, y)
createRuler(a, self.window.axisPanels[0].panelType)
def doCreateMark(self, canvas, x, y):
(row, col) = self.scrolled_window.getCanvasRowCol(canvas)
xAxisRegion = self.window.axisPanels[0].axisRegions[col]
yAxisRegion = self.window.axisPanels[1].axisRegions[row]
(a, b, x, y) = self.scrolled_window.calcWorldCoord(canvas, x, y)
position_region = self.findPositionRegion(a, b, col)
views = self.getActiveSpectrumViews()
peak = None
if (self.hasValueAxis):
# TBD: look for nearby peaks
pass
else:
for view in views:
spectrum = view.dataSource
(xscale, yscale) = self.getPeakScale(view, xAxisRegion, yAxisRegion)
spectrum_region = spectrum.numDim * [0]
axisPanels = spectrum.numDim * [0]
for axisMapping in view.axisMappings:
dataDim = axisMapping.dataDim
dim = axisMapping.dim - 1
label = axisMapping.label
if (not self.isInAllowedRegion(dataDim, label, position_region[label])):
break
if (label == 'x'):
xdim = dim
elif (label == 'y'):
ydim = dim
axisPanels[dim] = self.window.findFirstAxisPanel(label=label)
spectrum_region[dim] = self.convertPositionRegion(position_region[label],
axisPanels[dim], dataDim)
else:
peakList = Util.getSpectrumActivePeakList(spectrum)
if (peakList):
peak = self.findNearbyPeak(peakList, spectrum_region, xdim, ydim, xscale, yscale)
if (peak):
break
project = self.window.project
if (peak):
createPeakMark(peak)
positions = len(peak.peakDims) * [0]
for n in range(len(peak.peakDims)):
peakDim = peak.peakDims[n]
positions[n] = Util.convertPosition(peakDim.position, peakDim.dataDimRef,
toUnit=axisPanels[n].axisUnit.unit)
else:
positions = self.findPosition(a, b, col, returnDict=False)
axisTypes = [axisPanel.axisType for axisPanel in self.window.axisPanels]
createNonPeakMark(positions, axisTypes)
def moveSelectedPeak(self, canvas, x, y):
peaks = self.parent.currentPeaks
if (len(peaks) > 1):
showError('Multiple peaks', 'Multiple peaks selected, can only move one at a time.')
return
elif (not len(peaks)):
return
peak = peaks[0]
spectrum = peak.peakList.dataSource
view = getSpectrumWindowView(self.window, spectrum)
if (not view):
showError('Peak not in window', 'Selected peak not in this window.')
return
(a, b, x, y) = self.scrolled_window.calcWorldCoord(canvas, x, y)
(row, col) = self.scrolled_window.getCanvasRowCol(canvas)
position = self.findPosition(a, b, col)
(spectrum_position, spectrum_tile) = self.determinePosition(view, position)
setPeakPosition(peak, spectrum_position, spectrum_tile)
def assignPeakAtLocation(self, canvas, x, y):
(x, y, propX, propY) = self.scrolled_window.calcWorldCoord(canvas, x, y)
(row, col) = self.scrolled_window.getCanvasRowCol(canvas)
xAxisRegion = self.window.axisPanels[0].axisRegions[col]
yAxisRegion = self.window.axisPanels[1].axisRegions[row]
region = self.findPositionRegion(x, y, col)
for view in self.getActiveSpectrumViews():
peak = self.findNearbyViewPeak(view, region, xAxisRegion, yAxisRegion)
if peak:
self.menuPeak = peak
self.assignPeak()
break
def keypress(self, event):
keysym = event.keysym
#print 'keypress1', keysym
if (keysym in Util.spectrum_shortcuts):
self.parent.toggleSpectrum(self.window, shortcut=keysym)
else:
project = self.project
macro = project.findFirstMacro(shortcut=keysym)
#print 'keypress2', macro
if (macro):
self.setCurrentObjects(event)
Util.runMacro(macro, self.parent.argumentServer)
def sliceKeypress(self, event):
#print 'sliceKeypress', event.keysym
slice = event.widget
if (event.keysym == 'Home'):
self.changeSliceRange(0.5)
elif (event.keysym == 'End'):
self.changeSliceRange(2.0)
def changeSliceRange(self, scale):
if (not self.hasValueAxis):
(r0, r1) = self.window.sliceRange
a = 0.5 * (r0 + r1)
b = 0.5 * scale * (r1 - r0)
self.window.sliceRange = (a - b, a + b)
else:
# TBD: change y axis range
pass
# overrides WindowDraw version
def drawViewTile(self, handler, canvas, view, contourLevels, contourStyle,
worldPointRanges, spectrumPointRanges, row):
#if (self.window.name == 'w'):
# print 'entering drawViewTile', self.window.name
if (canvas.doubleBuffer):
#print 'drawViewTile double', self.window.name
t = time.time()
if ((t - canvas.initTime) > doubleBufferTimeout):
raise WindowTimeoutException()
# exceptions caught higher up
self.drawViewTileReal(handler, view, contourLevels, contourStyle,
worldPointRanges, spectrumPointRanges, row)
else:
#print 'drawViewTile single', self.window.name
# exceptions caught here because called with after_idle
try:
#print 'drawViewTile0', self.window.name
self.drawViewTileReal(handler, view, contourLevels, contourStyle,
worldPointRanges, spectrumPointRanges, row)
#print 'drawViewTile1', self.window.name
except Implementation.ApiError, e:
print 'Drawing canvas tile error:', e.error_msg
except self.handlerExc, e:
print 'Drawing canvas tile handler error:', e
except ContourFile.error, e:
print 'Drawing canvas tile ContourFile error:', e
except SliceFile.error, e:
print 'Drawing canvas tile SliceFile error:', e
except PeakList.error, e:
print 'Drawing canvas tile PeakList error:', e
except WinPeakList.error, e:
print 'Drawing canvas tile WinPeakList error:', e
except:
#print 'Unknown canvas tile error'
pass
# overrides WindowDraw version
def drawCanvas(self, canvas, row = None, col = None):
if (self.scrolled_window.isDeleting):
return
if (self.state() != 'normal'):
return
# below does not work because get splatted by Tcl/Tk if do nothing
#if (hasattr(canvas, 'beingDrawn') and canvas.beingDrawn):
# return
if (row is None or col is None):
(row, col) = self.scrolled_window.getCanvasRowCol(canvas)
self.drawCanvasCount = self.drawCanvasCount + 1
#canvas.beingDrawn = True
if (not hasattr(canvas, 'drawCount')):
canvas.drawCount = 0
'''
if (self.window.name == 'Win_Hn-N'):
from Util import printStackTrace
fp = open('test.txt', 'a')
fp.write('***********drawCount=%d, drawCanvasCount=%d, doCanvasCount=%d*********\n' % (canvas.drawCount, self.drawCanvasCount, self.doCanvasCount))
printStackTrace(fp)
fp.close()
'''
#print 'drawCanvas1', self.window.name, canvas.drawCount
canvas.drawCount = canvas.drawCount + 1
self.after_idle(lambda: self.drawCanvasReal(canvas, row, col))
#print 'drawCanvas2', self.window.name
# overrides WindowDraw version
def drawCanvasReal(self, canvas, row, col):
#print 'drawCanvasReal0', self.window.name
canvas.drawCount = canvas.drawCount - 1
#print 'drawCanvasReal1', self.window.name, canvas.drawCount
if (canvas.drawCount):
return # only draw when there is only one request remaining
#print 'drawCanvasReal2', self.window.name
if (not hasattr(canvas, 'canvas_width')):
#canvas.beingDrawn = False
return
if (not hasattr(canvas, 'xview_region')):
#canvas.beingDrawn = False
return
#print 'drawCanvasReal1', self.window.name, canvas.canvas_width, canvas.canvas_height
self.doCanvasCount = self.doCanvasCount + 1
self.setupWidgetHandler(canvas, isCanvas=True)
try:
canvas.doubleBuffer = True
canvas.initTime = time.time()
canvas.handler.makeCurrent()
canvas.handler.startBack()
canvas.handler.clearXor()
canvas.handler.expose(0, 0, canvas.canvas_width, canvas.canvas_height)
self.doCanvas(canvas.handler, canvas, row, col)
canvas.handler.flush()
# doing an after_idle probably messes things up since can
# have multiple draws before a single swapBuffer is called
##canvas.after_idle(canvas.handler.swapBuffers)
canvas.handler.swapBuffers()
#canvas.beingDrawn = False
except WindowTimeoutException:
#print 'drawCanvasReal: about to single buffer doCanvas', self.window.name
canvas.doubleBuffer = False
canvas.handler.makeCurrent()
canvas.handler.clearXor()
canvas.handler.startFront()
canvas.handler.expose(0, 0, canvas.canvas_width, canvas.canvas_height)
self.doCanvas(canvas.handler, canvas, row, col)
canvas.handler.flush()
except Implementation.ApiError, e:
print 'Drawing real canvas error:', e.error_msg
#canvas.beingDrawn = False
except self.handlerExc, e:
print 'Drawing real canvas handler error:', e
except ContourFile.error, e:
print 'Drawing real canvas ContourFile error:', e
except SliceFile.error, e:
print 'Drawing real canvas SliceFile error:', e
except ContourLevels.error, e:
print 'Drawing real canvas ContourLevels error:', e
except ContourStyle.error, e:
print 'Drawing real canvas ContourStyle error:', e
except PeakList.error, e:
print 'Drawing real canvas PeakList error:', e
except WinPeakList.error, e:
print 'Drawing real canvas WinPeakList error:', e
except:
#canvas.beingDrawn = False
#print 'Unknown drawing real canvas error'
pass
#print 'drawCanvas2', self.window.name
self.waitResize = 0
# overrides WindowDraw version
def drawRow(self, row):
if (self.window.isDeleted):
return
#print 'WindowPopup: drawRow1'
ncols = self.getNCols()
for i in range(ncols):
canvas = self.scrolled_window.canvases[row][i]
self.drawCanvas(canvas, row, i)
#print 'WindowPopup: drawRow2'
# overrides WindowDraw version
def drawCol(self, col):
if (self.window.isDeleted):
return
nrows = self.getNRows()
for j in range(nrows):
canvas = self.scrolled_window.canvases[j][col]
self.drawCanvas(canvas, j, col)
# overrides WindowDraw version
def drawAll(self, *extra):
if (self.window.isDeleted):
return
#print 'WindowPopup: drawAll1'
self.setSpectrumSelector()
self.setStripsSelectorAfter()
# exceptions caught here because called with after_idle
try:
w = self.scrolled_window
for j in range(w.nrows):
self.drawRow(j)
self.drawAllSlices()
except Implementation.ApiError, e:
print 'Drawing all error:', e.error_msg
except self.handlerExc, e:
print 'Drawing all handler error:', e
except ContourFile.error, e:
print 'Drawing all ContourFile error:', e
except SliceFile.error, e:
print 'Drawing all SliceFile error:', e
except PeakList.error, e:
print 'Drawing all PeakList error:', e
except WinPeakList.error, e:
print 'Drawing all WinPeakList error:', e
except ContourLevels.error, e:
print 'Drawing all ContourLevels error:', e
except ContourStyle.error, e:
print 'Drawing all ContourStyle error:', e
except:
#print 'Unknown drawing all error'
pass
#print 'WindowPopup: drawAll2'
self.waitPeak = 0
def drawViewSlice(self, slice, view):
#print 'drawViewSliceA', view.dataSource.name
label = slice.label
sliceFile = view.sliceFile.get(label)
if (not sliceFile):
return
#print 'drawViewSliceB', view.dataSource.name
handler = slice.handler
# TBD: do again when view.sliceColor in data model
name = Util.getSpectrumSliceColor(view.dataSource)
color = view.root.findFirstColor(name=name)
if (not color):
color = view.root.findFirstColor(name='black')
handler.setColor((color.r, color.g, color.b))
#print 'drawViewSliceC', view.dataSource.name
position = view.dataSource.numDim * [0]
for axisMapping in view.axisMappings:
axisPanel = self.window.findFirstAxisPanel(label=axisMapping.label)
if (axisPanel.label == label): # position irrelevant for this dim
continue
if (not hasattr(axisPanel, 'pointLocation')):
return
if ((axisPanel.label not in ('x', 'y')) and (slice.orient == Tkinter.HORIZONTAL)):
col = self.scrolled_window.getSliceCol(slice)
axisRegion = axisPanel.axisRegions[col]
p = self.calcAxisMidpoint(axisRegion)
else:
p = axisPanel.pointLocation
if (p is None):
return
dataDim = axisMapping.dataDim
# -1 below to get points starting from 0
p = Util.convertPosition(p, dataDim.dataDimRefs[0],
fromUnit=axisPanel.axisUnit.unit) - 1
n = dataDim.numPointsOrig
p = position[dataDim.dim-1] = p % n
if (p >= dataDim.numPoints):
return
#print 'drawViewSlice1', label, position, view.dataSource.name
slicePanel = self.window.findFirstSlicePanel(label=label)
y0 = 0.0
y1 = 1.0
(b0, b1) = self.window.sliceRange
scale = view.dataSource.scale
(b0, b1) = (b0/scale, b1/scale)
axisMapping = view.findFirstAxisMapping(label=label)
dataDim = axisMapping.dataDim
axisPanel = self.window.findFirstAxisPanel(label=label)
(t0, t1) = Util.convertRegion(slice.view_region, axisPanel.axisUnit, dataDim)
if (t0 > t1):
(t0, t1) = (t1, t0)
dataDimRef = dataDim.dataDimRefs[0]
expDimRef = dataDimRef.expDimRef
minAliasedFreq = expDimRef.minAliasedFreq
maxAliasedFreq = expDimRef.maxAliasedFreq
unit = axisPanel.axisType.axisUnits[0].unit
if (maxAliasedFreq is None):
minFreqPts = 0.0
else:
minFreqPts = Util.convertPosition(maxAliasedFreq, dataDimRef, unit) - 1.0
if (minAliasedFreq is None):
maxFreqPts = float(dataDim.numPoints) - 1.0
else:
maxFreqPts = Util.convertPosition(minAliasedFreq, dataDimRef, unit) - 1.0
n = dataDim.numPointsOrig
tile0 = int(math.floor(max(t0, minFreqPts) / n))
tile1 = int(math.floor(min(t1, maxFreqPts) / n))
#print 'drawViewSlice2', label, t0, t1, n, tile0, tile1
for tile in range(tile0, tile1+1):
o = tile * n
if (tile == tile0):
s0 = t0
else:
s0 = tile * n
if (tile == tile1):
s1 = t1
else:
s1 = (tile+1) * n
#print 'drawViewSlice3', label, tile, s0, s1, t0, t1
s0 = max(s0, minFreqPts)
s1 = min(s1, maxFreqPts)
#print 'drawViewSlice4', label, tile, s0, s1, t0, t1
if (s1 <= s0):
continue
x0 = (s0-t0) / (t1-t0)
x1 = (s1-t0) / (t1-t0)
# TBD: here set s0 and s1 to lie in freq range of spectrum
a0 = float(s0 - o)
a1 = float(s1 - o)
first = int(math.floor(a0))
last = min(n, int(math.ceil(a1+1)))
#print 'drawViewSlice5', label, x0, y0, x1, y1, a0, b0, a1, b1
if (slice.orient == Tkinter.HORIZONTAL):
handler.mapRanges(x0, y0, x1, y1, a0, b0, a1, b1)
else:
# note b1, b0 swap, due to wanting positive values to point left, not right
handler.mapRanges(y0, x0, y1, x1, b1, a0, b0, a1)
#print 'drawViewSlice6', label, first, last, position
sliceFile.draw(handler, first, last, position)
#print 'drawViewSlice7', label
def doSlice(self, slice):
for view in self.window.spectrumWindowViews:
#print 'doSlice', view.dataSource.name, view.isSliceVisible
if (view.isSliceVisible):
self.drawViewSlice(slice, view)
slice.handler.flush()
self.drawSliceAxis(slice)
def drawSlice(self, slice):
if (self.state() != 'normal'):
return
if (not hasattr(slice, 'drawCount')):
slice.drawCount = 0
slice.drawCount = slice.drawCount + 1
self.after_idle(lambda: self.drawSliceReal(slice))
def drawSliceReal(self, slice):
slice.drawCount = slice.drawCount - 1
if (slice.drawCount):
return # only draw when there is only one request remaining
if (not hasattr(slice, 'slice_width')):
return
if (not hasattr(slice, 'view_region')):
return
#print 'drawSliceReal', slice.slice_width, slice.slice_height
self.setupWidgetHandler(slice, isCanvas=False)
try:
handler = slice.handler
handler.makeCurrent()
handler.startBack()
handler.clearXor()
slice.handler.expose(0, 0, slice.slice_width, slice.slice_height)
self.doSlice(slice)
handler.swapBuffers()
except Implementation.ApiError, e:
print 'Drawing slice error:', e.error_msg
except self.handlerExc, e:
print 'Drawing slice handler error:', e
except SliceFile.error, e:
print 'Drawing slice SliceFile error:', e
except:
#print 'Unknown drawing slice error'
pass
try:
if (slice.label == 'x'):
self.drawSliceCrosshair(slice, x=self.window.axisPanels[0].pointLocation)
else:
self.drawSliceCrosshair(slice, y=self.window.axisPanels[1].pointLocation)
except:
pass
def drawAllSlices(self):
slicePanel = self.window.slicePanels[0]
if (slicePanel.isVisible):
for i in range(self.scrolled_window.ncols):
self.drawSlice(self.scrolled_window.xslices[i])
slicePanel = self.window.slicePanels[1]
if (slicePanel.isVisible):
for j in range(self.scrolled_window.nrows):
self.drawSlice(self.scrolled_window.yslices[j])
def drawSliceAxis(self, slice):
handler = slice.handler
color = self.window.background
color = (1.0-color.r, 1.0-color.g, 1.0-color.b)
handler.setColor(color)
slicePanel = self.window.findFirstSlicePanel(label=slice.label)
y0 = 0.0
y1 = 1.0
(b0, b1) = self.window.sliceRange
x0 = 0.0
x1 = 1.0
a0 = 0.0
a1 = 1.0
if (slice.orient == Tkinter.HORIZONTAL):
handler.mapRanges(x0, y0, x1, y1, a0, b0, a1, b1)
handler.drawLine(0.0, 0.0, 1.0, 0.0)
else:
handler.mapRanges(y0, x0, y1, x1, b0, a0, b1, a1)
handler.drawLine(0.0, 0.0, 0.0, 1.0)
def drawSliceCrosshair(self, slice, x = None, y = None):
if (not self.parent.isCrosshairVisible()):
return
self.setupWidgetHandler(slice, isCanvas=False)
handler = slice.handler
handler.makeCurrent()
handler.startXor()
handler.setBlack()
# above in xor mode means that below will appear in inverse colors
handler.mapRanges(0, 0, 1, 1, 0, 0, 1, 1)
if (x is not None):
(x0, x1) = slice.view_region
x = float(x - x0) / (x1 - x0)
handler.drawLine(x, 0, x, 1)
if (y is not None):
(y0, y1) = slice.view_region
y = float(y - y0) / (y1 - y0)
handler.drawLine(0, y, 1, y)
handler.finishXor()
def initAxisPanel(self, axisPanel):
if (axisPanel.spectrumWindow != self.window):
return
self.createRegionSelector(axisPanel)
def deleteAxisPanel(self, axisPanel):
if (axisPanel.spectrumWindow != self.window):
return
self.deleteRegionSelector(axisPanel)
# TBD: could make initPeak and drawPeak more intelligent
def initPeak(self, peak):
if self.waitPeak:
return
self.waitPeak = 1
self.after_idle(self.drawAll)
def deletePeak(self, peak):
if self.waitPeak:
return
self.waitPeak = 1
self.after_idle(self.drawAll)
def splitWindowHorizontal(self, event):
pass
def splitWindowVertical(self, event):
canvas = event.widget
col = self.scrolled_window.getCanvasRowCol(canvas)[1]
self.scrolled_window.splitWindowVertical(event)
new_canvas = self.scrolled_window.canvases[0][col+1] # row 0 arbitrary
(r0, r1) = new_canvas.xview_region
if (r0 > r1):
(r0, r1) = (r1, r0)
Util.addAxisPanelRegion(self.window.axisPanels[0], region=(r0, r1),
size=new_canvas.winfo_width())
self.setHandlersCol(col+1)
self.setHandlerBackground()
def addRow(self, *event):
#self.scrolled_window.oneWeights()
self.scrolled_window.addRow()
row = -1
canvas = self.scrolled_window.canvases[row][0] # col 0 arbitrary
(r0, r1) = canvas.yview_region
if (r0 > r1):
(r0, r1) = (r1, r0)
Util.addAxisPanelRegion(self.window.axisPanels[1], region=(r0, r1),
size=canvas.winfo_height())
self.setHandlersRow(row)
self.setHandlerBackground()
def deleteRow(self):
#self.scrolled_window.oneWeights()
self.scrolled_window.deleteRow()
self.window.axisPanels[1].axisRegions[-1].delete()
def shuffleAxisRegions(self, sourceCol = -1, targetCol = -1):
if (sourceCol == -1):
return
axisPanels = self.window.axisPanels
n = len(axisPanels[0].axisRegions)
if (targetCol == -1):
targetCol = n - 1
#print 'shuffleAxisRegions2', sourceCol, targetCol
if (sourceCol == targetCol):
return
if (sourceCol < targetCol):
d = 1
else:
d = -1
for i in range(len(axisPanels)):
if (i == 1): # do not need to do y
continue
axisRegions = axisPanels[i].axisRegions
region = axisRegions[sourceCol].region
size = axisRegions[sourceCol].size
isActive = axisRegions[sourceCol].isActive
n = len(axisRegions)
for j in range(sourceCol, targetCol, d):
axisRegions[j].region = axisRegions[j+d].region
axisRegions[j].size = axisRegions[j+d].size
axisRegions[j].isActive = axisRegions[j+d].isActive
axisRegions[targetCol].region = region
axisRegions[targetCol].size = size
axisRegions[targetCol].isActive = isActive
def addCol(self, col = -1, centerPositionDict = None):
#print 'addCol1', col
if (centerPositionDict is None):
centerPositionDict = {}
#self.scrolled_window.oneWeights()
# need to append everything as far as scrolled_window concerned
# otherwise handlers and regions get confused
# then need to do shuffle on axis regions to make up for this
###self.scrolled_window.addCol(col)
self.scrolled_window.addCol()
canvas = self.scrolled_window.canvases[0][col] # row 0 arbitrary
(r0, r1) = canvas.xview_region
if (r0 > r1):
(r0, r1) = (r1, r0)
#print 'WindowPopup.addCol', (r0, r1)
Util.addAxisPanelRegion(self.window.axisPanels[0], region=(r0, r1),
size=canvas.winfo_width())
# see above note
###self.setHandlersCol(col)
self.setHandlersCol()
self.setHandlerBackground()
self.shuffleAxisRegions(sourceCol=col)
if (col != -1): # reset region to be that of strip where event set off
if (col == 0):
col = 1
axisPanels = self.window.axisPanels
for i in range(len(axisPanels)):
if (i == 1): # do not need to do y
continue
axisRegions = axisPanels[i].axisRegions
axisRegions[col].region = axisRegions[col-1].region
if len(self.window.axisPanels[0].axisRegions) > 1:
self.stripsButtons.buttons[1].enable()
if col == -1:
self.activateStrip(len(self.window.axisPanels[0].axisRegions)-1)
else:
self.activateStrip(col)
for label in centerPositionDict.keys():
axisPanel = self.window.findFirstAxisPanel(label=label)
axisRegion = axisPanel.axisRegions[col]
centerAxisRegion(axisRegion, centerPositionDict[label])
def deleteCol(self, col = -1):
#print 'deleteCol', col
self.update_idletasks() # see if this helps crashing stop
#self.scrolled_window.oneWeights()
N = len(self.window.axisPanels[0].axisRegions)
if N > 1:
active_col = self.getActiveStrip()
if (col == -1) and (active_col != 'all'):
col = active_col
self.scrolled_window.deleteCol(col)
WindowDraw.deleteCol(self, col)
if (active_col == col):
self.activateStrip(min(col, N-2)) # new active col
if N < 3:
self.stripsButtons.buttons[1].disable()
def findPositionMatches(self, peaks, dimNum, peakList=None):
peakLists = []
# only want peaks represented in the current window
checkPeakLists = []
for view in self.window.spectrumWindowViews:
for winPeakList in view.windowPeakLists:
try:
peakList = winPeakList.peakList
except:
peakList = None
if (peakList and not peakList.isDeleted):
checkPeakLists.append(peakList)
for peak in peaks:
if peak.peakList not in checkPeakLists:
peaks.remove(peak)
for peak in peaks:
createPeakDimRuler(peak.peakDims[dimNum],self.window,remove=False)
if peak.peakList not in peakLists:
peakLists.append(peak.peakList)
groups = findPositionMatches(peaks, dimNum, peakList)
self.parent.viewPeakGroups(groups,dimNum,peakLists)
def makeIntermediatePeak(self, *event):
peaks = self.parent.currentPeaks
if peaks:
makeIntermediatePeak(peaks)
def gotoOrthogonalPlane(self, window, position):
self.parent.gotoPosition(window_name=window.name, position=position )
def predictSpinSystemType(self, *event):
if self.menuPeak:
spinSystem = None
for peakDim in self.menuPeak.peakDims:
for contrib in peakDim.peakDimContribs:
if contrib.resonance.resonanceGroup:
spinSystem = contrib.resonance.resonanceGroup
break
else:
continue
break
if spinSystem:
self.parent.typeSpinSystem(spinSystem=spinSystem)
def makeSeqSpinSystemConnections(self, seqOffsets, *event):
peaks = []
if self.parent.currentPeaks:
peaks = self.parent.currentPeaks
elif self.menuPeak:
peaks = [self.menuPeak,]
for peak in peaks:
addPeakResonancesToSeqSpinSystems(peak, seqOffsets)
def showStructConnections(self, *event):
peaks = []
if self.parent.currentPeaks:
peaks = self.parent.currentPeaks
elif self.menuPeak:
peaks = [self.menuPeak,]
if peaks:
self.parent.viewStructure()
popup = self.parent.popups['view_structure']
popup.clearConnections()
for peak in peaks:
popup.showPeakConnection(peak)
def gotoOrthogonalAllPlanes(self, windowZplanes):
for planeName, window, position in windowZplanes:
self.gotoOrthogonalPlane(window, position)
def peakCenterOrthogonalPlanes(self, event):
canvas = event.widget
col = self.scrolled_window.getCanvasRowCol(canvas)[1]
position = {}
if self.menuPeak:
peak = self.menuPeak
for view in self.window.spectrumWindowViews:
if view.dataSource is peak.peakList.dataSource:
for axisMapping in view.axisMappings:
if axisMapping.label not in ('x','y'):
for peakDim in peak.peakDims:
if peakDim.dataDimRef.dataDim is axisMapping.dataDim:
position[axisMapping.label] = getPeakDimPosition(peakDim, toUnit=peakDim.dataDimRef.expDimRef.unit)
break
self.parent.gotoPosition(window_name=self.window.name, position=position, col=col)
def zoomToSpinSystem(self, event):
peak = self.menuPeak
if peak:
canvas = event.widget
col = self.scrolled_window.getCanvasRowCol(canvas)[1]
specDict = {}
for view in self.window.spectrumWindowViews:
specDict[view.dataSource] = 1
ssDict = {}
for peakDim in peak.peakDims:
for contrib in peakDim.peakDimContribs:
ss = contrib.resonance.resonanceGroup
if ss:
ssDict[ss] = ssDict.get(ss, 0) + 1
if ssDict:
ssBest = ssDict.keys()[0]
for ss in ssDict.keys():
if ssDict[ss] > ssDict[ssBest]:
ssBest = ss
peaks = []
for resonance in ssBest.resonances:
for contrib in resonance.peakDimContribs:
peak = contrib.peakDim.peak
if specDict.get(peak.peakList.dataSource):
peaks.append(peak)
if peaks:
zoomToShowPeaks(peaks, self.window, col)
def zoomToSelectedPeaks(self, event):
peaks = self.parent.currentPeaks
if peaks:
canvas = event.widget
col = self.scrolled_window.getCanvasRowCol(canvas)[1]
zoomToShowPeaks(peaks, self.window, col)
|
