def __init__(self, *args):
Kittens.widgets.ClickableTreeWidget.__init__(self, *args)
self._currier = PersistentCurrier()
self.model = None
# insert columns
self.setHeaderLabels(ViewColumns)
self.headerItem().setText(ColumnIapp, "I(app)")
self.header().setMovable(False)
self.header().setClickable(True)
self.setSortingEnabled(True)
self.setRootIsDecorated(False)
self.setEditTriggers(QAbstractItemView.AllEditTriggers)
self.setMouseTracking(True)
# set column width modes
for icol in range(NumColumns - 1):
self.header().setResizeMode(icol, QHeaderView.ResizeToContents)
self.header().setStretchLastSection(True)
## self.setTextAlignment(ColumnR,Qt.AlignRight);
## self.setTextAlignment(ColumnType,Qt.AlignHCenter);
# _column_enabled[i] is True if column is available in the model.
# _column_show[i] is True if column is currently being shown (via a view control)
self._column_enabled = [True] * NumColumns
self._column_shown = [True] * NumColumns
# other listview init
self.header().show()
self.setSelectionMode(QTreeWidget.ExtendedSelection)
self.setAllColumnsShowFocus(True)
## self.setShowToolTips(True);
self._updating_selection = False
self.setRootIsDecorated(False)
# connect signals to track selected sources
QObject.connect(self, SIGNAL("itemSelectionChanged()"),
self._selectionChanged)
QObject.connect(self, SIGNAL("itemEntered(QTreeWidgetItem*,int)"),
self._itemHighlighted)
# add "View" controls for different column categories
self._column_views = []
self._column_widths = {}
self.addColumnCategory("Position", [ColumnRa, ColumnDec])
self.addColumnCategory("Position errors",
[ColumnRa_err, ColumnDec_err], False)
self.addColumnCategory("Type", [ColumnType])
self.addColumnCategory("Flux", [ColumnIapp, ColumnI])
self.addColumnCategory("Flux errors", [ColumnI_err], False)
self.addColumnCategory("Polarization",
[ColumnQ, ColumnU, ColumnV, ColumnRm])
self.addColumnCategory(
"Polarization errors",
[ColumnQ_err, ColumnU_err, ColumnV_err, ColumnRm_err], False)
self.addColumnCategory("Spectrum", [ColumnSpi])
self.addColumnCategory("Spectrum errors", [ColumnSpi_err], False)
self.addColumnCategory("Shape", [ColumnShape])
self.addColumnCategory("Shape errors", [ColumnShape_err], False)
self.addColumnCategory("Tags", [ColumnTags])
def __init__(self, parent, *args):
QWidget.__init__(self, parent, *args)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
lo = QVBoxLayout(self)
lo.setContentsMargins(0, 0, 0, 0)
lo1 = QHBoxLayout()
lo.addLayout(lo1)
lo1.setContentsMargins(0, 0, 0, 0)
lbl = QLabel(QString("<nobr><b>Source groupings:</b></nobr>"), self)
lo1.addWidget(lbl, 0)
lo1.addStretch(1)
# add show/hide button
self._showattrbtn = QPushButton(self)
self._showattrbtn.setMinimumWidth(256)
lo1.addWidget(self._showattrbtn, 0)
lo1.addStretch()
QObject.connect(self._showattrbtn, SIGNAL("clicked()"),
self._togglePlotControlsVisibility)
# add table
self.table = QTableWidget(self)
lo.addWidget(self.table)
QObject.connect(self.table, SIGNAL("cellChanged(int,int)"),
self._valueChanged)
self.table.setSelectionMode(QTableWidget.NoSelection)
# setup basic columns
self.table.setColumnCount(6 + len(self.EditableAttrs))
for i, label in enumerate(
("grouping", "total", "selection", "list", "plot", "style")):
self.table.setHorizontalHeaderItem(i, QTableWidgetItem(label))
self.table.horizontalHeader().setSectionHidden(self.ColApply, True)
# setup columns for editable grouping attributes
for i, attr in self.AttrByCol.iteritems():
self.table.setHorizontalHeaderItem(
i, QTableWidgetItem(PlotStyles.StyleAttributeLabels[attr]))
self.table.horizontalHeader().setSectionHidden(i, True)
self.table.verticalHeader().hide()
# other internal init
self._attrs_shown = False
self._togglePlotControlsVisibility()
self.model = None
self._setting_model = False
self._currier = PersistentCurrier()
# row of 'selected' grouping
self._irow_selgroup = 0
def __init__(self, parent, menu, toolbar):
QObject.__init__(self, parent)
self._currier = PersistentCurrier()
# get list of mouse modes from config
modelist = []
for mid in Config.get("mouse-modes", _DefaultModes).split(","):
if not ConfigFile.has_section(mid):
print "ERROR: unknown mouse-mode '%s', skipping. Check your %s." % (
mid, ConfigFileName)
else:
modelist.append(self._readModeConfig(mid))
self._modes = dict([(mode.id, mode) for mode in modelist])
self._qag_mode = QActionGroup(self)
self._qag_submode = QActionGroup(self)
self._all_submodes = []
# make entries for main modes
for mode in modelist:
mode.addAction(menu,
self._qag_mode,
callback=self._currier.curry(
self._setMode, mode.id))
if mode.submodes:
self._all_submodes += list(mode.submodes)
# make entries for submodes
self._qa_submode_sep = menu.addSeparator()
self._modes.update([(mode.id, mode) for mode in self._all_submodes])
for mode in self._all_submodes:
mode.addAction(menu,
self._qag_submode,
toolbar=toolbar,
callback=self._currier.curry(
self._setSubmode, mode.id))
# other init
self._current_context = None
self._available_submodes = []
# set initial mode
initmode = Config.get("current-mouse-mode", _DefaultInitialMode)
if initmode not in self._modes:
initmode = modelist[0].id
self._modes[initmode].qa.setChecked(True)
self._setMode(initmode, write_config=False)
def __init__ (self,*args):
QWidget.__init__(self,*args);
# init layout
self._lo = QVBoxLayout(self);
self._lo.setContentsMargins(0,0,0,0);
self._lo.setSpacing(0);
# init internal state
self._currier = PersistentCurrier();
self._z0 = 0; # z-depth of first image, the rest count down from it
self._updating_imap = False;
self._locked_display_range = False;
self._imagecons = [];
self._imagecon_loadorder = [];
self._center_image = None;
self._plot = None;
self._border_pen = None;
self._drawing_key = None;
self._load_image_dialog = None;
self._model_imagecons = set();
# init menu and standard actions
self._menu = QMenu("&Image",self);
qag = QActionGroup(self);
# exclusive controls for plotting topmost or all images
self._qa_plot_top = qag.addAction("Display topmost image only");
self._qa_plot_all = qag.addAction("Display all images");
self._qa_plot_top.setCheckable(True);
self._qa_plot_all.setCheckable(True);
self._qa_plot_top.setChecked(True);
QObject.connect(self._qa_plot_all,SIGNAL("toggled(bool)"),self._displayAllImages);
self._closing = False;
self._qa_load_clipboard = None;
self._clipboard_mode = QClipboard.Clipboard;
QObject.connect(QApplication.clipboard(),SIGNAL("changed(QClipboard::Mode)"),self._checkClipboardPath);
# populate the menu
self._repopulateMenu();
def __init__(self, image, parent, imgman, name=None, save=False):
QFrame.__init__(self, parent)
self.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
# init state
self.image = image
self._imgman = imgman
self._currier = PersistentCurrier()
self._control_dialog = None
# create widgets
self._lo = lo = QHBoxLayout(self)
lo.setContentsMargins(0, 0, 0, 0)
lo.setSpacing(2)
# raise button
self._wraise = QToolButton(self)
lo.addWidget(self._wraise)
self._wraise.setIcon(pixmaps.raise_up.icon())
self._wraise.setAutoRaise(True)
self._can_raise = False
QObject.connect(self._wraise, SIGNAL("clicked()"),
self._raiseButtonPressed)
self._wraise.setToolTip(
"""<P>Click here to raise this image above other images. Hold the button down briefly to
show a menu of image operations.</P>""")
# center label
self._wcenter = QLabel(self)
self._wcenter.setPixmap(pixmaps.center_image.pm())
self._wcenter.setToolTip(
"<P>The plot is currently centered on (the reference pixel %d,%d) of this image.</P>"
% self.image.referencePixel())
lo.addWidget(self._wcenter)
# name/filename label
self.name = image.name
self._wlabel = QLabel(self.name, self)
self._number = 0
self.setName(self.name)
self._wlabel.setToolTip(
"%s %s" %
(image.filename, u"\u00D7".join(map(str,
image.data().shape))))
lo.addWidget(self._wlabel, 1)
# if 'save' is specified, create a "save" button
if save:
self._wsave = QToolButton(self)
lo.addWidget(self._wsave)
self._wsave.setText("save")
self._wsave.setAutoRaise(True)
self._save_dir = save if isinstance(save, str) else "."
QObject.connect(self._wsave, SIGNAL("clicked()"), self._saveImage)
self._wsave.setToolTip(
"""<P>Click here to write this image to a FITS file.</P>""")
# render control
dprint(2, "creating RenderControl")
self._rc = RenderControl(image, self)
dprint(2, "done")
# selectors for extra axes
self._wslicers = []
curslice = self._rc.currentSlice()
# this may be loaded from config, so not necessarily 0
for iextra, axisname, labels in self._rc.slicedAxes():
if axisname.upper() not in ["STOKES", "COMPLEX"]:
lbl = QLabel("%s:" % axisname, self)
lo.addWidget(lbl)
else:
lbl = None
slicer = QComboBox(self)
self._wslicers.append(slicer)
lo.addWidget(slicer)
slicer.addItems(labels)
slicer.setToolTip(
"""<P>Selects current slice along the %s axis.</P>""" %
axisname)
slicer.setCurrentIndex(curslice[iextra])
QObject.connect(slicer, SIGNAL("activated(int)"),
self._currier.curry(self._rc.changeSlice, iextra))
# min/max display ranges
lo.addSpacing(5)
self._wrangelbl = QLabel(self)
lo.addWidget(self._wrangelbl)
self._minmaxvalidator = FloatValidator(self)
self._wmin = QLineEdit(self)
self._wmax = QLineEdit(self)
width = self._wmin.fontMetrics().width("1.234567e-05")
for w in self._wmin, self._wmax:
lo.addWidget(w, 0)
w.setValidator(self._minmaxvalidator)
w.setMaximumWidth(width)
w.setMinimumWidth(width)
QObject.connect(w, SIGNAL("editingFinished()"),
self._changeDisplayRange)
# full-range button
self._wfullrange = QToolButton(self)
lo.addWidget(self._wfullrange, 0)
self._wfullrange.setIcon(pixmaps.zoom_range.icon())
self._wfullrange.setAutoRaise(True)
QObject.connect(self._wfullrange, SIGNAL("clicked()"),
self.renderControl().resetSubsetDisplayRange)
rangemenu = QMenu(self)
rangemenu.addAction(pixmaps.full_range.icon(), "Full subset",
self.renderControl().resetSubsetDisplayRange)
for percent in (99.99, 99.9, 99.5, 99, 98, 95):
rangemenu.addAction(
"%g%%" % percent,
self._currier.curry(self._changeDisplayRangeToPercent,
percent))
self._wfullrange.setPopupMode(QToolButton.DelayedPopup)
self._wfullrange.setMenu(rangemenu)
# update widgets from current display range
self._updateDisplayRange(*self._rc.displayRange())
# lock button
self._wlock = QToolButton(self)
self._wlock.setIcon(pixmaps.unlocked.icon())
self._wlock.setAutoRaise(True)
self._wlock.setToolTip(
"""<P>Click to lock or unlock the intensity range. When the intensity range is locked across multiple images, any changes in the intensity
range of one are propagated to the others. Hold the button down briefly for additional options.</P>"""
)
lo.addWidget(self._wlock)
QObject.connect(self._wlock, SIGNAL("clicked()"),
self._toggleDisplayRangeLock)
QObject.connect(self.renderControl(), SIGNAL("displayRangeLocked"),
self._setDisplayRangeLock)
QObject.connect(self.renderControl(), SIGNAL("dataSubsetChanged"),
self._dataSubsetChanged)
lockmenu = QMenu(self)
lockmenu.addAction(
pixmaps.locked.icon(), "Lock all to this",
self._currier.curry(imgman.lockAllDisplayRanges,
self.renderControl()))
lockmenu.addAction(pixmaps.unlocked.icon(), "Unlock all",
imgman.unlockAllDisplayRanges)
self._wlock.setPopupMode(QToolButton.DelayedPopup)
self._wlock.setMenu(lockmenu)
self._setDisplayRangeLock(self.renderControl().isDisplayRangeLocked())
# dialog button
self._wshowdialog = QToolButton(self)
lo.addWidget(self._wshowdialog)
self._wshowdialog.setIcon(pixmaps.colours.icon())
self._wshowdialog.setAutoRaise(True)
self._wshowdialog.setToolTip(
"""<P>Click for colourmap and intensity policy options.</P>""")
QObject.connect(self._wshowdialog, SIGNAL("clicked()"),
self.showRenderControls)
tooltip = """<P>You can change the currently displayed intensity range by entering low and high limits here.</P>
<TABLE>
<TR><TD><NOBR>Image min:</NOBR></TD><TD>%g</TD><TD>max:</TD><TD>%g</TD></TR>
</TABLE>""" % self.image.imageMinMax()
for w in self._wmin, self._wmax, self._wrangelbl:
w.setToolTip(tooltip)
# create image operations menu
self._menu = QMenu(self.name, self)
self._qa_raise = self._menu.addAction(
pixmaps.raise_up.icon(), "Raise image",
self._currier.curry(self.image.emit, SIGNAL("raise")))
self._qa_center = self._menu.addAction(
pixmaps.center_image.icon(), "Center plot on image",
self._currier.curry(self.image.emit, SIGNAL("center")))
self._qa_show_rc = self._menu.addAction(pixmaps.colours.icon(),
"Colours && Intensities...",
self.showRenderControls)
if save:
self._qa_save = self._menu.addAction("Save image...",
self._saveImage)
self._menu.addAction("Export image to PNG file...",
self._exportImageToPNG)
self._export_png_dialog = None
self._menu.addAction(
"Unload image",
self._currier.curry(self.image.emit, SIGNAL("unload")))
self._wraise.setMenu(self._menu)
self._wraise.setPopupMode(QToolButton.DelayedPopup)
# connect updates from renderControl and image
self.image.connect(SIGNAL("slice"), self._updateImageSlice)
QObject.connect(self._rc, SIGNAL("displayRangeChanged"),
self._updateDisplayRange)
# default plot depth of image markers
self._z_markers = None
# and the markers themselves
self._image_border = QwtPlotCurve()
self._image_label = QwtPlotMarker()
# subset markers
self._subset_pen = QPen(QColor("Light Blue"))
self._subset_border = QwtPlotCurve()
self._subset_border.setPen(self._subset_pen)
self._subset_border.setVisible(False)
self._subset_label = QwtPlotMarker()
text = QwtText("subset")
text.setColor(self._subset_pen.color())
self._subset_label.setLabel(text)
self._subset_label.setLabelAlignment(Qt.AlignRight | Qt.AlignBottom)
self._subset_label.setVisible(False)
self._setting_lmrect = False
self._all_markers = [
self._image_border, self._image_label, self._subset_border,
self._subset_label
]
def __init__ (self,parent,hide_on_close=False):
QMainWindow.__init__(self,parent);
self.setWindowIcon(pixmaps.tigger_starface.icon());
self._currier = PersistentCurrier();
self.hide();
# init column constants
for icol,col in enumerate(self.ViewModelColumns):
setattr(self,"Column%s"%col.capitalize(),icol);
# init GUI
self.setWindowTitle("Tigger");
# self.setIcon(pixmaps.purr_logo.pm());
cw = QWidget(self);
self.setCentralWidget(cw);
cwlo = QVBoxLayout(cw);
cwlo.setMargin(5);
# make splitter
spl1 = self._splitter1 = QSplitter(Qt.Vertical,cw);
spl1.setOpaqueResize(False);
cwlo.addWidget(spl1);
# Create listview of LSM entries
self.tw = SkyModelTreeWidget(spl1);
self.tw.hide();
# split bottom pane
spl2 = self._splitter2 = QSplitter(Qt.Horizontal,spl1);
spl2.setOpaqueResize(False);
self._skyplot_stack = QWidget(spl2);
self._skyplot_stack_lo = QVBoxLayout(self._skyplot_stack);
self._skyplot_stack_lo.setContentsMargins(0,0,0,0);
# add plot
self.skyplot = SkyModelPlotter(self._skyplot_stack,self);
self.skyplot.resize(128,128);
self.skyplot.setSizePolicy(QSizePolicy.Minimum,QSizePolicy.Preferred);
self._skyplot_stack_lo.addWidget(self.skyplot,1000);
self.skyplot.hide();
QObject.connect(self.skyplot,SIGNAL("imagesChanged"),self._imagesChanged);
QObject.connect(self.skyplot,SIGNAL("showMessage"),self.showMessage);
QObject.connect(self.skyplot,SIGNAL("showErrorMessage"),self.showErrorMessage);
self._grouptab_stack = QWidget(spl2);
self._grouptab_stack_lo = lo =QVBoxLayout(self._grouptab_stack);
self._grouptab_stack_lo.setContentsMargins(0,0,0,0);
# add groupings table
self.grouptab = ModelGroupsTable(self._grouptab_stack);
self.grouptab.setSizePolicy(QSizePolicy.Preferred,QSizePolicy.Preferred);
QObject.connect(self,SIGNAL("hasSkyModel"),self.grouptab.setEnabled);
lo.addWidget(self.grouptab,1000);
lo.addStretch(1);
self.grouptab.hide();
# add image controls -- parentless for now (setLayout will reparent them anyway)
self.imgman = ImageManager();
self.skyplot.setImageManager(self.imgman);
QObject.connect(self.imgman,SIGNAL("imagesChanged"),self._imagesChanged);
QObject.connect(self.imgman,SIGNAL("showMessage"),self.showMessage);
QObject.connect(self.imgman,SIGNAL("showErrorMessage"),self.showErrorMessage);
# enable status line
self.statusBar().show();
# Create and populate main menu
menubar = self.menuBar();
# File menu
file_menu = menubar.addMenu("&File");
qa_open = file_menu.addAction("&Open model...",self._openFileCallback,Qt.CTRL+Qt.Key_O);
qa_merge = file_menu.addAction("&Merge in model...",self._mergeFileCallback,Qt.CTRL+Qt.SHIFT+Qt.Key_O);
QObject.connect(self,SIGNAL("hasSkyModel"),qa_merge.setEnabled);
file_menu.addSeparator();
qa_save = file_menu.addAction("&Save model",self.saveFile,Qt.CTRL+Qt.Key_S);
QObject.connect(self,SIGNAL("isUpdated"),qa_save.setEnabled);
qa_save_as = file_menu.addAction("Save model &as...",self.saveFileAs);
QObject.connect(self,SIGNAL("hasSkyModel"),qa_save_as.setEnabled);
qa_save_selection_as = file_menu.addAction("Save selection as...",self.saveSelectionAs);
QObject.connect(self,SIGNAL("hasSelection"),qa_save_selection_as.setEnabled);
file_menu.addSeparator();
qa_close = file_menu.addAction("&Close model",self.closeFile,Qt.CTRL+Qt.Key_W);
QObject.connect(self,SIGNAL("hasSkyModel"),qa_close.setEnabled);
qa_quit = file_menu.addAction("Quit",self.close,Qt.CTRL+Qt.Key_Q);
# Image menu
menubar.addMenu(self.imgman.getMenu());
# Plot menu
menubar.addMenu(self.skyplot.getMenu());
# LSM Menu
em = QMenu("&LSM",self);
self._qa_em = menubar.addMenu(em);
self._qa_em.setVisible(False);
QObject.connect(self,SIGNAL("hasSkyModel"),self._qa_em.setVisible);
self._column_view_menu = QMenu("&Show columns",self);
self._qa_cv_menu = em.addMenu(self._column_view_menu);
em.addSeparator();
em.addAction("Select &all",self._selectAll,Qt.CTRL+Qt.Key_A);
em.addAction("&Invert selection",self._selectInvert,Qt.CTRL+Qt.Key_I);
em.addAction("Select b&y attribute...",self._showSourceSelector,Qt.CTRL+Qt.Key_Y);
em.addSeparator();
qa_add_tag = em.addAction("&Tag selection...",self.addTagToSelection,Qt.CTRL+Qt.Key_T);
QObject.connect(self,SIGNAL("hasSelection"),qa_add_tag.setEnabled);
qa_del_tag = em.addAction("&Untag selection...",self.removeTagsFromSelection,Qt.CTRL+Qt.Key_U);
QObject.connect(self,SIGNAL("hasSelection"),qa_del_tag.setEnabled);
qa_del_sel = em.addAction("&Delete selection",self._deleteSelection);
QObject.connect(self,SIGNAL("hasSelection"),qa_del_sel.setEnabled);
# Tools menu
tm = self._tools_menu = QMenu("&Tools",self);
self._qa_tm = menubar.addMenu(tm);
self._qa_tm.setVisible(False);
QObject.connect(self,SIGNAL("hasSkyModel"),self._qa_tm.setVisible);
# Help menu
menubar.addSeparator();
hm = self._help_menu = menubar.addMenu("&Help");
hm.addAction("&About...",self._showAboutDialog);
self._about_dialog = None;
# message handlers
self.qerrmsg = QErrorMessage(self);
# set initial state
self.setAcceptDrops(True);
self.model = None;
self.filename = None;
self._display_filename = None;
self._open_file_dialog = self._merge_file_dialog = self._save_as_dialog = self._save_sel_as_dialog = self._open_image_dialog = None;
self.emit(SIGNAL("isUpdated"),False);
self.emit(SIGNAL("hasSkyModel"),False);
self.emit(SIGNAL("hasSelection"),False);
self._exiting = False;
# set initial layout
self._current_layout = None;
self.setLayout(self.LayoutEmpty);
dprint(1,"init complete");
