def _fillMagazinsTable(self):
self.ItemsList = self._getItemsList(
) #Список имеющихся предметов для выпадающего списка
rows = self.DbConnector.getMagazinsItemsMap()
if rows is None or len(rows) == 0:
return
self.MagazinsTable.setItemDelegateForColumn(3, NonEditColumnDelegate())
self.MagazinsTable.setRowCount(0)
counter = 0
for row in rows:
ItemIdMag = QtGui.QTableWidgetItem(str(str(row[0])))
ItemIdMag.setTextAlignment(QtCore.Qt.AlignCenter)
cmbx = QComboBox()
cmbx.addItems(self.ItemsList)
name = str(row[1])
index = cmbx.findText(name)
cmbx.setCurrentIndex(index)
ItemItemQty = QtGui.QTableWidgetItem(str(row[2]))
ItemItemQty.setTextAlignment(QtCore.Qt.AlignCenter)
ItemIdItem = QtGui.QTableWidgetItem(str(row[3]))
ItemIdItem.setTextAlignment(QtCore.Qt.AlignCenter)
self.MagazinsTable.insertRow(counter)
self.MagazinsTable.setItem(counter, 0, ItemIdMag)
self.MagazinsTable.setCellWidget(counter, 1, cmbx)
self.MagazinsTable.setItem(counter, 2, ItemItemQty)
self.MagazinsTable.setItem(counter, 3, ItemIdItem)
counter += 1
def _addMagazin(self):
rowCount = self.MagazinsTable.rowCount()
self.MagazinsTable.insertRow(rowCount)
ItemItemQty = QtGui.QTableWidgetItem()
ItemItemQty.setTextAlignment(QtCore.Qt.AlignCenter)
self.MagazinsTable.setItem(rowCount, 0, ItemItemQty)
cmbx = QComboBox()
cmbx.addItems(self.ItemsList)
cmbx.setCurrentIndex(-1)
self.MagazinsTable.setCellWidget(rowCount, 1, cmbx)
ItemItemQty = QtGui.QTableWidgetItem('0')
ItemItemQty.setTextAlignment(QtCore.Qt.AlignCenter)
self.MagazinsTable.setItem(rowCount, 2, ItemItemQty)
class RuleEditor(QDialog): # {{{
def __init__(self, fm, pref_name, parent=None):
QDialog.__init__(self, parent)
self.fm = fm
if pref_name == 'column_color_rules':
self.rule_kind = 'color'
rule_text = _('coloring')
else:
self.rule_kind = 'icon'
rule_text = _('icon')
self.setWindowIcon(QIcon(I('format-fill-color.png')))
self.setWindowTitle(_('Create/edit a column {0} rule').format(rule_text))
self.l = l = QGridLayout(self)
self.setLayout(l)
self.l1 = l1 = QLabel(_('Create a column {0} rule by'
' filling in the boxes below'.format(rule_text)))
l.addWidget(l1, 0, 0, 1, 8)
self.f1 = QFrame(self)
self.f1.setFrameShape(QFrame.HLine)
l.addWidget(self.f1, 1, 0, 1, 8)
self.l2 = l2 = QLabel(_('Set the'))
l.addWidget(l2, 2, 0)
if self.rule_kind == 'color':
l.addWidget(QLabel(_('color')))
else:
self.kind_box = QComboBox(self)
for tt, t in icon_rule_kinds:
self.kind_box.addItem(tt, t)
l.addWidget(self.kind_box, 2, 1)
self.l3 = l3 = QLabel(_('of the column:'))
l.addWidget(l3, 2, 2)
self.column_box = QComboBox(self)
l.addWidget(self.column_box, 2, 3)
self.l4 = l4 = QLabel(_('to'))
l.addWidget(l4, 2, 4)
if self.rule_kind == 'color':
self.color_box = QComboBox(self)
self.color_label = QLabel('Sample text Sample text')
self.color_label.setTextFormat(Qt.RichText)
l.addWidget(self.color_box, 2, 5)
l.addWidget(self.color_label, 2, 6)
l.addItem(QSpacerItem(10, 10, QSizePolicy.Expanding), 2, 7)
else:
self.filename_box = QComboBox()
self.filename_box.setInsertPolicy(self.filename_box.InsertAlphabetically)
d = os.path.join(config_dir, 'cc_icons')
self.icon_file_names = []
if os.path.exists(d):
for icon_file in os.listdir(d):
icon_file = lower(icon_file)
if os.path.exists(os.path.join(d, icon_file)):
if icon_file.endswith('.png'):
self.icon_file_names.append(icon_file)
self.icon_file_names.sort(key=sort_key)
self.update_filename_box()
l.addWidget(self.filename_box, 2, 5)
self.filename_button = QPushButton(QIcon(I('document_open.png')),
_('&Add icon'))
l.addWidget(self.filename_button, 2, 6)
l.addWidget(QLabel(_('Icons should be square or landscape')), 2, 7)
l.setColumnStretch(7, 10)
self.l5 = l5 = QLabel(
_('Only if the following conditions are all satisfied:'))
l.addWidget(l5, 3, 0, 1, 7)
self.scroll_area = sa = QScrollArea(self)
sa.setMinimumHeight(300)
sa.setMinimumWidth(950)
sa.setWidgetResizable(True)
l.addWidget(sa, 4, 0, 1, 8)
self.add_button = b = QPushButton(QIcon(I('plus.png')),
_('Add another condition'))
l.addWidget(b, 5, 0, 1, 8)
b.clicked.connect(self.add_blank_condition)
self.l6 = l6 = QLabel(_('You can disable a condition by'
' blanking all of its boxes'))
l.addWidget(l6, 6, 0, 1, 8)
self.bb = bb = QDialogButtonBox(
QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
l.addWidget(bb, 7, 0, 1, 8)
self.conditions_widget = QWidget(self)
sa.setWidget(self.conditions_widget)
self.conditions_widget.setLayout(QVBoxLayout())
self.conditions_widget.layout().setAlignment(Qt.AlignTop)
self.conditions = []
if self.rule_kind == 'color':
for b in (self.column_box, self.color_box):
b.setSizeAdjustPolicy(b.AdjustToMinimumContentsLengthWithIcon)
b.setMinimumContentsLength(15)
for key in sorted(displayable_columns(fm),
key=lambda(k): sort_key(fm[k]['name']) if k != color_row_key else 0):
if key == color_row_key and self.rule_kind != 'color':
continue
name = all_columns_string if key == color_row_key else fm[key]['name']
if name:
self.column_box.addItem(name, key)
self.column_box.setCurrentIndex(0)
if self.rule_kind == 'color':
self.color_box.addItems(QColor.colorNames())
self.color_box.setCurrentIndex(0)
self.update_color_label()
self.color_box.currentIndexChanged.connect(self.update_color_label)
else:
self.filename_button.clicked.connect(self.filename_button_clicked)
self.resize(self.sizeHint())
def update_filename_box(self):
self.filename_box.clear()
self.icon_file_names.sort(key=sort_key)
self.filename_box.addItem('')
self.filename_box.addItems(self.icon_file_names)
for i,filename in enumerate(self.icon_file_names):
icon = QIcon(os.path.join(config_dir, 'cc_icons', filename))
self.filename_box.setItemIcon(i+1, icon)
def update_color_label(self):
pal = QApplication.palette()
bg1 = unicode(pal.color(pal.Base).name())
bg2 = unicode(pal.color(pal.AlternateBase).name())
c = unicode(self.color_box.currentText())
self.color_label.setText('''
<span style="color: {c}; background-color: {bg1}"> {st} </span>
<span style="color: {c}; background-color: {bg2}"> {st} </span>
'''.format(c=c, bg1=bg1, bg2=bg2, st=_('Sample Text')))
def filename_button_clicked(self):
try:
path = choose_files(self, 'choose_category_icon',
_('Select Icon'), filters=[
('Images', ['png', 'gif', 'jpg', 'jpeg'])],
all_files=False, select_only_single_file=True)
if path:
icon_path = path[0]
icon_name = sanitize_file_name_unicode(
os.path.splitext(
os.path.basename(icon_path))[0]+'.png')
if icon_name not in self.icon_file_names:
self.icon_file_names.append(icon_name)
self.update_filename_box()
try:
p = QIcon(icon_path).pixmap(QSize(128, 128))
d = os.path.join(config_dir, 'cc_icons')
if not os.path.exists(os.path.join(d, icon_name)):
if not os.path.exists(d):
os.makedirs(d)
with open(os.path.join(d, icon_name), 'wb') as f:
f.write(pixmap_to_data(p, format='PNG'))
except:
import traceback
traceback.print_exc()
self.filename_box.setCurrentIndex(self.filename_box.findText(icon_name))
self.filename_box.adjustSize()
except:
import traceback
traceback.print_exc()
return
def add_blank_condition(self):
c = ConditionEditor(self.fm, parent=self.conditions_widget)
self.conditions.append(c)
self.conditions_widget.layout().addWidget(c)
def apply_rule(self, kind, col, rule):
if kind == 'color':
if rule.color:
idx = self.color_box.findText(rule.color)
if idx >= 0:
self.color_box.setCurrentIndex(idx)
else:
self.kind_box.setCurrentIndex(0 if kind == 'icon' else 1)
if rule.color:
idx = self.filename_box.findText(rule.color)
if idx >= 0:
self.filename_box.setCurrentIndex(idx)
else:
self.filename_box.setCurrentIndex(0)
for i in range(self.column_box.count()):
c = unicode(self.column_box.itemData(i).toString())
if col == c:
self.column_box.setCurrentIndex(i)
break
for c in rule.conditions:
ce = ConditionEditor(self.fm, parent=self.conditions_widget)
self.conditions.append(ce)
self.conditions_widget.layout().addWidget(ce)
try:
ce.condition = c
except:
import traceback
traceback.print_exc()
def accept(self):
if self.rule_kind != 'color':
fname = lower(unicode(self.filename_box.currentText()))
if not fname:
error_dialog(self, _('No icon selected'),
_('You must choose an icon for this rule'), show=True)
return
if self.validate():
QDialog.accept(self)
def validate(self):
r = Rule(self.fm)
for c in self.conditions:
condition = c.condition
if condition is not None:
try:
r.add_condition(*condition)
except Exception as e:
import traceback
error_dialog(self, _('Invalid condition'),
_('One of the conditions for this rule is'
' invalid: <b>%s</b>')%e,
det_msg=traceback.format_exc(), show=True)
return False
if len(r.conditions) < 1:
error_dialog(self, _('No conditions'),
_('You must specify at least one non-empty condition'
' for this rule'), show=True)
return False
return True
@property
def rule(self):
r = Rule(self.fm)
if self.rule_kind != 'color':
r.color = unicode(self.filename_box.currentText())
else:
r.color = unicode(self.color_box.currentText())
idx = self.column_box.currentIndex()
col = unicode(self.column_box.itemData(idx).toString())
for c in self.conditions:
condition = c.condition
if condition is not None:
r.add_condition(*condition)
if self.rule_kind == 'icon':
kind = unicode(self.kind_box.itemData(
self.kind_box.currentIndex()).toString())
else:
kind = 'color'
return kind, col, r
def _updateModel(self, what=SkyModel.UpdateAll, origin=None):
if origin is self or not what & (SkyModel.UpdateTags | SkyModel.UpdateGroupStyle):
return
model = self.model
self._setting_model = True; # to ignore cellChanged() signals (in valueChanged())
# _item_cb is a dict (with row,col keys) containing the widgets (CheckBoxes ComboBoxes) per each cell
self._item_cb = {}
# lists of "list" and "plot" checkboxes per each grouping (excepting the default grouping); each entry is an (row,col,item) tuple.
# used as argument to self._showControls()
self._list_controls = []
self._plot_controls = []
# list of selection callbacks (to which signals are connected)
self._callbacks = []
# set requisite number of rows,and start filling
self.table.setRowCount(len(model.groupings))
for irow, group in enumerate(model.groupings):
self.table.setItem(irow, 0, QTableWidgetItem(group.name))
if group is model.selgroup:
self._irow_selgroup = irow
# total # source in group: skip for "current"
if group is not model.curgroup:
self.table.setItem(irow, 1, QTableWidgetItem(str(group.total)))
# selection controls: skip for current and selection
if group not in (model.curgroup, model.selgroup):
btns = QWidget()
lo = QHBoxLayout(btns)
lo.setContentsMargins(0, 0, 0, 0)
lo.setSpacing(0)
# make selector buttons (depending on which group we're in)
if group is model.defgroup:
Buttons = (
("+", lambda src, grp=group: True, "select all sources"),
("-", lambda src, grp=group: False, "unselect all sources"))
else:
Buttons = (
("=", lambda src, grp=group: grp.func(src), "select only this grouping"),
("+", lambda src, grp=group: src.selected or grp.func(src), "add grouping to selection"),
("-", lambda src, grp=group: src.selected and not grp.func(src),
"remove grouping from selection"),
("&&", lambda src, grp=group: src.selected and grp.func(src),
"intersect selection with grouping"))
lo.addStretch(1)
for label, predicate, tooltip in Buttons:
btn = QToolButton(btns)
btn.setText(label)
btn.setMinimumWidth(24)
btn.setMaximumWidth(24)
btn.setToolTip(tooltip)
lo.addWidget(btn)
# add callback
QObject.connect(btn, SIGNAL("clicked()"), self._currier.curry(self.selectSources, predicate))
lo.addStretch(1)
self.table.setCellWidget(irow, 2, btns)
# "list" checkbox (not for current and selected groupings: these are always listed)
if group not in (model.curgroup, model.selgroup):
item = self._makeCheckItem("", group, "show_list")
self.table.setItem(irow, self.ColList, item)
item.setToolTip("""<P>If checked, sources in this grouping will be listed in the source table. If un-checked, sources will be
excluded from the table. If partially checked, then the default list/no list setting of "all sources" will be in effect.
</P>""")
# "plot" checkbox (not for the current grouping, since that's always plotted)
if group is not model.curgroup:
item = self._makeCheckItem("", group, "show_plot")
self.table.setItem(irow, self.ColPlot, item)
item.setToolTip("""<P>If checked, sources in this grouping will be included in the plot. If un-checked, sources will be
excluded from the plot. If partially checked, then the default plot/no plot setting of "all sources" will be in effect.
</P>""")
# custom style control
# for default, current and selected, this is just a text label
if group is model.defgroup:
item = QTableWidgetItem("default:")
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setToolTip(
"""<P>This is the default plot style used for all sources for which a custom grouping style is not selected.</P>""")
self.table.setItem(irow, self.ColApply, item)
elif group is model.curgroup:
item = QTableWidgetItem("")
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setToolTip("""<P>This is the plot style used for the highlighted source, if any.</P>""")
self.table.setItem(irow, self.ColApply, item)
elif group is model.selgroup:
item = QTableWidgetItem("")
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setToolTip("""<P>This is the plot style used for the currently selected sources.</P>""")
self.table.setItem(irow, self.ColApply, item)
# for the rest, a combobox with custom priorities
else:
cb = QComboBox()
cb.addItems(["default"] + ["custom %d" % p for p in range(1, 10)])
index = max(0, min(group.style.apply, 9))
# dprint(0,group.name,"apply",index)
cb.setCurrentIndex(index)
QObject.connect(cb, SIGNAL("activated(int)"),
self._currier.xcurry(self._valueChanged, (irow, self.ColApply)))
self.table.setCellWidget(irow, self.ColApply, cb)
cb.setToolTip("""<P>This controls whether sources within this group are plotted with a customized
plot style. Customized styles have numeric priority; if a source belongs to multiple groups, then
the style with the lowest priority takes precedence.<P>""")
# attribute comboboxes
for icol, attr in self.AttrByCol.items():
# get list of options for this style attribute. If dealing with first grouping (i==0), which is
# the "all sources" grouping, then remove the "default" option (which is always first in the list)
options = PlotStyles.StyleAttributeOptions[attr]
if irow == 0:
options = options[1:]
# make combobox
cb = QComboBox()
cb.addItems(list(map(str, options)))
# the "label" option is also editable
if attr == "label":
cb.setEditable(True)
try:
index = options.index(getattr(group.style, attr))
cb.setCurrentIndex(index)
except ValueError:
cb.setEditText(str(getattr(group.style, attr)))
slot = self._currier.xcurry(self._valueChanged, (irow, icol))
QObject.connect(cb, SIGNAL("activated(int)"), slot)
QObject.connect(cb, SIGNAL("editTextChanged(const QString &)"), slot)
cb.setEnabled(group is model.defgroup or group.style.apply)
self.table.setCellWidget(irow, icol, cb)
label = attr
if irow:
cb.setToolTip("""<P>This is the %s used to plot sources in this group, when a "custom" style for the group
is enabled via the style control.<P>""" % label)
else:
cb.setToolTip(
"<P>This is the default %s used for all sources for which a custom style is not specified below.<P>" % label)
self.table.resizeColumnsToContents()
# re-enable processing of cellChanged() signals
self._setting_model = False
class RuleEditor(QDialog): # {{{
def __init__(self, fm, parent=None):
QDialog.__init__(self, parent)
self.fm = fm
self.setWindowIcon(QIcon(I('format-fill-color.png')))
self.setWindowTitle(_('Create/edit a column coloring rule'))
self.l = l = QGridLayout(self)
self.setLayout(l)
self.l1 = l1 = QLabel(_('Create a coloring rule by'
' filling in the boxes below'))
l.addWidget(l1, 0, 0, 1, 5)
self.f1 = QFrame(self)
self.f1.setFrameShape(QFrame.HLine)
l.addWidget(self.f1, 1, 0, 1, 5)
self.l2 = l2 = QLabel(_('Set the color of the column:'))
l.addWidget(l2, 2, 0)
self.column_box = QComboBox(self)
l.addWidget(self.column_box, 2, 1)
self.l3 = l3 = QLabel(_('to'))
l.addWidget(l3, 2, 2)
self.color_box = QComboBox(self)
self.color_label = QLabel('Sample text Sample text')
self.color_label.setTextFormat(Qt.RichText)
l.addWidget(self.color_box, 2, 3)
l.addWidget(self.color_label, 2, 4)
l.addItem(QSpacerItem(10, 10, QSizePolicy.Expanding), 2, 5)
self.l4 = l4 = QLabel(
_('Only if the following conditions are all satisfied:'))
l.addWidget(l4, 3, 0, 1, 6)
self.scroll_area = sa = QScrollArea(self)
sa.setMinimumHeight(300)
sa.setMinimumWidth(950)
sa.setWidgetResizable(True)
l.addWidget(sa, 4, 0, 1, 6)
self.add_button = b = QPushButton(QIcon(I('plus.png')),
_('Add another condition'))
l.addWidget(b, 5, 0, 1, 6)
b.clicked.connect(self.add_blank_condition)
self.l5 = l5 = QLabel(_('You can disable a condition by'
' blanking all of its boxes'))
l.addWidget(l5, 6, 0, 1, 6)
self.bb = bb = QDialogButtonBox(
QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
l.addWidget(bb, 7, 0, 1, 6)
self.conditions_widget = QWidget(self)
sa.setWidget(self.conditions_widget)
self.conditions_widget.setLayout(QVBoxLayout())
self.conditions_widget.layout().setAlignment(Qt.AlignTop)
self.conditions = []
for b in (self.column_box, self.color_box):
b.setSizeAdjustPolicy(b.AdjustToMinimumContentsLengthWithIcon)
b.setMinimumContentsLength(15)
for key in sorted(
displayable_columns(fm),
key=sort_key):
name = fm[key]['name']
if name:
self.column_box.addItem(key, key)
self.column_box.setCurrentIndex(0)
self.color_box.addItems(QColor.colorNames())
self.color_box.setCurrentIndex(0)
self.update_color_label()
self.color_box.currentIndexChanged.connect(self.update_color_label)
self.resize(self.sizeHint())
def update_color_label(self):
pal = QApplication.palette()
bg1 = unicode(pal.color(pal.Base).name())
bg2 = unicode(pal.color(pal.AlternateBase).name())
c = unicode(self.color_box.currentText())
self.color_label.setText('''
<span style="color: {c}; background-color: {bg1}"> {st} </span>
<span style="color: {c}; background-color: {bg2}"> {st} </span>
'''.format(c=c, bg1=bg1, bg2=bg2, st=_('Sample Text')))
def add_blank_condition(self):
c = ConditionEditor(self.fm, parent=self.conditions_widget)
self.conditions.append(c)
self.conditions_widget.layout().addWidget(c)
def apply_rule(self, col, rule):
for i in range(self.column_box.count()):
c = unicode(self.column_box.itemData(i).toString())
if col == c:
self.column_box.setCurrentIndex(i)
break
if rule.color:
idx = self.color_box.findText(rule.color)
if idx >= 0:
self.color_box.setCurrentIndex(idx)
for c in rule.conditions:
ce = ConditionEditor(self.fm, parent=self.conditions_widget)
self.conditions.append(ce)
self.conditions_widget.layout().addWidget(ce)
try:
ce.condition = c
except:
import traceback
traceback.print_exc()
def accept(self):
if self.validate():
QDialog.accept(self)
def validate(self):
r = Rule(self.fm)
for c in self.conditions:
condition = c.condition
if condition is not None:
try:
r.add_condition(*condition)
except Exception as e:
import traceback
error_dialog(self, _('Invalid condition'),
_('One of the conditions for this rule is'
' invalid: <b>%s</b>')%e,
det_msg=traceback.format_exc(), show=True)
return False
if len(r.conditions) < 1:
error_dialog(self, _('No conditions'),
_('You must specify at least one non-empty condition'
' for this rule'), show=True)
return False
return True
@property
def rule(self):
r = Rule(self.fm)
r.color = unicode(self.color_box.currentText())
idx = self.column_box.currentIndex()
col = unicode(self.column_box.itemData(idx).toString())
for c in self.conditions:
condition = c.condition
if condition is not None:
r.add_condition(*condition)
return col, r
class EditResidues_PropertyManager(Command_PropertyManager):
"""
The ProteinDisplayStyle_PropertyManager class provides a Property Manager
for the B{Display Style} command on the flyout toolbar in the
Build > Protein mode.
@ivar title: The title that appears in the property manager header.
@type title: str
@ivar pmName: The name of this property manager. This is used to set
the name of the PM_Dialog object via setObjectName().
@type name: str
@ivar iconPath: The relative path to the PNG file that contains a
22 x 22 icon image that appears in the PM header.
@type iconPath: str
"""
title = "Edit Residues"
pmName = title
iconPath = "ui/actions/Command Toolbar/BuildProtein/Residues.png"
rosetta_all_set = "PGAVILMFWYCSTNQDEHKR"
rosetta_polar_set = "___________STNQDEHKR"
rosetta_apolar_set = "PGAVILMFWYC_________"
def __init__( self, command ):
"""
Constructor for the property manager.
"""
self.currentWorkingDirectory = env.prefs[workingDirectory_prefs_key]
_superclass.__init__(self, command)
self.sequenceEditor = self.win.createProteinSequenceEditorIfNeeded()
self.showTopRowButtons( PM_DONE_BUTTON | \
PM_WHATS_THIS_BUTTON)
self.editingItem = False
return
def connect_or_disconnect_signals(self, isConnect = True):
if isConnect:
change_connect = self.win.connect
else:
change_connect = self.win.disconnect
change_connect(self.applyAnyPushButton,
SIGNAL("clicked()"),
self._applyAny)
change_connect(self.applySamePushButton,
SIGNAL("clicked()"),
self._applySame)
change_connect(self.applyLockedPushButton,
SIGNAL("clicked()"),
self._applyLocked)
change_connect(self.applyPolarPushButton,
SIGNAL("clicked()"),
self._applyPolar)
change_connect(self.applyApolarPushButton,
SIGNAL("clicked()"),
self._applyApolar)
change_connect(self.selectAllPushButton,
SIGNAL("clicked()"),
self._selectAll)
change_connect(self.selectNonePushButton,
SIGNAL("clicked()"),
self._selectNone)
change_connect(self.selectInvertPushButton,
SIGNAL("clicked()"),
self._invertSelection)
change_connect(self.applyDescriptorPushButton,
SIGNAL("clicked()"),
self._applyDescriptor)
change_connect(self.removeDescriptorPushButton,
SIGNAL("clicked()"),
self._removeDescriptor)
change_connect(self.sequenceTable,
SIGNAL("cellClicked(int, int)"),
self._sequenceTableCellChanged)
change_connect(self.sequenceTable,
SIGNAL("itemChanged(QTableWidgetItem*)"),
self._sequenceTableItemChanged)
change_connect(self.descriptorsTable,
SIGNAL("itemChanged(QTableWidgetItem*)"),
self._descriptorsTableItemChanged)
change_connect(self.newDescriptorPushButton,
SIGNAL("clicked()"),
self._addNewDescriptor)
change_connect(self.showSequencePushButton,
SIGNAL("clicked()"),
self._showSeqEditor)
return
def _showSeqEditor(self):
"""
Shows sequence editor
"""
if self.showSequencePushButton.isEnabled():
self.sequenceEditor.show()
return
def show(self):
"""
Shows the Property Manager. Extends superclass method.
"""
env.history.statusbar_msg("")
#Urmi 20080728: Set the current protein and this will be used for accessing
#various properties of this protein
self.set_current_protein()
if self.current_protein:
msg = "Editing structure <b>%s</b>." % self.current_protein.name
self.showSequencePushButton.setEnabled(True)
else:
msg = "Select a single structure to edit."
self.showSequencePushButton.setEnabled(False)
self.sequenceEditor.hide()
_superclass.show(self)
self._fillSequenceTable()
self.updateMessage(msg)
return
def set_current_protein(self):
"""
Set the current protein for which all the properties are displayed to the
one chosen in the build protein combo box
"""
self.current_protein = self.win.assy.getSelectedProteinChunk()
return
def _addGroupBoxes( self ):
"""
Add the Property Manager group boxes.
"""
if sys.platform == "darwin":
# Workaround for table font size difference between Mac/Win
self.labelfont = QFont("Helvetica", 12)
self.descriptorfont = QFont("Courier New", 12)
else:
self.labelfont = QFont("Helvetica", 9)
self.descriptorfont = QFont("Courier New", 9)
self._pmGroupBox1 = PM_GroupBox( self,
title = "Descriptors")
self._loadGroupBox1( self._pmGroupBox1 )
self._pmGroupBox2 = PM_GroupBox( self,
title = "Sequence")
self._loadGroupBox2( self._pmGroupBox2 )
def _loadGroupBox1(self, pmGroupBox):
"""
Load widgets in the first group box.
"""
self.headerdata_desc = ['Name', 'Descriptor']
self.set_names = ["Any", "Same", "Locked", "Apolar", "Polar"]
self.rosetta_set_names = ["ALLAA", "NATAA", "NATRO", "APOLA", "POLAR"]
self.descriptor_list = ["PGAVILMFWYCSTNQDEHKR",
"____________________",
"____________________",
"PGAVILMFWYC_________",
"___________STNQDEHKR"]
self.applyAnyPushButton = PM_PushButton( pmGroupBox,
text = "ALLAA",
setAsDefault = True)
self.applySamePushButton = PM_PushButton( pmGroupBox,
text = "NATAA",
setAsDefault = True)
self.applyLockedPushButton = PM_PushButton( pmGroupBox,
text = "NATRO",
setAsDefault = True)
self.applyPolarPushButton = PM_PushButton( pmGroupBox,
text = "APOLA",
setAsDefault = True)
self.applyApolarPushButton = PM_PushButton( pmGroupBox,
text = "POLAR",
setAsDefault = True)
#self.applyBackrubPushButton = PM_PushButton( pmGroupBox,
# text = "BACKRUB",
# setAsDefault = True)
self.applyAnyPushButton.setFixedHeight(25)
self.applyAnyPushButton.setFixedWidth(60)
self.applySamePushButton.setFixedHeight(25)
self.applySamePushButton.setFixedWidth(60)
self.applyLockedPushButton.setFixedHeight(25)
self.applyLockedPushButton.setFixedWidth(60)
self.applyPolarPushButton.setFixedHeight(25)
self.applyPolarPushButton.setFixedWidth(60)
self.applyApolarPushButton.setFixedHeight(25)
self.applyApolarPushButton.setFixedWidth(60)
applyButtonList = [
('PM_PushButton', self.applyAnyPushButton, 0, 0),
('PM_PushButton', self.applySamePushButton, 1, 0),
('PM_PushButton', self.applyLockedPushButton, 2, 0),
('PM_PushButton', self.applyPolarPushButton, 3, 0),
('PM_PushButton', self.applyApolarPushButton, 4, 0) ]
self.applyButtonGrid = PM_WidgetGrid( pmGroupBox,
label = "Apply standard set",
widgetList = applyButtonList)
self.descriptorsTable = PM_TableWidget( pmGroupBox,
label = "Custom descriptors")
self.descriptorsTable.setFixedHeight(100)
self.descriptorsTable.setRowCount(0)
self.descriptorsTable.setColumnCount(2)
self.descriptorsTable.verticalHeader().setVisible(False)
self.descriptorsTable.horizontalHeader().setVisible(True)
self.descriptorsTable.setGridStyle(Qt.NoPen)
self.descriptorsTable.setHorizontalHeaderLabels(self.headerdata_desc)
self._updateSetLists()
self._fillDescriptorsTable()
self.descriptorsTable.resizeColumnsToContents()
self.newDescriptorPushButton = PM_PushButton( pmGroupBox,
text = "New",
setAsDefault = True)
self.newDescriptorPushButton.setFixedHeight(25)
self.removeDescriptorPushButton = PM_PushButton( pmGroupBox,
text = "Remove",
setAsDefault = True)
self.removeDescriptorPushButton.setFixedHeight(25)
self.applyDescriptorPushButton = PM_PushButton( pmGroupBox,
text = "Apply",
setAsDefault = True)
self.applyDescriptorPushButton.setFixedHeight(25)
addDescriptorButtonList = [('PM_PushButton', self.newDescriptorPushButton, 0, 0),
('PM_PushButton', self.removeDescriptorPushButton, 1, 0),
('PM_PushButton', self.applyDescriptorPushButton, 2, 0) ]
self.addDescriptorGrid = PM_WidgetGrid( pmGroupBox,
alignment = "Center",
widgetList = addDescriptorButtonList)
def _loadGroupBox2(self, pmGroupBox):
"""
Load widgets in the second group box.
"""
self.headerdata_seq = ['', 'ID', 'Set', 'BR', 'Descriptor']
self.recenterViewCheckBox = \
PM_CheckBox( pmGroupBox,
text = "Re-center view on selected residue",
setAsDefault = True,
widgetColumn = 0,
state = Qt.Unchecked)
self.selectAllPushButton = PM_PushButton( pmGroupBox,
text = "All",
setAsDefault = True)
self.selectAllPushButton.setFixedHeight(25)
self.selectNonePushButton = PM_PushButton( pmGroupBox,
text = "None",
setAsDefault = True)
self.selectNonePushButton.setFixedHeight(25)
self.selectInvertPushButton = PM_PushButton( pmGroupBox,
text = "Invert",
setAsDefault = True)
self.selectInvertPushButton.setFixedHeight(25)
buttonList = [ ('PM_PushButton', self.selectAllPushButton, 0, 0),
('PM_PushButton', self.selectNonePushButton, 1, 0),
('PM_PushButton', self.selectInvertPushButton, 2, 0)]
self.buttonGrid = PM_WidgetGrid( pmGroupBox,
widgetList = buttonList)
self.sequenceTable = PM_TableWidget( pmGroupBox)
#self.sequenceTable.setModel(self.tableModel)
self.sequenceTable.resizeColumnsToContents()
self.sequenceTable.verticalHeader().setVisible(False)
#self.sequenceTable.setRowCount(0)
self.sequenceTable.setColumnCount(5)
self.checkbox = QCheckBox()
self.sequenceTable.setFixedHeight(345)
self.sequenceTable.setGridStyle(Qt.NoPen)
self.sequenceTable.setHorizontalHeaderLabels(self.headerdata_seq)
###self._fillSequenceTable()
self.showSequencePushButton = PM_PushButton( pmGroupBox,
text = "Show Sequence",
setAsDefault = True,
spanWidth = True)
def _addWhatsThisText( self ):
#from ne1_ui.WhatsThisText_for_PropertyManagers import WhatsThis_EditResidues_PropertyManager
#WhatsThis_EditResidues_PropertyManager(self)
pass
def _addToolTipText(self):
#from ne1_ui.ToolTipText_for_PropertyManagers import ToolTip_EditProteinDisplayStyle_PropertyManager
#ToolTip_EditProteinDisplayStyle_PropertyManager(self)
pass
def _fillSequenceTable(self):
"""
Fills in the sequence table.
"""
if not self.current_protein:
return
else:
currentProteinChunk = self.current_protein
self.editingItem = True
aa_list = currentProteinChunk.protein.get_amino_acids()
aa_list_len = len(aa_list)
self.sequenceTable.setRowCount(aa_list_len)
for index in range(aa_list_len):
# Selection checkbox column
item_widget = QTableWidgetItem("")
item_widget.setFont(self.labelfont)
item_widget.setCheckState(Qt.Checked)
item_widget.setTextAlignment(Qt.AlignLeft)
item_widget.setSizeHint(QSize(20,12))
item_widget.setFlags(Qt.ItemIsSelectable |
Qt.ItemIsEnabled |
Qt.ItemIsUserCheckable)
self.sequenceTable.setItem(index, 0, item_widget)
# Amino acid index column
item_widget = QTableWidgetItem(str(index+1))
item_widget.setFont(self.labelfont)
item_widget.setFlags(
Qt.ItemIsSelectable |
Qt.ItemIsEnabled)
item_widget.setTextAlignment(Qt.AlignCenter)
self.sequenceTable.setItem(index, 1, item_widget)
# Mutation descriptor name column
aa = self._get_aa_for_index(index)
item_widget = QTableWidgetItem(self._get_descriptor_name(aa))
item_widget.setFont(self.labelfont)
item_widget.setFlags(Qt.ItemIsSelectable |
Qt.ItemIsEnabled)
item_widget.setTextAlignment(Qt.AlignCenter)
self.sequenceTable.setItem(index, 2, item_widget)
# Backrub checkbox column
item_widget = QTableWidgetItem("")
item_widget.setFont(self.labelfont)
if aa.get_backrub_mode():
item_widget.setCheckState(Qt.Checked)
else:
item_widget.setCheckState(Qt.Unchecked)
item_widget.setTextAlignment(Qt.AlignLeft)
item_widget.setSizeHint(QSize(20,12))
item_widget.setFlags(Qt.ItemIsSelectable |
Qt.ItemIsEnabled |
Qt.ItemIsUserCheckable)
self.sequenceTable.setItem(index, 3, item_widget)
# Mutation descriptor column
aa_string = self._get_mutation_descriptor(aa)
item_widget = QTableWidgetItem(aa_string)
item_widget.setFont(self.descriptorfont)
self.sequenceTable.setItem(index, 4, item_widget)
self.sequenceTable.setRowHeight(index, 16)
self.editingItem = False
self.sequenceTable.resizeColumnsToContents()
self.sequenceTable.setColumnWidth(0, 35)
self.sequenceTable.setColumnWidth(2, 80)
self.sequenceTable.setColumnWidth(3, 35)
return
def _fillDescriptorsTable(self):
"""
Fills in the descriptors table from descriptors user pref.
"""
dstr = env.prefs[proteinCustomDescriptors_prefs_key].split(":")
for i in range(len(dstr) / 2):
self._addNewDescriptorTableRow(dstr[2*i], dstr[2*i+1])
def _selectAll(self):
"""
Select all rows in the sequence table.
"""
for row in range(self.sequenceTable.rowCount()):
self.sequenceTable.item(row, 0).setCheckState(Qt.Checked)
def _selectNone(self):
"""
Unselect all rows in the sequence table.
"""
for row in range(self.sequenceTable.rowCount()):
self.sequenceTable.item(row, 0).setCheckState(Qt.Unchecked)
def _invertSelection(self):
"""
Inverto row selection range in the sequence table.
"""
for row in range(self.sequenceTable.rowCount()):
item_widget = self.sequenceTable.item(row, 0)
if item_widget.checkState() == Qt.Checked:
item_widget.setCheckState(Qt.Unchecked)
else:
item_widget.setCheckState(Qt.Checked)
def _get_mutation_descriptor(self, aa):
"""
Get mutation descriptor string for a given amino acid.
"""
aa_string = self.rosetta_all_set
range = aa.get_mutation_range()
aa_string = self.rosetta_all_set
if range == "NATRO" or \
range == "NATAA":
code = aa.get_one_letter_code()
aa_string = re.sub("[^"+code+"]",'_', aa_string)
elif range == "POLAR":
aa_string = self.rosetta_polar_set
elif range == "APOLA":
aa_string = self.rosetta_apolar_set
elif range == "PIKAA":
aa_string = aa.get_mutation_descriptor()
return aa_string
def _get_descriptor_name(self, aa):
"""
Returns a mutation descriptor name for an amino acid.
"""
range_name = aa.get_mutation_range()
for i in range(len(self.rosetta_set_names)):
if range_name == self.rosetta_set_names[i]:
if range_name == "PIKAA":
# Find a descriptor with a list of
# custom descriptors.
dstr = self._makeProperAAString(aa.get_mutation_descriptor())
for i in range(5, len(self.descriptor_list)):
if dstr == self.descriptor_list[i]:
return self.set_names[i]
else:
return self.set_names[i]
return "Custom"
def _get_aa_for_index(self, index, expand = False):
"""
Get amino acid by index.
@return: amino acid (Residue)
"""
if not self.current_protein:
return None
else:
currentProteinChunk = self.current_protein
currentProteinChunk.protein.set_current_amino_acid_index(index)
current_aa = currentProteinChunk.protein.get_current_amino_acid()
if expand:
currentProteinChunk.protein.collapse_all_rotamers()
currentProteinChunk.protein.expand_rotamer(current_aa)
return current_aa
def _sequenceTableCellChanged(self, crow, ccol):
"""
Slot for sequence table CellChanged event.
"""
item = self.sequenceTable.item(crow, ccol)
for row in range(self.sequenceTable.rowCount()):
self.sequenceTable.removeCellWidget(row, 2)
self.sequenceTable.setRowHeight(row, 16)
if ccol == 2:
# Make the row a little bit wider.
self.sequenceTable.setRowHeight(crow, 22)
# Create and insert a Combo Box into a current cell.
self.setComboBox = QComboBox()
self.setComboBox.addItems(self.set_names)
self.win.connect(self.setComboBox,
SIGNAL("activated(int)"),
self._setComboBoxIndexChanged)
self.sequenceTable.setCellWidget(crow, 2, self.setComboBox)
current_aa = self._get_aa_for_index(crow, expand=True)
if current_aa:
# Center on the selected amino acid.
if self.recenterViewCheckBox.isChecked():
ca_atom = current_aa.get_c_alpha_atom()
if ca_atom:
self.win.glpane.pov = -ca_atom.posn()
self.win.glpane.gl_update()
# Update backrub status for selected amino acid.
if ccol == 3:
cbox = self.sequenceTable.item(crow, 3)
if cbox.checkState() == Qt.Checked:
current_aa.set_backrub_mode(True)
else:
current_aa.set_backrub_mode(False)
from PyQt4.Qt import QTextCursor
cursor = self.sequenceEditor.sequenceTextEdit.textCursor()
#boundary condition
if crow == -1:
crow = 0
cursor.setPosition(crow, QTextCursor.MoveAnchor)
cursor.setPosition(crow + 1, QTextCursor.KeepAnchor)
self.sequenceEditor.sequenceTextEdit.setTextCursor( cursor )
def _applyDescriptor(self):
"""
Apply mutation descriptor to the selected amino acids.
"""
cdes = self.descriptorsTable.currentRow()
for row in range(self.sequenceTable.rowCount()):
self._setComboBoxIndexChanged(cdes + 5, tablerow = row, selectedOnly = True)
def _setComboBoxIndexChanged( self, index, tablerow = None, selectedOnly = False):
"""
Slot for mutation descriptor combo box (in third column of the sequence
table.)
"""
if tablerow is None:
crow = self.sequenceTable.currentRow()
else:
crow = tablerow
item = self.sequenceTable.item(crow, 2)
if item:
self.editingItem = True
cbox = self.sequenceTable.item(crow, 0)
if not selectedOnly or \
cbox.checkState() == Qt.Checked:
item.setText(self.set_names[index])
item = self.sequenceTable.item(crow, 4)
aa = self._get_aa_for_index(crow)
set_name = self.rosetta_set_names[index]
aa.set_mutation_range(set_name)
if set_name == "PIKAA":
aa.set_mutation_descriptor(self.descriptor_list[index])
item.setText(self._get_mutation_descriptor(aa))
for row in range(self.sequenceTable.rowCount()):
self.sequenceTable.removeCellWidget(row, 2)
self.sequenceTable.setRowHeight(row, 16)
self.editingItem = False
def scrollToPosition(self, index):
"""
Scrolls the Sequence Table to a given sequence position.
"""
item = self.sequenceTable.item(index, 0)
if item:
self.sequenceTable.scrollToItem(item)
def _applyAny(self):
"""
Apply "ALLAA" descriptor.
"""
for row in range(self.sequenceTable.rowCount()):
self._setComboBoxIndexChanged(0, tablerow = row, selectedOnly = True)
def _applySame(self):
"""
Apply "NATAA" descriptor.
"""
for row in range(self.sequenceTable.rowCount()):
self._setComboBoxIndexChanged(1, tablerow = row, selectedOnly = True)
def _applyLocked(self):
"""
Apply "NATRO" descriptor.
"""
for row in range(self.sequenceTable.rowCount()):
self._setComboBoxIndexChanged(2, tablerow = row, selectedOnly = True)
def _applyPolar(self):
"""
Apply "POLAR" descriptor.
"""
for row in range(self.sequenceTable.rowCount()):
self._setComboBoxIndexChanged(3, tablerow = row, selectedOnly = True)
def _applyApolar(self):
"""
Apply "APOLA" descriptor.
"""
for row in range(self.sequenceTable.rowCount()):
self._setComboBoxIndexChanged(4, tablerow = row, selectedOnly = True)
def resizeEvent(self, event):
"""
Called whenever PM width has changed. Sets correct width of the
rows in descriptor and sequence tables.
"""
self.descriptorsTable.setColumnWidth(1,
self.descriptorsTable.width()-self.descriptorsTable.columnWidth(0)-20)
self.sequenceTable.setColumnWidth(4,
self.sequenceTable.width()-
(self.sequenceTable.columnWidth(0) +
self.sequenceTable.columnWidth(1) +
self.sequenceTable.columnWidth(2) +
self.sequenceTable.columnWidth(3))-20)
def _addNewDescriptorTableRow(self, name, descriptor):
"""
Adds a new row to the descriptor table.
"""
row = self.descriptorsTable.rowCount()
self.descriptorsTable.insertRow(row)
item_widget = QTableWidgetItem(name)
item_widget.setFont(self.labelfont)
item_widget.setFlags(Qt.ItemIsSelectable |
Qt.ItemIsEnabled |
Qt.ItemIsEditable)
item_widget.setTextAlignment(Qt.AlignLeft)
self.descriptorsTable.setItem(row, 0, item_widget)
self.descriptorsTable.resizeColumnToContents(0)
s = self._makeProperAAString(descriptor)
item_widget = QTableWidgetItem(s)
item_widget.setFont(self.descriptorfont)
item_widget.setFlags(Qt.ItemIsSelectable |
Qt.ItemIsEnabled |
Qt.ItemIsEditable)
item_widget.setTextAlignment(Qt.AlignLeft)
self.descriptorsTable.setItem(row, 1, item_widget)
self.descriptorsTable.setColumnWidth(1,
self.descriptorsTable.width()-self.descriptorsTable.columnWidth(0)-20)
self.descriptorsTable.setRowHeight(row, 16)
def _addNewDescriptor(self):
"""
Adds a new descriptor to the descriptor table.
"""
self._addNewDescriptorTableRow("New Set", "PGAVILMFWYCSTNQDEHKR")
self._makeDescriptorUserPref()
self._updateSetLists()
def _removeDescriptor(self):
"""
Removes a highlighted descriptor from the descriptors table.
"""
crow = self.descriptorsTable.currentRow()
if crow >= 0:
self.descriptorsTable.removeRow(crow)
self._makeDescriptorUserPref()
self._updateSetLists()
def _makeDescriptorUserPref(self):
"""
Constructs a custom descriptors string.
"""
dstr = ""
for row in range(self.descriptorsTable.rowCount()):
item0 = self.descriptorsTable.item(row, 0)
item1 = self.descriptorsTable.item(row, 1)
if item0 and \
item1:
dstr += item0.text() + \
":" + \
item1.text() + \
":"
env.prefs[proteinCustomDescriptors_prefs_key] = dstr
def _makeProperAAString(self, string):
"""
Creates a proper amino acid string from an arbitrary string.
"""
aa_string = str(string).upper()
new_aa_string = ""
for i in range(len(self.rosetta_all_set)):
if aa_string.find(self.rosetta_all_set[i]) == -1:
new_aa_string += "_"
else:
new_aa_string += self.rosetta_all_set[i]
return new_aa_string
def _sequenceTableItemChanged(self, item):
"""
Called when an item in the sequence table has changed.
"""
if self.editingItem:
return
if self.sequenceTable.column(item) == 4:
self.editingItem = True
crow = self.sequenceTable.currentRow()
dstr = self._makeProperAAString(str(item.text()).upper())
item.setText(dstr)
aa = self._get_aa_for_index(crow)
if aa:
aa.set_mutation_range("PIKAA")
aa.set_mutation_descriptor(dstr.replace("_",""))
item = self.sequenceTable.item(crow, 2)
if item:
item.setText("Custom")
self.editingItem = False
def _descriptorsTableItemChanged(self, item):
"""
Called when an item in the descriptors table has changed.
"""
if self.editingItem:
return
if self.descriptorsTable.column(item) == 1:
self.editingItem = True
item.setText(self._makeProperAAString(str(item.text()).upper()))
self.editingItem = False
self._makeDescriptorUserPref()
self._updateSetLists()
def _updateSetLists(self):
"""
Updates lists of descriptor sets and descriptor set names.
"""
self.set_names = self.set_names[:5]
self.descriptor_list = self.descriptor_list[:5]
self.rosetta_set_names = self.rosetta_set_names[:5]
dstr = env.prefs[proteinCustomDescriptors_prefs_key].split(":")
for i in range(len(dstr) / 2):
self.set_names.append(dstr[2*i])
self.descriptor_list.append(dstr[2*i+1])
self.rosetta_set_names.append("PIKAA")
#self._addNewDescriptorTableRow(dstr[2*i], dstr[2*i+1])
return
def _update_UI_do_updates_TEMP(self):
"""
Overrides superclass method.
@see: Command_PropertyManager._update_UI_do_updates()
"""
self.current_protein = self.win.assy.getSelectedProteinChunk()
if self.current_protein is self.previous_protein:
print "_update_UI_do_updates(): DO NOTHING."
return
# NOTE: Changing the display styles of the protein chunks can take some
# time. We should put up the wait (hourglass) cursor here and restore
# before returning.
# Update all PM widgets that need to be since something has changed.
print "_update_UI_do_updates(): UPDATING the PMGR."
self.update_name_field()
self.sequenceEditor.update()
self.update_residue_combobox()
if self.previous_protein:
self.previous_protein.setDisplayStyle(self.previous_protein_display_style)
self.previous_protein = self.current_protein
if self.current_protein:
self.previous_protein_display_style = self.current_protein.getDisplayStyle()
self.current_protein.setDisplayStyle(diPROTEIN)
return
class ImageControlDialog(QDialog):
def __init__(self, parent, rc, imgman):
"""An ImageControlDialog is initialized with a parent widget, a RenderControl object,
and an ImageManager object"""
QDialog.__init__(self, parent)
image = rc.image
self.setWindowTitle("%s: Colour Controls" % image.name)
self.setWindowIcon(pixmaps.colours.icon())
self.setModal(False)
self.image = image
self._rc = rc
self._imgman = imgman
self._currier = PersistentCurrier()
# init internal state
self._prev_range = self._display_range = None, None
self._hist = None
self._geometry = None
# create layouts
lo0 = QVBoxLayout(self)
# lo0.setContentsMargins(0,0,0,0)
# histogram plot
whide = self.makeButton("Hide", self.hide, width=128)
whide.setShortcut(Qt.Key_F9)
lo0.addWidget(Separator(self, "Histogram and ITF", extra_widgets=[whide]))
lo1 = QHBoxLayout()
lo1.setContentsMargins(0, 0, 0, 0)
self._histplot = QwtPlot(self)
self._histplot.setAutoDelete(False)
lo1.addWidget(self._histplot, 1)
lo2 = QHBoxLayout()
lo2.setContentsMargins(0, 0, 0, 0)
lo2.setSpacing(2)
lo0.addLayout(lo2)
lo0.addLayout(lo1)
self._wautozoom = QCheckBox("autozoom", self)
self._wautozoom.setChecked(True)
self._wautozoom.setToolTip("""<P>If checked, then the histrogram plot will zoom in automatically when
you narrow the current intensity range.</P>""")
self._wlogy = QCheckBox("log Y", self)
self._wlogy.setChecked(True)
self._ylogscale = True
self._wlogy.setToolTip(
"""<P>If checked, a log-scale Y axis is used for the histogram plot instead of a linear one.""")
QObject.connect(self._wlogy, SIGNAL("toggled(bool)"), self._setHistLogScale)
self._whistunzoom = self.makeButton("", self._unzoomHistogram, icon=pixmaps.full_range.icon())
self._whistzoomout = self.makeButton("-", self._currier.curry(self._zoomHistogramByFactor, math.sqrt(.1)))
self._whistzoomin = self.makeButton("+", self._currier.curry(self._zoomHistogramByFactor, math.sqrt(10)))
self._whistzoomin.setToolTip("""<P>Click to zoom into the histogram plot by one step. This does not
change the current intensity range.</P>""")
self._whistzoomout.setToolTip("""<P>Click to zoom out of the histogram plot by one step. This does not
change the current intensity range.</P>""")
self._whistunzoom.setToolTip("""<P>Click to reset the histogram plot back to its full extent.
This does not change the current intensity range.</P>""")
self._whistzoom = QwtWheel(self)
self._whistzoom.setOrientation(Qt.Horizontal)
self._whistzoom.setMaximumWidth(80)
self._whistzoom.setRange(10, 0)
self._whistzoom.setStep(0.1)
self._whistzoom.setTickCnt(30)
self._whistzoom.setTracking(False)
QObject.connect(self._whistzoom, SIGNAL("valueChanged(double)"), self._zoomHistogramFinalize)
QObject.connect(self._whistzoom, SIGNAL("sliderMoved(double)"), self._zoomHistogramPreview)
self._whistzoom.setToolTip("""<P>Use this wheel control to zoom in/out of the histogram plot.
This does not change the current intensity range.
Note that the zoom wheel should also respond to your mouse wheel, if you have one.</P>""")
# This works around a stupid bug in QwtSliders -- when using the mousewheel, only sliderMoved() signals are emitted,
# with no final valueChanged(). If we want to do a fast preview of something on sliderMoved(), and a "slow" final
# step on valueChanged(), we're in trouble. So we start a timer on sliderMoved(), and if the timer expires without
# anything else happening, do a valueChanged().
# Here we use a timer to call zoomHistogramFinalize() w/o an argument.
self._whistzoom_timer = QTimer(self)
self._whistzoom_timer.setSingleShot(True)
self._whistzoom_timer.setInterval(500)
QObject.connect(self._whistzoom_timer, SIGNAL("timeout()"), self._zoomHistogramFinalize)
# set same size for all buttons and controls
width = 24
for w in self._whistunzoom, self._whistzoomin, self._whistzoomout:
w.setMinimumSize(width, width)
w.setMaximumSize(width, width)
self._whistzoom.setMinimumSize(80, width)
self._wlab_histpos_text = "(hover here for help)"
self._wlab_histpos = QLabel(self._wlab_histpos_text, self)
self._wlab_histpos.setToolTip("""
<P>The plot shows a histogram of either the full image or its selected subset
(as per the "Data subset" section below).</P>
<P>The current intensity range is indicated by the grey box
in the plot.</P>
<P>Use the left mouse button to change the low intensity limit, and the right
button (on Macs, use Ctrl-click) to change the high limit.</P>
<P>Use Shift with the left mouse button to zoom into an area of the histogram,
or else use the "zoom wheel" control or the plus/minus toolbuttons above the histogram to zoom in or out.
To zoom back out to the full extent of the histogram, click on the rightmost button above the histogram.</P>
""")
lo2.addWidget(self._wlab_histpos, 1)
lo2.addWidget(self._wautozoom)
lo2.addWidget(self._wlogy, 0)
lo2.addWidget(self._whistzoomin, 0)
lo2.addWidget(self._whistzoom, 0)
lo2.addWidget(self._whistzoomout, 0)
lo2.addWidget(self._whistunzoom, 0)
self._zooming_histogram = False
sliced_axes = rc.slicedAxes()
dprint(1, "sliced axes are", sliced_axes)
self._stokes_axis = None
# subset indication
lo0.addWidget(Separator(self, "Data subset"))
# sliced axis selectors
self._wslicers = []
if sliced_axes:
lo1 = QHBoxLayout()
lo1.setContentsMargins(0, 0, 0, 0)
lo1.setSpacing(2)
lo0.addLayout(lo1)
lo1.addWidget(QLabel("Current slice: ", self))
for i, (iextra, name, labels) in enumerate(sliced_axes):
lo1.addWidget(QLabel("%s:" % name, self))
if name == "STOKES":
self._stokes_axis = iextra
# add controls
wslicer = QComboBox(self)
self._wslicers.append(wslicer)
wslicer.addItems(labels)
wslicer.setToolTip("""<P>Selects current slice along the %s axis.</P>""" % name)
wslicer.setCurrentIndex(self._rc.currentSlice()[iextra])
QObject.connect(wslicer, SIGNAL("activated(int)"), self._currier.curry(self._rc.changeSlice, iextra))
lo2 = QVBoxLayout()
lo1.addLayout(lo2)
lo2.setContentsMargins(0, 0, 0, 0)
lo2.setSpacing(0)
wminus = QToolButton(self)
wminus.setArrowType(Qt.UpArrow)
QObject.connect(wminus, SIGNAL("clicked()"), self._currier.curry(self._rc.incrementSlice, iextra, 1))
if i == 0:
wminus.setShortcut(Qt.SHIFT + Qt.Key_F7)
elif i == 1:
wminus.setShortcut(Qt.SHIFT + Qt.Key_F8)
wplus = QToolButton(self)
wplus.setArrowType(Qt.DownArrow)
QObject.connect(wplus, SIGNAL("clicked()"), self._currier.curry(self._rc.incrementSlice, iextra, -1))
if i == 0:
wplus.setShortcut(Qt.Key_F7)
elif i == 1:
wplus.setShortcut(Qt.Key_F8)
wminus.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
wplus.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
sz = QSize(12, 8)
wminus.setMinimumSize(sz)
wplus.setMinimumSize(sz)
wminus.resize(sz)
wplus.resize(sz)
lo2.addWidget(wminus)
lo2.addWidget(wplus)
lo1.addWidget(wslicer)
lo1.addSpacing(5)
lo1.addStretch(1)
# subset indicator
lo1 = QHBoxLayout()
lo1.setContentsMargins(0, 0, 0, 0)
lo1.setSpacing(2)
lo0.addLayout(lo1)
self._wlab_subset = QLabel("Subset: xxx", self)
self._wlab_subset.setToolTip("""<P>This indicates the current data subset to which the histogram
and the stats given here apply. Use the "Reset to" control on the right to change the
current subset and recompute the histogram and stats.</P>""")
lo1.addWidget(self._wlab_subset, 1)
self._wreset_full = self.makeButton("\u2192 full", self._rc.setFullSubset)
lo1.addWidget(self._wreset_full)
if sliced_axes:
# if self._stokes_axis is not None and len(sliced_axes)>1:
# self._wreset_stokes = self.makeButton(u"\u21920Stokes",self._rc.setFullSubset)
self._wreset_slice = self.makeButton("\u2192 slice", self._rc.setSliceSubset)
lo1.addWidget(self._wreset_slice)
else:
self._wreset_slice = None
# min/max controls
lo1 = QHBoxLayout()
lo1.setContentsMargins(0, 0, 0, 0)
lo0.addLayout(lo1, 0)
self._wlab_stats = QLabel(self)
lo1.addWidget(self._wlab_stats, 0)
self._wmore_stats = self.makeButton("more...", self._showMeanStd)
self._wlab_stats.setMinimumHeight(self._wmore_stats.height())
lo1.addWidget(self._wmore_stats, 0)
lo1.addStretch(1)
# intensity controls
lo0.addWidget(Separator(self, "Intensity mapping"))
lo1 = QHBoxLayout()
lo1.setContentsMargins(0, 0, 0, 0)
lo1.setSpacing(2)
lo0.addLayout(lo1, 0)
self._range_validator = FloatValidator(self)
self._wrange = QLineEdit(self), QLineEdit(self)
self._wrange[0].setToolTip("""<P>This is the low end of the intensity range.</P>""")
self._wrange[1].setToolTip("""<P>This is the high end of the intensity range.</P>""")
for w in self._wrange:
w.setValidator(self._range_validator)
QObject.connect(w, SIGNAL("editingFinished()"), self._changeDisplayRange)
lo1.addWidget(QLabel("low:", self), 0)
lo1.addWidget(self._wrange[0], 1)
self._wrangeleft0 = self.makeButton("\u21920", self._setZeroLeftLimit, width=32)
self._wrangeleft0.setToolTip("""<P>Click this to set the low end of the intensity range to 0.</P>""")
lo1.addWidget(self._wrangeleft0, 0)
lo1.addSpacing(8)
lo1.addWidget(QLabel("high:", self), 0)
lo1.addWidget(self._wrange[1], 1)
lo1.addSpacing(8)
self._wrange_full = self.makeButton(None, self._setHistDisplayRange, icon=pixmaps.intensity_graph.icon())
lo1.addWidget(self._wrange_full)
self._wrange_full.setToolTip(
"""<P>Click this to reset the intensity range to the current extent of the histogram plot.</P>""")
# add menu for display range
range_menu = QMenu(self)
wrange_menu = QToolButton(self)
wrange_menu.setText("Reset to")
wrange_menu.setToolTip("""<P>Use this to reset the intensity range to various pre-defined settings.</P>""")
lo1.addWidget(wrange_menu)
self._qa_range_full = range_menu.addAction(pixmaps.full_range.icon(), "Full subset",
self._rc.resetSubsetDisplayRange)
self._qa_range_hist = range_menu.addAction(pixmaps.intensity_graph.icon(), "Current histogram limits",
self._setHistDisplayRange)
for percent in (99.99, 99.9, 99.5, 99, 98, 95):
range_menu.addAction("%g%%" % percent, self._currier.curry(self._changeDisplayRangeToPercent, percent))
wrange_menu.setMenu(range_menu)
wrange_menu.setPopupMode(QToolButton.InstantPopup)
lo1 = QGridLayout()
lo1.setContentsMargins(0, 0, 0, 0)
lo0.addLayout(lo1, 0)
self._wimap = QComboBox(self)
lo1.addWidget(QLabel("Intensity policy:", self), 0, 0)
lo1.addWidget(self._wimap, 1, 0)
self._wimap.addItems(rc.getIntensityMapNames())
QObject.connect(self._wimap, SIGNAL("currentIndexChanged(int)"), self._rc.setIntensityMapNumber)
self._wimap.setToolTip("""<P>Use this to change the type of the intensity transfer function (ITF).</P>""")
# log cycles control
lo1.setColumnStretch(1, 1)
self._wlogcycles_label = QLabel("Log cycles: ", self)
lo1.addWidget(self._wlogcycles_label, 0, 1)
# self._wlogcycles = QwtWheel(self)
# self._wlogcycles.setTotalAngle(360)
self._wlogcycles = QwtSlider(self)
self._wlogcycles.setToolTip(
"""<P>Use this to change the log-base for the logarithmic intensity transfer function (ITF).</P>""")
# This works around a stupid bug in QwtSliders -- see comments on histogram zoom wheel above
self._wlogcycles_timer = QTimer(self)
self._wlogcycles_timer.setSingleShot(True)
self._wlogcycles_timer.setInterval(500)
QObject.connect(self._wlogcycles_timer, SIGNAL("timeout()"), self._setIntensityLogCycles)
lo1.addWidget(self._wlogcycles, 1, 1)
self._wlogcycles.setRange(1., 10)
self._wlogcycles.setStep(0.1)
self._wlogcycles.setTracking(False)
QObject.connect(self._wlogcycles, SIGNAL("valueChanged(double)"), self._setIntensityLogCycles)
QObject.connect(self._wlogcycles, SIGNAL("sliderMoved(double)"), self._previewIntensityLogCycles)
self._updating_imap = False
# lock intensity map
lo1 = QHBoxLayout()
lo1.setContentsMargins(0, 0, 0, 0)
lo0.addLayout(lo1, 0)
# lo1.addWidget(QLabel("Lock range accross",self))
wlock = QCheckBox("Lock display range", self)
wlock.setToolTip("""<P>If checked, then the intensity range will be locked. The ranges of all locked images
change simultaneously.</P>""")
lo1.addWidget(wlock)
wlockall = QToolButton(self)
wlockall.setIcon(pixmaps.locked.icon())
wlockall.setText("Lock all to this")
wlockall.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
wlockall.setAutoRaise(True)
wlockall.setToolTip("""<P>Click this to lock together the intensity ranges of all images.</P>""")
lo1.addWidget(wlockall)
wunlockall = QToolButton(self)
wunlockall.setIcon(pixmaps.unlocked.icon())
wunlockall.setText("Unlock all")
wunlockall.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
wunlockall.setAutoRaise(True)
wunlockall.setToolTip("""<P>Click this to unlock the intensity ranges of all images.</P>""")
lo1.addWidget(wunlockall)
wlock.setChecked(self._rc.isDisplayRangeLocked())
QObject.connect(wlock, SIGNAL("clicked(bool)"), self._rc.lockDisplayRange)
QObject.connect(wlockall, SIGNAL("clicked()"),
self._currier.curry(self._imgman.lockAllDisplayRanges, self._rc))
QObject.connect(wunlockall, SIGNAL("clicked()"), self._imgman.unlockAllDisplayRanges)
QObject.connect(self._rc, SIGNAL("displayRangeLocked"), wlock.setChecked)
# self._wlock_imap_axis = [ QCheckBox(name,self) for iaxis,name,labels in sliced_axes ]
# for iw,w in enumerate(self._wlock_imap_axis):
# QObject.connect(w,SIGNAL("toggled(bool)"),self._currier.curry(self._rc.lockDisplayRangeForAxis,iw))
# lo1.addWidget(w,0)
lo1.addStretch(1)
# lo0.addWidget(Separator(self,"Colourmap"))
# color bar
self._colorbar = QwtPlot(self)
lo0.addWidget(self._colorbar)
self._colorbar.setAutoDelete(False)
self._colorbar.setMinimumHeight(32)
self._colorbar.enableAxis(QwtPlot.yLeft, False)
self._colorbar.enableAxis(QwtPlot.xBottom, False)
# color plot
self._colorplot = QwtPlot(self)
lo0.addWidget(self._colorplot)
self._colorplot.setAutoDelete(False)
self._colorplot.setMinimumHeight(64)
self._colorplot.enableAxis(QwtPlot.yLeft, False)
self._colorplot.enableAxis(QwtPlot.xBottom, False)
# self._colorplot.setSizePolicy(QSizePolicy.Expanding,QSizePolicy.Preferred)
self._colorbar.hide()
self._colorplot.hide()
# color controls
lo1 = QHBoxLayout()
lo1.setContentsMargins(0, 0, 0, 0)
lo0.addLayout(lo1, 1)
lo1.addWidget(QLabel("Colourmap:", self))
# colormap list
### NB: use setIconSize() and icons in QComboBox!!!
self._wcolmaps = QComboBox(self)
self._wcolmaps.setIconSize(QSize(128, 16))
self._wcolmaps.setToolTip("""<P>Use this to select a different colourmap.</P>""")
for cmap in self._rc.getColormapList():
self._wcolmaps.addItem(QIcon(cmap.makeQPixmap(128, 16)), cmap.name)
lo1.addWidget(self._wcolmaps)
QObject.connect(self._wcolmaps, SIGNAL("activated(int)"), self._rc.setColorMapNumber)
# add widgetstack for colormap controls
self._wcolmap_control_stack = QStackedWidget(self)
self._wcolmap_control_blank = QWidget(self._wcolmap_control_stack)
self._wcolmap_control_stack.addWidget(self._wcolmap_control_blank)
lo0.addWidget(self._wcolmap_control_stack)
self._colmap_controls = []
# add controls to stack
for index, cmap in enumerate(self._rc.getColormapList()):
if isinstance(cmap, Colormaps.ColormapWithControls):
controls = cmap.makeControlWidgets(self._wcolmap_control_stack)
self._wcolmap_control_stack.addWidget(controls)
QObject.connect(cmap, SIGNAL("colormapChanged"),
self._currier.curry(self._previewColormapParameters, index, cmap))
QObject.connect(cmap, SIGNAL("colormapPreviewed"),
self._currier.curry(self._previewColormapParameters, index, cmap))
self._colmap_controls.append(controls)
else:
self._colmap_controls.append(self._wcolmap_control_blank)
# connect updates from renderControl and image
self.image.connect(SIGNAL("slice"), self._updateImageSlice)
QObject.connect(self._rc, SIGNAL("intensityMapChanged"), self._updateIntensityMap)
QObject.connect(self._rc, SIGNAL("colorMapChanged"), self._updateColorMap)
QObject.connect(self._rc, SIGNAL("dataSubsetChanged"), self._updateDataSubset)
QObject.connect(self._rc, SIGNAL("displayRangeChanged"), self._updateDisplayRange)
# update widgets
self._setupHistogramPlot()
self._updateDataSubset(*self._rc.currentSubset())
self._updateColorMap(image.colorMap())
self._updateIntensityMap(rc.currentIntensityMap(), rc.currentIntensityMapNumber())
self._updateDisplayRange(*self._rc.displayRange())
def makeButton(self, label, callback=None, width=None, icon=None):
btn = QToolButton(self)
# btn.setAutoRaise(True)
label and btn.setText(label)
icon and btn.setIcon(icon)
# btn = QPushButton(label,self)
# btn.setFlat(True)
if width:
btn.setMinimumWidth(width)
btn.setMaximumWidth(width)
if icon:
btn.setIcon(icon)
if callback:
QObject.connect(btn, SIGNAL("clicked()"), callback)
return btn
# def closeEvent (self,ev):
# ev.ignore()
# self.hide()
def hide(self):
self._geometry = self.geometry()
QDialog.hide(self)
def show(self):
dprint(4, "show entrypoint")
if self._geometry:
dprint(4, "setting geometry")
self.setGeometry(self._geometry)
if self._hist is None:
busy = BusyIndicator()
dprint(4, "updating histogram")
self._updateHistogram()
dprint(4, "updating stats")
self._updateStats(self._subset, self._subset_range)
busy = None
dprint(4, "calling QDialog.show")
QDialog.show(self)
# number of bins used to compute intensity transfer function
NumItfBins = 1000
# number of bins used for displaying histograms
NumHistBins = 500
# number of bins used for high-res histograms
NumHistBinsHi = 10000
# colorbar height, as fraction of plot area
ColorBarHeight = 0.1
class HistLimitPicker(QwtPlotPicker):
"""Auguments QwtPlotPicker with functions for selecting hist min/max values"""
def __init__(self, plot, label, color="green", mode=QwtPicker.PointSelection,
rubber_band=QwtPicker.VLineRubberBand, tracker_mode=QwtPicker.ActiveOnly, track=None):
QwtPlotPicker.__init__(self, QwtPlot.xBottom, QwtPlot.yRight, mode, rubber_band, tracker_mode,
plot.canvas())
self.plot = plot
self.label = label
self.track = track
self.color = QColor(color)
self.setRubberBandPen(QPen(self.color))
def trackerText(self, pos):
x, y = self.plot.invTransform(QwtPlot.xBottom, pos.x()), self.plot.invTransform(QwtPlot.yLeft, pos.y())
if self.track:
text = self.track(x, y)
if text is not None:
return text
if self.label:
text = QwtText(self.label % dict(x=x, y=y))
text.setColor(self.color)
return text
return QwtText()
def widgetLeaveEvent(self, ev):
if self.track:
self.track(None, None)
QwtPlotPicker.widgetLeaveEvent(self, ev)
class ColorBarPlotItem(QwtPlotItem):
def __init__(self, y0, y1, *args):
QwtPlotItem.__init__(self, *args)
self._y0 = y1
self._dy = y1 - y0
def setIntensityMap(self, imap):
self.imap = imap
def setColorMap(self, cmap):
self.cmap = cmap
def draw(self, painter, xmap, ymap, rect):
"""Implements QwtPlotItem.draw(), to render the colorbar on the given painter."""
xp1, xp2, xdp, xs1, xs2, xds = xinfo = xmap.p1(), xmap.p2(), xmap.pDist(), xmap.s1(), xmap.s2(), xmap.sDist()
yp1, yp2, ydp, ys1, ys2, yds = yinfo = ymap.p1(), ymap.p2(), ymap.pDist(), ymap.s1(), ymap.s2(), ymap.sDist()
# xp: coordinates of pixels xp1...xp2 in data units
xp = xs1 + (xds / xdp) * (0.5 + numpy.arange(int(xdp)))
# convert y0 and y1 into pixel coordinates
y0 = yp1 - (self._y0 - ys1) * (ydp / yds)
dy = self._dy * (ydp / yds)
# remap into an Nx1 image
qimg = self.cmap.colorize(self.imap.remap(xp.reshape((len(xp), 1))))
# plot image
painter.drawImage(QRect(xp1, y0, xdp, dy), qimg)
class HistogramLineMarker(object):
"""Helper class implementing a line marker for a histogram plot"""
def __init__(self, plot, color="black", linestyle=Qt.DotLine, align=Qt.AlignBottom | Qt.AlignRight, z=90,
label="", zlabel=None, linewidth=1, spacing=2,
yaxis=QwtPlot.yRight):
self.line = TiggerPlotCurve()
self.color = color = color if isinstance(color, QColor) else QColor(color)
self.line.setPen(QPen(color, linewidth, linestyle))
self.marker = TiggerPlotMarker()
self.marker.setLabelAlignment(align)
try:
self.marker.setSpacing(spacing)
except AttributeError:
pass
self.setText(label)
self.line.setZ(z)
self.marker.setZ(zlabel if zlabel is not None else z)
# set axes -- using yRight, since that is the "markup" z-axis
self.line.setAxis(QwtPlot.xBottom, yaxis)
self.marker.setAxis(QwtPlot.xBottom, yaxis)
# attach to plot
self.line.attach(plot)
self.marker.attach(plot)
def show(self):
self.line.show()
self.marker.show()
def hide(self):
self.line.hide()
self.marker.hide()
def setText(self, text):
label = QwtText(text)
label.setColor(self.color)
self.marker.setLabel(label)
def _setupHistogramPlot(self):
self._histplot.setCanvasBackground(QColor("lightgray"))
self._histplot.setAxisFont(QwtPlot.yLeft, QApplication.font())
self._histplot.setAxisFont(QwtPlot.xBottom, QApplication.font())
# add histogram curves
self._histcurve1 = TiggerPlotCurve()
self._histcurve2 = TiggerPlotCurve()
self._histcurve1.setStyle(QwtPlotCurve.Steps)
self._histcurve2.setStyle(QwtPlotCurve.Steps)
self._histcurve1.setPen(QPen(Qt.NoPen))
self._histcurve1.setBrush(QBrush(QColor("slategrey")))
pen = QPen(QColor("red"))
pen.setWidth(1)
self._histcurve2.setPen(pen)
self._histcurve1.setZ(0)
self._histcurve2.setZ(100)
# self._histcurve1.attach(self._histplot)
self._histcurve2.attach(self._histplot)
# add maxbin and half-max curves
self._line_0 = self.HistogramLineMarker(self._histplot, color="grey50", linestyle=Qt.SolidLine,
align=Qt.AlignTop | Qt.AlignLeft, z=90)
self._line_mean = self.HistogramLineMarker(self._histplot, color="black", linestyle=Qt.SolidLine,
align=Qt.AlignBottom | Qt.AlignRight, z=91,
label="mean", zlabel=151)
self._line_std = self.HistogramLineMarker(self._histplot, color="black", linestyle=Qt.SolidLine,
align=Qt.AlignTop | Qt.AlignRight, z=91,
label="std", zlabel=151)
sym = QwtSymbol()
sym.setStyle(QwtSymbol.VLine)
sym.setSize(8)
self._line_std.line.setSymbol(sym)
self._line_maxbin = self.HistogramLineMarker(self._histplot, color="green", linestyle=Qt.DotLine,
align=Qt.AlignTop | Qt.AlignRight, z=92,
label="max bin", zlabel=150)
self._line_halfmax = self.HistogramLineMarker(self._histplot, color="green", linestyle=Qt.DotLine,
align=Qt.AlignBottom | Qt.AlignRight, z=90,
label="half-max", yaxis=QwtPlot.yLeft)
# add current range
self._rangebox = TiggerPlotCurve()
self._rangebox.setStyle(QwtPlotCurve.Steps)
self._rangebox.setYAxis(QwtPlot.yRight)
self._rangebox.setPen(QPen(Qt.NoPen))
self._rangebox.setBrush(QBrush(QColor("darkgray")))
self._rangebox.setZ(50)
self._rangebox.attach(self._histplot)
self._rangebox2 = TiggerPlotCurve()
self._rangebox2.setStyle(QwtPlotCurve.Sticks)
self._rangebox2.setYAxis(QwtPlot.yRight)
self._rangebox2.setZ(60)
# self._rangebox2.attach(self._histplot)
# add intensity transfer function
self._itfcurve = TiggerPlotCurve()
self._itfcurve.setStyle(QwtPlotCurve.Lines)
self._itfcurve.setPen(QPen(QColor("blue")))
self._itfcurve.setYAxis(QwtPlot.yRight)
self._itfcurve.setZ(120)
self._itfcurve.attach(self._histplot)
self._itfmarker = TiggerPlotMarker()
label = QwtText("ITF")
label.setColor(QColor("blue"))
self._itfmarker.setLabel(label)
try:
self._itfmarker.setSpacing(0)
except AttributeError:
pass
self._itfmarker.setLabelAlignment(Qt.AlignTop | Qt.AlignRight)
self._itfmarker.setZ(120)
self._itfmarker.attach(self._histplot)
# add colorbar
self._cb_item = self.ColorBarPlotItem(1, 1 + self.ColorBarHeight)
self._cb_item.setYAxis(QwtPlot.yRight)
self._cb_item.attach(self._histplot)
# add pickers
self._hist_minpicker = self.HistLimitPicker(self._histplot, "low: %(x).4g")
self._hist_minpicker.setMousePattern(QwtEventPattern.MouseSelect1, Qt.LeftButton)
QObject.connect(self._hist_minpicker, SIGNAL("selected(const QwtDoublePoint &)"), self._selectLowLimit)
self._hist_maxpicker = self.HistLimitPicker(self._histplot, "high: %(x).4g")
self._hist_maxpicker.setMousePattern(QwtEventPattern.MouseSelect1, Qt.RightButton)
QObject.connect(self._hist_maxpicker, SIGNAL("selected(const QwtDoublePoint &)"), self._selectHighLimit)
self._hist_maxpicker1 = self.HistLimitPicker(self._histplot, "high: %(x).4g")
self._hist_maxpicker1.setMousePattern(QwtEventPattern.MouseSelect1, Qt.LeftButton, Qt.CTRL)
QObject.connect(self._hist_maxpicker1, SIGNAL("selected(const QwtDoublePoint &)"), self._selectHighLimit)
self._hist_zoompicker = self.HistLimitPicker(self._histplot, label="zoom",
tracker_mode=QwtPicker.AlwaysOn, track=self._trackHistCoordinates,
color="black",
mode=QwtPicker.RectSelection,
rubber_band=QwtPicker.RectRubberBand)
self._hist_zoompicker.setMousePattern(QwtEventPattern.MouseSelect1, Qt.LeftButton, Qt.SHIFT)
QObject.connect(self._hist_zoompicker, SIGNAL("selected(const QwtDoubleRect &)"), self._zoomHistogramIntoRect)
def _trackHistCoordinates(self, x, y):
self._wlab_histpos.setText((DataValueFormat + " %d") % (x, y) if x is not None else self._wlab_histpos_text)
return QwtText()
def _updateITF(self):
"""Updates current ITF array."""
# do nothing if no histogram -- means we're not visible
if self._hist is not None:
xdata = self._itf_bins
ydata = self.image.intensityMap().remap(xdata)
self._rangebox.setData(self._rc.displayRange(), [1, 1])
self._rangebox2.setData(self._rc.displayRange(), [1, 1])
self._itfcurve.setData(xdata, ydata)
self._itfmarker.setValue(xdata[0], 1)
def _updateHistogram(self, hmin=None, hmax=None):
"""Recomputes histogram. If no arguments, computes full histogram for
data subset. If hmin/hmax is specified, computes zoomed-in histogram."""
busy = BusyIndicator()
self._prev_range = self._display_range
dmin, dmax = self._subset_range
hmin0, hmax0 = dmin, dmax
if hmin0 >= hmax0:
hmax0 = hmin0 + 1
subset, mask = self.image.optimalRavel(self._subset)
# compute full-subset hi-res histogram, if we don't have one (for percentile stats)
if self._hist_hires is None:
dprint(1, "computing histogram for full subset range", hmin0, hmax0)
self._hist_hires = measurements.histogram(subset, hmin0, hmax0, self.NumHistBinsHi, labels=mask,
index=None if mask is None else False)
self._hist_bins_hires = hmin0 + (hmax0 - hmin0) * (numpy.arange(self.NumHistBinsHi) + 0.5) / float(
self.NumHistBinsHi)
self._hist_binsize_hires = (hmax0 - hmin0) / self.NumHistBins
# if hist limits not specified, then compute lo-res histogram based on the hi-res one
if hmin is None:
hmin, hmax = hmin0, hmax0
# downsample to low-res histogram
self._hist = self._hist_hires.reshape((self.NumHistBins, self.NumHistBinsHi / self.NumHistBins)).sum(1)
else:
# zoomed-in low-res histogram
# bracket limits at subset range
hmin, hmax = max(hmin, dmin), min(hmax, dmax)
if hmin >= hmax:
hmax = hmin + 1
dprint(1, "computing histogram for", self._subset.shape, self._subset.dtype, hmin, hmax)
self._hist = measurements.histogram(subset, hmin, hmax, self.NumHistBins, labels=mask,
index=None if mask is None else False)
dprint(1, "histogram computed")
# compute bins
self._itf_bins = hmin + (hmax - hmin) * (numpy.arange(self.NumItfBins)) / (float(self.NumItfBins) - 1)
self._hist_bins = hmin + (hmax - hmin) * (numpy.arange(self.NumHistBins) + 0.5) / float(self.NumHistBins)
# histogram range and position of peak
self._hist_range = hmin, hmax
self._hist_min, self._hist_max, self._hist_imin, self._hist_imax = measurements.extrema(self._hist)
self._hist_peak = self._hist_bins[self._hist_imax]
# set controls accordingly
if dmin >= dmax:
dmax = dmin + 1
zoom = math.log10((dmax - dmin) / (hmax - hmin))
self._whistzoom.setValue(zoom)
self._whistunzoom.setEnabled(zoom > 0)
self._whistzoomout.setEnabled(zoom > 0)
# reset scales
self._histplot.setAxisScale(QwtPlot.xBottom, hmin, hmax)
self._histplot.setAxisScale(QwtPlot.yRight, 0, 1 + self.ColorBarHeight)
# update curves
# call _setHistLogScale() (with current setting) to update axis scales and set data
self._setHistLogScale(self._ylogscale, replot=False)
# set plot lines
self._line_0.line.setData([0, 0], [0, 1])
self._line_0.marker.setValue(0, 0)
self._line_maxbin.line.setData([self._hist_peak, self._hist_peak], [0, 1])
self._line_maxbin.marker.setValue(self._hist_peak, 0)
self._line_maxbin.setText(("max bin:" + DataValueFormat) % self._hist_peak)
# set half-max line
self._line_halfmax.line.setData(self._hist_range, [self._hist_max / 2, self._hist_max / 2])
self._line_halfmax.marker.setValue(hmin, self._hist_max / 2)
# update ITF
self._updateITF()
def _updateStats(self, subset, minmax):
"""Recomputes subset statistics."""
if subset.size <= (2048 * 2048):
self._showMeanStd(busy=False)
else:
self._wlab_stats.setText(
("min: %s max: %s np: %d" % (DataValueFormat, DataValueFormat, self._subset.size)) % minmax)
self._wmore_stats.show()
def _updateDataSubset(self, subset, minmax, desc, subset_type):
"""Called when the displayed data subset is changed. Updates the histogram."""
self._subset = subset
self._subset_range = minmax
self._wlab_subset.setText("Subset: %s" % desc)
self._hist = self._hist_hires = None
self._wreset_full.setVisible(subset_type is not RenderControl.SUBSET_FULL)
self._wreset_slice and self._wreset_slice.setVisible(subset_type is not RenderControl.SUBSET_SLICE)
# hide the mean/std markers, they will only be shown when _showMeanStd() is called
self._line_mean.hide()
self._line_std.hide()
# if we're visibile, recompute histograms and stats
if self.isVisible():
# if subset is sufficiently small, compute extended stats on-the-fly. Else show the "more" button to compute them later
self._updateHistogram()
self._updateStats(subset, minmax)
self._histplot.replot()
def _showMeanStd(self, busy=True):
if busy:
busy = BusyIndicator()
dmin, dmax = self._subset_range
subset, mask = self.image.optimalRavel(self._subset)
dprint(5, "computing mean")
mean = measurements.mean(subset, labels=mask, index=None if mask is None else False)
dprint(5, "computing std")
std = measurements.standard_deviation(subset, labels=mask, index=None if mask is None else False)
dprint(5, "done")
text = " ".join([("%s: " + DataValueFormat) % (name, value) for name, value in
("min", dmin), ("max", dmax), ("mean", mean), ("std", std)] + ["np: %d" % self._subset.size])
self._wlab_stats.setText(text)
self._wmore_stats.hide()
# update markers
ypos = 0.3
self._line_mean.line.setData([mean, mean], [0, 1])
self._line_mean.marker.setValue(mean, ypos)
self._line_mean.setText(("\u03BC=" + DataValueFormat) % mean)
self._line_mean.show()
self._line_std.line.setData([mean - std, mean + std], [ypos, ypos])
self._line_std.marker.setValue(mean, ypos)
self._line_std.setText(("\u03C3=" + DataValueFormat) % std)
self._line_std.show()
self._histplot.replot()
def _setIntensityLogCyclesLabel(self, value):
self._wlogcycles_label.setText("Log cycles: %4.1f" % value)
def _previewIntensityLogCycles(self, value):
self._setIntensityLogCycles(value, notify_image=False, write_config=False)
self._wlogcycles_timer.start(500)
def _setIntensityLogCycles(self, value=None, notify_image=True, write_config=True):
if value is None:
value = self._wlogcycles.value()
# stop timer if being called to finalize the change in value
if notify_image:
self._wlogcycles_timer.stop()
if not self._updating_imap:
self._setIntensityLogCyclesLabel(value)
self._rc.setIntensityMapLogCycles(value, notify_image=notify_image, write_config=write_config)
self._updateITF()
self._histplot.replot()
def _updateDisplayRange(self, dmin, dmax):
self._rangebox.setData([dmin, dmax], [.9, .9])
self._wrange[0].setText(DataValueFormat % dmin)
self._wrange[1].setText(DataValueFormat % dmax)
self._wrangeleft0.setEnabled(dmin != 0)
self._display_range = dmin, dmax
# if auto-zoom is on, zoom the histogram
# try to be a little clever about this. Zoom only if (a) both limits have changed (so that adjusting one end of the range
# does not cause endless rezooms), or (b) display range is < 1/10 of the histogram range
if self._wautozoom.isChecked() and self._hist is not None:
if (dmax - dmin) / (self._hist_range[1] - self._hist_range[0]) < .1 or (
dmin != self._prev_range[0] and dmax != self._prev_range[1]):
margin = (dmax - dmin) / 8
self._updateHistogram(dmin - margin, dmax + margin)
self._updateITF()
self._histplot.replot()
def _updateIntensityMap(self, imap, index):
self._updating_imap = True
try:
self._cb_item.setIntensityMap(imap)
self._updateITF()
self._histplot.replot()
self._wimap.setCurrentIndex(index)
if isinstance(imap, Colormaps.LogIntensityMap):
self._wlogcycles.setValue(imap.log_cycles)
self._setIntensityLogCyclesLabel(imap.log_cycles)
self._wlogcycles.show()
self._wlogcycles_label.show()
else:
self._wlogcycles.hide()
self._wlogcycles_label.hide()
finally:
self._updating_imap = False
def _updateColorMap(self, cmap):
self._cb_item.setColorMap(cmap)
self._histplot.replot()
try:
index = self._rc.getColormapList().index(cmap)
except:
return
self._setCurrentColormapNumber(index, cmap)
def _previewColormapParameters(self, index, cmap):
"""Called to preview a new colormap parameter value"""
self._histplot.replot()
self._wcolmaps.setItemIcon(index, QIcon(cmap.makeQPixmap(128, 16)))
def _setCurrentColormapNumber(self, index, cmap):
self._wcolmaps.setCurrentIndex(index)
# show controls for colormap
self._wcolmap_control_stack.setCurrentWidget(self._colmap_controls[index])
def _changeDisplayRange(self):
"""Gets display range from widgets and updates the image with it."""
try:
newrange = [float(str(w.text())) for w in self._wrange]
except ValueError:
return
self._rc.setDisplayRange(*newrange)
def _setHistDisplayRange(self):
self._rc.setDisplayRange(*self._hist_range)
def _updateImageSlice(self, slice):
for i, (iextra, name, labels) in enumerate(self._rc.slicedAxes()):
self._wslicers[i].setCurrentIndex(slice[iextra])
def _changeDisplayRangeToPercent(self, percent):
busy = BusyIndicator()
if self._hist is None:
self._updateHistogram()
self._updateStats(self._subset, self._subset_range)
# delta: we need the [delta,100-delta] interval of the total distribution
delta = self._subset.size * ((100. - percent) / 200.)
# get F(x): cumulative sum
cumsum = numpy.zeros(len(self._hist_hires) + 1, dtype=int)
cumsum[1:] = numpy.cumsum(self._hist_hires)
bins = numpy.zeros(len(self._hist_hires) + 1, dtype=float)
bins[0] = self._subset_range[0]
bins[1:] = self._hist_bins_hires + self._hist_binsize_hires / 2
# use interpolation to find value interval corresponding to [delta,100-delta] of the distribution
dprint(2, self._subset.size, delta, self._subset.size - delta)
dprint(2, cumsum, self._hist_bins_hires)
# if first bin is already > delta, then set colour range to first bin
x0, x1 = numpy.interp([delta, self._subset.size - delta], cumsum, bins)
# and change the display range (this will also cause a histplot.replot() via _updateDisplayRange above)
self._rc.setDisplayRange(x0, x1)
def _setZeroLeftLimit(self):
self._rc.setDisplayRange(0., self._rc.displayRange()[1])
def _selectLowLimit(self, pos):
self._rc.setDisplayRange(pos.x(), self._rc.displayRange()[1])
def _selectHighLimit(self, pos):
self._rc.setDisplayRange(self._rc.displayRange()[0], pos.x())
def _unzoomHistogram(self):
self._updateHistogram()
self._histplot.replot()
def _zoomHistogramByFactor(self, factor):
"""Changes histogram limits by specified factor"""
# get max distance of plot limit from peak
dprint(1, "zooming histogram by", factor)
halfdist = (self._hist_range[1] - self._hist_range[0]) / (factor * 2)
self._updateHistogram(self._hist_peak - halfdist, self._hist_peak + halfdist)
self._histplot.replot()
def _zoomHistogramIntoRect(self, rect):
hmin, hmax = rect.bottomLeft().x(), rect.bottomRight().x()
if hmax > hmin:
self._updateHistogram(rect.bottomLeft().x(), rect.bottomRight().x())
self._histplot.replot()
def _zoomHistogramPreview(self, value):
dprint(2, "wheel moved to", value)
self._zoomHistogramFinalize(value, preview=True)
self._whistzoom_timer.start()
def _zoomHistogramFinalize(self, value=None, preview=False):
if self._zooming_histogram:
return
self._zooming_histogram = True
try:
if value is not None:
dmin, dmax = self._subset_range
dist = max(dmax - self._hist_peak, self._hist_peak - dmin) / 10 ** value
self._preview_hist_range = max(self._hist_peak - dist, dmin), min(self._hist_peak + dist, dmax)
if preview:
self._histplot.setAxisScale(QwtPlot.xBottom, *self._preview_hist_range)
else:
dprint(2, "wheel finalized at", value)
self._whistzoom_timer.stop()
self._updateHistogram(*self._preview_hist_range)
self._histplot.replot()
finally:
self._zooming_histogram = False
def _setHistLogScale(self, logscale, replot=True):
self._ylogscale = logscale
if logscale:
self._histplot.setAxisScaleEngine(QwtPlot.yLeft, QwtLog10ScaleEngine())
ymax = max(1, self._hist_max)
self._histplot.setAxisScale(QwtPlot.yLeft, 1, 10 ** (math.log10(ymax) * (1 + self.ColorBarHeight)))
y = self._hist.copy()
y[y == 0] = 1
self._histcurve1.setData(self._hist_bins, y)
self._histcurve2.setData(self._hist_bins, y)
else:
self._histplot.setAxisScaleEngine(QwtPlot.yLeft, QwtLinearScaleEngine())
self._histplot.setAxisScale(QwtPlot.yLeft, 0, self._hist_max * (1 + self.ColorBarHeight))
self._histcurve1.setData(self._hist_bins, self._hist)
self._histcurve2.setData(self._hist_bins, self._hist)
if replot:
self._histplot.replot()
class EditResidues_PropertyManager(Command_PropertyManager):
"""
The ProteinDisplayStyle_PropertyManager class provides a Property Manager
for the B{Display Style} command on the flyout toolbar in the
Build > Protein mode.
@ivar title: The title that appears in the property manager header.
@type title: str
@ivar pmName: The name of this property manager. This is used to set
the name of the PM_Dialog object via setObjectName().
@type name: str
@ivar iconPath: The relative path to the PNG file that contains a
22 x 22 icon image that appears in the PM header.
@type iconPath: str
"""
title = "Edit Residues"
pmName = title
iconPath = "ui/actions/Command Toolbar/BuildProtein/Residues.png"
rosetta_all_set = "PGAVILMFWYCSTNQDEHKR"
rosetta_polar_set = "___________STNQDEHKR"
rosetta_apolar_set = "PGAVILMFWYC_________"
def __init__(self, command):
"""
Constructor for the property manager.
"""
self.currentWorkingDirectory = env.prefs[workingDirectory_prefs_key]
_superclass.__init__(self, command)
self.sequenceEditor = self.win.createProteinSequenceEditorIfNeeded()
self.showTopRowButtons( PM_DONE_BUTTON | \
PM_WHATS_THIS_BUTTON)
self.editingItem = False
return
def connect_or_disconnect_signals(self, isConnect=True):
if isConnect:
change_connect = self.win.connect
else:
change_connect = self.win.disconnect
change_connect(self.applyAnyPushButton, SIGNAL("clicked()"),
self._applyAny)
change_connect(self.applySamePushButton, SIGNAL("clicked()"),
self._applySame)
change_connect(self.applyLockedPushButton, SIGNAL("clicked()"),
self._applyLocked)
change_connect(self.applyPolarPushButton, SIGNAL("clicked()"),
self._applyPolar)
change_connect(self.applyApolarPushButton, SIGNAL("clicked()"),
self._applyApolar)
change_connect(self.selectAllPushButton, SIGNAL("clicked()"),
self._selectAll)
change_connect(self.selectNonePushButton, SIGNAL("clicked()"),
self._selectNone)
change_connect(self.selectInvertPushButton, SIGNAL("clicked()"),
self._invertSelection)
change_connect(self.applyDescriptorPushButton, SIGNAL("clicked()"),
self._applyDescriptor)
change_connect(self.removeDescriptorPushButton, SIGNAL("clicked()"),
self._removeDescriptor)
change_connect(self.sequenceTable, SIGNAL("cellClicked(int, int)"),
self._sequenceTableCellChanged)
change_connect(self.sequenceTable,
SIGNAL("itemChanged(QTableWidgetItem*)"),
self._sequenceTableItemChanged)
change_connect(self.descriptorsTable,
SIGNAL("itemChanged(QTableWidgetItem*)"),
self._descriptorsTableItemChanged)
change_connect(self.newDescriptorPushButton, SIGNAL("clicked()"),
self._addNewDescriptor)
change_connect(self.showSequencePushButton, SIGNAL("clicked()"),
self._showSeqEditor)
return
def _showSeqEditor(self):
"""
Shows sequence editor
"""
if self.showSequencePushButton.isEnabled():
self.sequenceEditor.show()
return
def show(self):
"""
Shows the Property Manager. Extends superclass method.
"""
env.history.statusbar_msg("")
#Urmi 20080728: Set the current protein and this will be used for accessing
#various properties of this protein
self.set_current_protein()
if self.current_protein:
msg = "Editing structure <b>%s</b>." % self.current_protein.name
self.showSequencePushButton.setEnabled(True)
else:
msg = "Select a single structure to edit."
self.showSequencePushButton.setEnabled(False)
self.sequenceEditor.hide()
_superclass.show(self)
self._fillSequenceTable()
self.updateMessage(msg)
return
def set_current_protein(self):
"""
Set the current protein for which all the properties are displayed to the
one chosen in the build protein combo box
"""
self.current_protein = self.win.assy.getSelectedProteinChunk()
return
def _addGroupBoxes(self):
"""
Add the Property Manager group boxes.
"""
if sys.platform == "darwin":
# Workaround for table font size difference between Mac/Win
self.labelfont = QFont("Helvetica", 12)
self.descriptorfont = QFont("Courier New", 12)
else:
self.labelfont = QFont("Helvetica", 9)
self.descriptorfont = QFont("Courier New", 9)
self._pmGroupBox1 = PM_GroupBox(self, title="Descriptors")
self._loadGroupBox1(self._pmGroupBox1)
self._pmGroupBox2 = PM_GroupBox(self, title="Sequence")
self._loadGroupBox2(self._pmGroupBox2)
def _loadGroupBox1(self, pmGroupBox):
"""
Load widgets in the first group box.
"""
self.headerdata_desc = ['Name', 'Descriptor']
self.set_names = ["Any", "Same", "Locked", "Apolar", "Polar"]
self.rosetta_set_names = ["ALLAA", "NATAA", "NATRO", "APOLA", "POLAR"]
self.descriptor_list = [
"PGAVILMFWYCSTNQDEHKR", "____________________",
"____________________", "PGAVILMFWYC_________",
"___________STNQDEHKR"
]
self.applyAnyPushButton = PM_PushButton(pmGroupBox,
text="ALLAA",
setAsDefault=True)
self.applySamePushButton = PM_PushButton(pmGroupBox,
text="NATAA",
setAsDefault=True)
self.applyLockedPushButton = PM_PushButton(pmGroupBox,
text="NATRO",
setAsDefault=True)
self.applyPolarPushButton = PM_PushButton(pmGroupBox,
text="APOLA",
setAsDefault=True)
self.applyApolarPushButton = PM_PushButton(pmGroupBox,
text="POLAR",
setAsDefault=True)
#self.applyBackrubPushButton = PM_PushButton( pmGroupBox,
# text = "BACKRUB",
# setAsDefault = True)
self.applyAnyPushButton.setFixedHeight(25)
self.applyAnyPushButton.setFixedWidth(60)
self.applySamePushButton.setFixedHeight(25)
self.applySamePushButton.setFixedWidth(60)
self.applyLockedPushButton.setFixedHeight(25)
self.applyLockedPushButton.setFixedWidth(60)
self.applyPolarPushButton.setFixedHeight(25)
self.applyPolarPushButton.setFixedWidth(60)
self.applyApolarPushButton.setFixedHeight(25)
self.applyApolarPushButton.setFixedWidth(60)
applyButtonList = [('PM_PushButton', self.applyAnyPushButton, 0, 0),
('PM_PushButton', self.applySamePushButton, 1, 0),
('PM_PushButton', self.applyLockedPushButton, 2, 0),
('PM_PushButton', self.applyPolarPushButton, 3, 0),
('PM_PushButton', self.applyApolarPushButton, 4, 0)]
self.applyButtonGrid = PM_WidgetGrid(pmGroupBox,
label="Apply standard set",
widgetList=applyButtonList)
self.descriptorsTable = PM_TableWidget(pmGroupBox,
label="Custom descriptors")
self.descriptorsTable.setFixedHeight(100)
self.descriptorsTable.setRowCount(0)
self.descriptorsTable.setColumnCount(2)
self.descriptorsTable.verticalHeader().setVisible(False)
self.descriptorsTable.horizontalHeader().setVisible(True)
self.descriptorsTable.setGridStyle(Qt.NoPen)
self.descriptorsTable.setHorizontalHeaderLabels(self.headerdata_desc)
self._updateSetLists()
self._fillDescriptorsTable()
self.descriptorsTable.resizeColumnsToContents()
self.newDescriptorPushButton = PM_PushButton(pmGroupBox,
text="New",
setAsDefault=True)
self.newDescriptorPushButton.setFixedHeight(25)
self.removeDescriptorPushButton = PM_PushButton(pmGroupBox,
text="Remove",
setAsDefault=True)
self.removeDescriptorPushButton.setFixedHeight(25)
self.applyDescriptorPushButton = PM_PushButton(pmGroupBox,
text="Apply",
setAsDefault=True)
self.applyDescriptorPushButton.setFixedHeight(25)
addDescriptorButtonList = [
('PM_PushButton', self.newDescriptorPushButton, 0, 0),
('PM_PushButton', self.removeDescriptorPushButton, 1, 0),
('PM_PushButton', self.applyDescriptorPushButton, 2, 0)
]
self.addDescriptorGrid = PM_WidgetGrid(
pmGroupBox, alignment="Center", widgetList=addDescriptorButtonList)
def _loadGroupBox2(self, pmGroupBox):
"""
Load widgets in the second group box.
"""
self.headerdata_seq = ['', 'ID', 'Set', 'BR', 'Descriptor']
self.recenterViewCheckBox = \
PM_CheckBox( pmGroupBox,
text = "Re-center view on selected residue",
setAsDefault = True,
widgetColumn = 0,
state = Qt.Unchecked)
self.selectAllPushButton = PM_PushButton(pmGroupBox,
text="All",
setAsDefault=True)
self.selectAllPushButton.setFixedHeight(25)
self.selectNonePushButton = PM_PushButton(pmGroupBox,
text="None",
setAsDefault=True)
self.selectNonePushButton.setFixedHeight(25)
self.selectInvertPushButton = PM_PushButton(pmGroupBox,
text="Invert",
setAsDefault=True)
self.selectInvertPushButton.setFixedHeight(25)
buttonList = [('PM_PushButton', self.selectAllPushButton, 0, 0),
('PM_PushButton', self.selectNonePushButton, 1, 0),
('PM_PushButton', self.selectInvertPushButton, 2, 0)]
self.buttonGrid = PM_WidgetGrid(pmGroupBox, widgetList=buttonList)
self.sequenceTable = PM_TableWidget(pmGroupBox)
#self.sequenceTable.setModel(self.tableModel)
self.sequenceTable.resizeColumnsToContents()
self.sequenceTable.verticalHeader().setVisible(False)
#self.sequenceTable.setRowCount(0)
self.sequenceTable.setColumnCount(5)
self.checkbox = QCheckBox()
self.sequenceTable.setFixedHeight(345)
self.sequenceTable.setGridStyle(Qt.NoPen)
self.sequenceTable.setHorizontalHeaderLabels(self.headerdata_seq)
###self._fillSequenceTable()
self.showSequencePushButton = PM_PushButton(pmGroupBox,
text="Show Sequence",
setAsDefault=True,
spanWidth=True)
def _addWhatsThisText(self):
#from ne1_ui.WhatsThisText_for_PropertyManagers import WhatsThis_EditResidues_PropertyManager
#WhatsThis_EditResidues_PropertyManager(self)
pass
def _addToolTipText(self):
#from ne1_ui.ToolTipText_for_PropertyManagers import ToolTip_EditProteinDisplayStyle_PropertyManager
#ToolTip_EditProteinDisplayStyle_PropertyManager(self)
pass
def _fillSequenceTable(self):
"""
Fills in the sequence table.
"""
if not self.current_protein:
return
else:
currentProteinChunk = self.current_protein
self.editingItem = True
aa_list = currentProteinChunk.protein.get_amino_acids()
aa_list_len = len(aa_list)
self.sequenceTable.setRowCount(aa_list_len)
for index in range(aa_list_len):
# Selection checkbox column
item_widget = QTableWidgetItem("")
item_widget.setFont(self.labelfont)
item_widget.setCheckState(Qt.Checked)
item_widget.setTextAlignment(Qt.AlignLeft)
item_widget.setSizeHint(QSize(20, 12))
item_widget.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
| Qt.ItemIsUserCheckable)
self.sequenceTable.setItem(index, 0, item_widget)
# Amino acid index column
item_widget = QTableWidgetItem(str(index + 1))
item_widget.setFont(self.labelfont)
item_widget.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_widget.setTextAlignment(Qt.AlignCenter)
self.sequenceTable.setItem(index, 1, item_widget)
# Mutation descriptor name column
aa = self._get_aa_for_index(index)
item_widget = QTableWidgetItem(self._get_descriptor_name(aa))
item_widget.setFont(self.labelfont)
item_widget.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_widget.setTextAlignment(Qt.AlignCenter)
self.sequenceTable.setItem(index, 2, item_widget)
# Backrub checkbox column
item_widget = QTableWidgetItem("")
item_widget.setFont(self.labelfont)
if aa.get_backrub_mode():
item_widget.setCheckState(Qt.Checked)
else:
item_widget.setCheckState(Qt.Unchecked)
item_widget.setTextAlignment(Qt.AlignLeft)
item_widget.setSizeHint(QSize(20, 12))
item_widget.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
| Qt.ItemIsUserCheckable)
self.sequenceTable.setItem(index, 3, item_widget)
# Mutation descriptor column
aa_string = self._get_mutation_descriptor(aa)
item_widget = QTableWidgetItem(aa_string)
item_widget.setFont(self.descriptorfont)
self.sequenceTable.setItem(index, 4, item_widget)
self.sequenceTable.setRowHeight(index, 16)
self.editingItem = False
self.sequenceTable.resizeColumnsToContents()
self.sequenceTable.setColumnWidth(0, 35)
self.sequenceTable.setColumnWidth(2, 80)
self.sequenceTable.setColumnWidth(3, 35)
return
def _fillDescriptorsTable(self):
"""
Fills in the descriptors table from descriptors user pref.
"""
dstr = env.prefs[proteinCustomDescriptors_prefs_key].split(":")
for i in range(len(dstr) / 2):
self._addNewDescriptorTableRow(dstr[2 * i], dstr[2 * i + 1])
def _selectAll(self):
"""
Select all rows in the sequence table.
"""
for row in range(self.sequenceTable.rowCount()):
self.sequenceTable.item(row, 0).setCheckState(Qt.Checked)
def _selectNone(self):
"""
Unselect all rows in the sequence table.
"""
for row in range(self.sequenceTable.rowCount()):
self.sequenceTable.item(row, 0).setCheckState(Qt.Unchecked)
def _invertSelection(self):
"""
Inverto row selection range in the sequence table.
"""
for row in range(self.sequenceTable.rowCount()):
item_widget = self.sequenceTable.item(row, 0)
if item_widget.checkState() == Qt.Checked:
item_widget.setCheckState(Qt.Unchecked)
else:
item_widget.setCheckState(Qt.Checked)
def _get_mutation_descriptor(self, aa):
"""
Get mutation descriptor string for a given amino acid.
"""
aa_string = self.rosetta_all_set
range = aa.get_mutation_range()
aa_string = self.rosetta_all_set
if range == "NATRO" or \
range == "NATAA":
code = aa.get_one_letter_code()
aa_string = re.sub("[^" + code + "]", '_', aa_string)
elif range == "POLAR":
aa_string = self.rosetta_polar_set
elif range == "APOLA":
aa_string = self.rosetta_apolar_set
elif range == "PIKAA":
aa_string = aa.get_mutation_descriptor()
return aa_string
def _get_descriptor_name(self, aa):
"""
Returns a mutation descriptor name for an amino acid.
"""
range_name = aa.get_mutation_range()
for i in range(len(self.rosetta_set_names)):
if range_name == self.rosetta_set_names[i]:
if range_name == "PIKAA":
# Find a descriptor with a list of
# custom descriptors.
dstr = self._makeProperAAString(
aa.get_mutation_descriptor())
for i in range(5, len(self.descriptor_list)):
if dstr == self.descriptor_list[i]:
return self.set_names[i]
else:
return self.set_names[i]
return "Custom"
def _get_aa_for_index(self, index, expand=False):
"""
Get amino acid by index.
@return: amino acid (Residue)
"""
if not self.current_protein:
return None
else:
currentProteinChunk = self.current_protein
currentProteinChunk.protein.set_current_amino_acid_index(index)
current_aa = currentProteinChunk.protein.get_current_amino_acid()
if expand:
currentProteinChunk.protein.collapse_all_rotamers()
currentProteinChunk.protein.expand_rotamer(current_aa)
return current_aa
def _sequenceTableCellChanged(self, crow, ccol):
"""
Slot for sequence table CellChanged event.
"""
item = self.sequenceTable.item(crow, ccol)
for row in range(self.sequenceTable.rowCount()):
self.sequenceTable.removeCellWidget(row, 2)
self.sequenceTable.setRowHeight(row, 16)
if ccol == 2:
# Make the row a little bit wider.
self.sequenceTable.setRowHeight(crow, 22)
# Create and insert a Combo Box into a current cell.
self.setComboBox = QComboBox()
self.setComboBox.addItems(self.set_names)
self.win.connect(self.setComboBox, SIGNAL("activated(int)"),
self._setComboBoxIndexChanged)
self.sequenceTable.setCellWidget(crow, 2, self.setComboBox)
current_aa = self._get_aa_for_index(crow, expand=True)
if current_aa:
# Center on the selected amino acid.
if self.recenterViewCheckBox.isChecked():
ca_atom = current_aa.get_c_alpha_atom()
if ca_atom:
self.win.glpane.pov = -ca_atom.posn()
self.win.glpane.gl_update()
# Update backrub status for selected amino acid.
if ccol == 3:
cbox = self.sequenceTable.item(crow, 3)
if cbox.checkState() == Qt.Checked:
current_aa.set_backrub_mode(True)
else:
current_aa.set_backrub_mode(False)
from PyQt4.Qt import QTextCursor
cursor = self.sequenceEditor.sequenceTextEdit.textCursor()
#boundary condition
if crow == -1:
crow = 0
cursor.setPosition(crow, QTextCursor.MoveAnchor)
cursor.setPosition(crow + 1, QTextCursor.KeepAnchor)
self.sequenceEditor.sequenceTextEdit.setTextCursor(cursor)
def _applyDescriptor(self):
"""
Apply mutation descriptor to the selected amino acids.
"""
cdes = self.descriptorsTable.currentRow()
for row in range(self.sequenceTable.rowCount()):
self._setComboBoxIndexChanged(cdes + 5,
tablerow=row,
selectedOnly=True)
def _setComboBoxIndexChanged(self,
index,
tablerow=None,
selectedOnly=False):
"""
Slot for mutation descriptor combo box (in third column of the sequence
table.)
"""
if tablerow is None:
crow = self.sequenceTable.currentRow()
else:
crow = tablerow
item = self.sequenceTable.item(crow, 2)
if item:
self.editingItem = True
cbox = self.sequenceTable.item(crow, 0)
if not selectedOnly or \
cbox.checkState() == Qt.Checked:
item.setText(self.set_names[index])
item = self.sequenceTable.item(crow, 4)
aa = self._get_aa_for_index(crow)
set_name = self.rosetta_set_names[index]
aa.set_mutation_range(set_name)
if set_name == "PIKAA":
aa.set_mutation_descriptor(self.descriptor_list[index])
item.setText(self._get_mutation_descriptor(aa))
for row in range(self.sequenceTable.rowCount()):
self.sequenceTable.removeCellWidget(row, 2)
self.sequenceTable.setRowHeight(row, 16)
self.editingItem = False
def scrollToPosition(self, index):
"""
Scrolls the Sequence Table to a given sequence position.
"""
item = self.sequenceTable.item(index, 0)
if item:
self.sequenceTable.scrollToItem(item)
def _applyAny(self):
"""
Apply "ALLAA" descriptor.
"""
for row in range(self.sequenceTable.rowCount()):
self._setComboBoxIndexChanged(0, tablerow=row, selectedOnly=True)
def _applySame(self):
"""
Apply "NATAA" descriptor.
"""
for row in range(self.sequenceTable.rowCount()):
self._setComboBoxIndexChanged(1, tablerow=row, selectedOnly=True)
def _applyLocked(self):
"""
Apply "NATRO" descriptor.
"""
for row in range(self.sequenceTable.rowCount()):
self._setComboBoxIndexChanged(2, tablerow=row, selectedOnly=True)
def _applyPolar(self):
"""
Apply "POLAR" descriptor.
"""
for row in range(self.sequenceTable.rowCount()):
self._setComboBoxIndexChanged(3, tablerow=row, selectedOnly=True)
def _applyApolar(self):
"""
Apply "APOLA" descriptor.
"""
for row in range(self.sequenceTable.rowCount()):
self._setComboBoxIndexChanged(4, tablerow=row, selectedOnly=True)
def resizeEvent(self, event):
"""
Called whenever PM width has changed. Sets correct width of the
rows in descriptor and sequence tables.
"""
self.descriptorsTable.setColumnWidth(
1,
self.descriptorsTable.width() -
self.descriptorsTable.columnWidth(0) - 20)
self.sequenceTable.setColumnWidth(
4,
self.sequenceTable.width() - (self.sequenceTable.columnWidth(0) +
self.sequenceTable.columnWidth(1) +
self.sequenceTable.columnWidth(2) +
self.sequenceTable.columnWidth(3)) -
20)
def _addNewDescriptorTableRow(self, name, descriptor):
"""
Adds a new row to the descriptor table.
"""
row = self.descriptorsTable.rowCount()
self.descriptorsTable.insertRow(row)
item_widget = QTableWidgetItem(name)
item_widget.setFont(self.labelfont)
item_widget.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
| Qt.ItemIsEditable)
item_widget.setTextAlignment(Qt.AlignLeft)
self.descriptorsTable.setItem(row, 0, item_widget)
self.descriptorsTable.resizeColumnToContents(0)
s = self._makeProperAAString(descriptor)
item_widget = QTableWidgetItem(s)
item_widget.setFont(self.descriptorfont)
item_widget.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
| Qt.ItemIsEditable)
item_widget.setTextAlignment(Qt.AlignLeft)
self.descriptorsTable.setItem(row, 1, item_widget)
self.descriptorsTable.setColumnWidth(
1,
self.descriptorsTable.width() -
self.descriptorsTable.columnWidth(0) - 20)
self.descriptorsTable.setRowHeight(row, 16)
def _addNewDescriptor(self):
"""
Adds a new descriptor to the descriptor table.
"""
self._addNewDescriptorTableRow("New Set", "PGAVILMFWYCSTNQDEHKR")
self._makeDescriptorUserPref()
self._updateSetLists()
def _removeDescriptor(self):
"""
Removes a highlighted descriptor from the descriptors table.
"""
crow = self.descriptorsTable.currentRow()
if crow >= 0:
self.descriptorsTable.removeRow(crow)
self._makeDescriptorUserPref()
self._updateSetLists()
def _makeDescriptorUserPref(self):
"""
Constructs a custom descriptors string.
"""
dstr = ""
for row in range(self.descriptorsTable.rowCount()):
item0 = self.descriptorsTable.item(row, 0)
item1 = self.descriptorsTable.item(row, 1)
if item0 and \
item1:
dstr += item0.text() + \
":" + \
item1.text() + \
":"
env.prefs[proteinCustomDescriptors_prefs_key] = dstr
def _makeProperAAString(self, string):
"""
Creates a proper amino acid string from an arbitrary string.
"""
aa_string = str(string).upper()
new_aa_string = ""
for i in range(len(self.rosetta_all_set)):
if aa_string.find(self.rosetta_all_set[i]) == -1:
new_aa_string += "_"
else:
new_aa_string += self.rosetta_all_set[i]
return new_aa_string
def _sequenceTableItemChanged(self, item):
"""
Called when an item in the sequence table has changed.
"""
if self.editingItem:
return
if self.sequenceTable.column(item) == 4:
self.editingItem = True
crow = self.sequenceTable.currentRow()
dstr = self._makeProperAAString(str(item.text()).upper())
item.setText(dstr)
aa = self._get_aa_for_index(crow)
if aa:
aa.set_mutation_range("PIKAA")
aa.set_mutation_descriptor(dstr.replace("_", ""))
item = self.sequenceTable.item(crow, 2)
if item:
item.setText("Custom")
self.editingItem = False
def _descriptorsTableItemChanged(self, item):
"""
Called when an item in the descriptors table has changed.
"""
if self.editingItem:
return
if self.descriptorsTable.column(item) == 1:
self.editingItem = True
item.setText(self._makeProperAAString(str(item.text()).upper()))
self.editingItem = False
self._makeDescriptorUserPref()
self._updateSetLists()
def _updateSetLists(self):
"""
Updates lists of descriptor sets and descriptor set names.
"""
self.set_names = self.set_names[:5]
self.descriptor_list = self.descriptor_list[:5]
self.rosetta_set_names = self.rosetta_set_names[:5]
dstr = env.prefs[proteinCustomDescriptors_prefs_key].split(":")
for i in range(len(dstr) / 2):
self.set_names.append(dstr[2 * i])
self.descriptor_list.append(dstr[2 * i + 1])
self.rosetta_set_names.append("PIKAA")
#self._addNewDescriptorTableRow(dstr[2*i], dstr[2*i+1])
return
def _update_UI_do_updates_TEMP(self):
"""
Overrides superclass method.
@see: Command_PropertyManager._update_UI_do_updates()
"""
self.current_protein = self.win.assy.getSelectedProteinChunk()
if self.current_protein is self.previous_protein:
print "_update_UI_do_updates(): DO NOTHING."
return
# NOTE: Changing the display styles of the protein chunks can take some
# time. We should put up the wait (hourglass) cursor here and restore
# before returning.
# Update all PM widgets that need to be since something has changed.
print "_update_UI_do_updates(): UPDATING the PMGR."
self.update_name_field()
self.sequenceEditor.update()
self.update_residue_combobox()
if self.previous_protein:
self.previous_protein.setDisplayStyle(
self.previous_protein_display_style)
self.previous_protein = self.current_protein
if self.current_protein:
self.previous_protein_display_style = self.current_protein.getDisplayStyle(
)
self.current_protein.setDisplayStyle(diPROTEIN)
return
class EditResidues_PropertyManager(PM_Dialog, DebugMenuMixin):
"""
The ProteinDisplayStyle_PropertyManager class provides a Property Manager
for the B{Display Style} command on the flyout toolbar in the
Build > Protein mode.
@ivar title: The title that appears in the property manager header.
@type title: str
@ivar pmName: The name of this property manager. This is used to set
the name of the PM_Dialog object via setObjectName().
@type name: str
@ivar iconPath: The relative path to the PNG file that contains a
22 x 22 icon image that appears in the PM header.
@type iconPath: str
"""
title = "Edit Residues"
pmName = title
iconPath = "ui/actions/Edit/EditProteinDisplayStyle.png"
def __init__(self, parentCommand):
"""
Constructor for the property manager.
"""
self.parentMode = parentCommand
self.w = self.parentMode.w
self.win = self.parentMode.w
self.pw = self.parentMode.pw
self.o = self.win.glpane
self.currentWorkingDirectory = env.prefs[workingDirectory_prefs_key]
PM_Dialog.__init__(self, self.pmName, self.iconPath, self.title)
DebugMenuMixin._init1(self)
self.showTopRowButtons( PM_DONE_BUTTON | \
PM_WHATS_THIS_BUTTON)
msg = "Edit residues."
self.updateMessage(msg)
def connect_or_disconnect_signals(self, isConnect=True):
if isConnect:
change_connect = self.win.connect
else:
change_connect = self.win.disconnect
#change_connect(self.nextAAPushButton,
# SIGNAL("clicked()"),
# self._expandNextRotamer)
def ok_btn_clicked(self):
"""
Slot for the OK button
"""
self.win.toolsDone()
def cancel_btn_clicked(self):
"""
Slot for the Cancel button.
"""
#TODO: Cancel button needs to be removed. See comment at the top
self.win.toolsDone()
def show(self):
"""
Shows the Property Manager. Overrides PM_Dialog.show.
"""
self.sequenceEditor = self.win.createProteinSequenceEditorIfNeeded()
self.sequenceEditor.hide()
PM_Dialog.show(self)
# Update all PM widgets, then establish their signal-slot connections.
# note: It is important to update the widgets *first* since doing
# it in the reverse order will generate signals when updating
# the PM widgets (via updateDnaDisplayStyleWidgets()), causing
# unneccessary repaints of the model view.
self._fillSequenceTable()
self.connect_or_disconnect_signals(isConnect=True)
def close(self):
"""
Closes the Property Manager. Overrides PM_Dialog.close.
"""
self.connect_or_disconnect_signals(False)
PM_Dialog.close(self)
def _addGroupBoxes(self):
"""
Add the Property Manager group boxes.
"""
self._pmGroupBox1 = PM_GroupBox(self, title="Sequence")
self._loadGroupBox1(self._pmGroupBox1)
#self._pmGroupBox2 = PM_GroupBox( self,
# title = "Rotamer")
#self._loadGroupBox2( self._pmGroupBox2 )
def _loadGroupBox1(self, pmGroupBox):
"""
Load widgets in group box.
"""
self.labelfont = QFont("Helvetica", 12)
self.descriptorfont = QFont("Courier New", 12)
self.headerdata = ['', 'ID', 'Set', 'Descriptor']
self.set_names = ["Any", "Same", "Locked", "Polar", "Apolar"]
self.rosetta_set_names = ["ALLAA", "NATRO", "NATAA", "POLAR", "APOLA"]
self.descriptor_list = [
"GAVILMFWCSTYNQDEHKRP", "____________________",
"____________________", "________CSTYNQDEHKR_",
"GAVILMFW___________P"
]
self.descriptorsTable = PM_TableWidget(pmGroupBox)
self.descriptorsTable.setFixedHeight(100)
self.descriptorsTable.setRowCount(len(self.set_names))
self.descriptorsTable.setColumnCount(2)
self.descriptorsTable.verticalHeader().setVisible(False)
self.descriptorsTable.horizontalHeader().setVisible(False)
for index in range(len(self.set_names)):
item_widget = QTableWidgetItem(self.set_names[index])
item_widget.setFont(self.labelfont)
item_widget.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
| Qt.ItemIsEditable)
item_widget.setTextAlignment(Qt.AlignCenter)
self.descriptorsTable.setItem(index, 0, item_widget)
item_widget = QTableWidgetItem(self.descriptor_list[index])
item_widget.setFont(self.descriptorfont)
item_widget.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
| Qt.ItemIsEditable)
item_widget.setTextAlignment(Qt.AlignCenter)
self.descriptorsTable.setItem(index, 1, item_widget)
self.descriptorsTable.setRowHeight(index, 16)
pass
self.descriptorsTable.resizeColumnsToContents()
self.applyDescriptorPushButton = PM_PushButton(pmGroupBox,
text="Apply",
setAsDefault=True)
self.selectAllPushButton = PM_PushButton(pmGroupBox,
text="All",
setAsDefault=True)
self.selectNonePushButton = PM_PushButton(pmGroupBox,
text="None",
setAsDefault=True)
self.selectInvertPushButton = PM_PushButton(pmGroupBox,
text="Invert",
setAsDefault=True)
self.win.connect(self.applyDescriptorPushButton, SIGNAL("clicked()"),
self._applyDescriptor)
self.win.connect(self.selectAllPushButton, SIGNAL("clicked()"),
self._selectAll)
self.win.connect(self.selectNonePushButton, SIGNAL("clicked()"),
self._selectNone)
self.win.connect(self.selectInvertPushButton, SIGNAL("clicked()"),
self._invertSelection)
buttonList = [('PM_PushButton', self.applyDescriptorPushButton, 0, 0),
('QSpacerItem', 5, 5, 1, 0),
('PM_PushButton', self.selectAllPushButton, 2, 0),
('PM_PushButton', self.selectNonePushButton, 3, 0),
('PM_PushButton', self.selectInvertPushButton, 4, 0)]
self.buttonGrid = PM_WidgetGrid(pmGroupBox, widgetList=buttonList)
self.recenterViewCheckBox = \
PM_CheckBox( pmGroupBox,
text = "Re-center view",
setAsDefault = True,
state = Qt.Checked)
self.sequenceTable = PM_TableWidget(pmGroupBox)
#self.sequenceTable.setModel(self.tableModel)
self.sequenceTable.resizeColumnsToContents()
self.sequenceTable.verticalHeader().setVisible(False)
#self.sequenceTable.setRowCount(0)
self.sequenceTable.setColumnCount(4)
self.checkbox = QCheckBox()
self.sequenceTable.setFixedHeight(345)
self.sequenceTable.setHorizontalHeaderLabels(self.headerdata)
###self._fillSequenceTable()
def _fillSequenceTable(self):
"""
"""
self.setComboBox = QComboBox()
for chunk in self.win.assy.molecules:
if chunk.isProteinChunk():
aa_list = chunk.protein.get_amino_acids()
aa_list_len = len(aa_list)
self.sequenceTable.setRowCount(aa_list_len)
for index in range(aa_list_len):
item_widget = QTableWidgetItem("")
item_widget.setFont(self.labelfont)
item_widget.setCheckState(Qt.Checked)
item_widget.setTextAlignment(Qt.AlignLeft)
item_widget.setSizeHint(QSize(20, 12))
item_widget.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
| Qt.ItemIsUserCheckable)
self.sequenceTable.setItem(index, 0, item_widget)
item_widget = QTableWidgetItem(str(index + 1))
item_widget.setFont(self.labelfont)
item_widget.setFlags(Qt.ItemIsSelectable
| Qt.ItemIsEnabled)
item_widget.setTextAlignment(Qt.AlignCenter)
self.sequenceTable.setItem(index, 1, item_widget)
item_widget = QTableWidgetItem("Any")
item_widget.setFont(self.labelfont)
item_widget.setFlags(Qt.ItemIsSelectable
| Qt.ItemIsEnabled)
item_widget.setTextAlignment(Qt.AlignCenter)
self.sequenceTable.setItem(index, 2, item_widget)
aa_string = self._get_mutation_descriptor(
self._get_aa_for_index(index))
item_widget = QTableWidgetItem(aa_string)
item_widget.setFont(self.descriptorfont)
self.sequenceTable.setItem(index, 3, item_widget)
self.sequenceTable.setRowHeight(index, 16)
self.win.connect(self.sequenceTable, SIGNAL("cellClicked(int, int)"),
self._sequenceTableCellChanged)
self.sequenceTable.resizeColumnsToContents()
self.sequenceTable.setColumnWidth(0, 35)
self.sequenceTable.setColumnWidth(2, 80)
def _selectAll(self):
for row in range(self.sequenceTable.rowCount()):
self.sequenceTable.item(row, 0).setCheckState(Qt.Checked)
def _selectNone(self):
for row in range(self.sequenceTable.rowCount()):
self.sequenceTable.item(row, 0).setCheckState(Qt.Unchecked)
def _invertSelection(self):
for row in range(self.sequenceTable.rowCount()):
item_widget = self.sequenceTable.item(row, 0)
if item_widget.checkState() == Qt.Checked:
item_widget.setCheckState(Qt.Unchecked)
else:
item_widget.setCheckState(Qt.Checked)
def _get_mutation_descriptor(self, aa):
"""
"""
aa_string = "GAVILMFWCSTYNQDEHKRP"
range = aa.get_mutation_range()
if range == "NATRO" or \
range == "NATAA":
code = aa.get_one_letter_code()
aa_string = re.sub("[^" + code + "]", '_', aa_string)
elif range == "POLAR":
aa_string = "________CSTYNQDEHKR_"
elif range == "APOLA":
aa_string = "GAVILMFW___________P"
return aa_string
def _get_aa_for_index(self, index, expand=False):
"""
"""
# Center on a selected amino acid.
for chunk in self.win.assy.molecules:
if chunk.isProteinChunk():
chunk.protein.set_current_amino_acid_index(index)
current_aa = chunk.protein.get_current_amino_acid()
if expand:
chunk.protein.collapse_all_rotamers()
chunk.protein.expand_rotamer(current_aa)
return current_aa
return None
def _sequenceTableCellChanged(self, crow, ccol):
#print "CELL CHANGED: ", (crow, ccol)
item = self.sequenceTable.item(crow, ccol)
#print "ITEM = ", item
for row in range(self.sequenceTable.rowCount()):
self.sequenceTable.removeCellWidget(row, 2)
self.sequenceTable.setRowHeight(row, 16)
if ccol == 2:
# Make the row a little bit wider.
self.sequenceTable.setRowHeight(crow, 22)
# Create and insert a Combo Box into a current cell.
self.setComboBox = QComboBox()
self.setComboBox.addItems(self.set_names)
self.win.connect(self.setComboBox,
SIGNAL("currentIndexChanged(int)"),
self._setComboBoxIndexChanged)
self.sequenceTable.setCellWidget(crow, 2, self.setComboBox)
current_aa = self._get_aa_for_index(crow, expand=True)
if current_aa:
# Center on the selected amino acid.
if self.recenterViewCheckBox.isChecked():
ca_atom = current_aa.get_c_alpha_atom()
if ca_atom:
self.win.glpane.pov = -ca_atom.posn()
self.win.glpane.gl_update()
def _applyDescriptor(self):
"""
"""
cdes = self.descriptorsTable.currentRow()
for row in range(self.sequenceTable.rowCount()):
#print "row = ", row
self._setComboBoxIndexChanged(cdes,
tablerow=row,
selectedOnly=True)
def _setComboBoxIndexChanged(self,
index,
tablerow=None,
selectedOnly=False):
"""
"""
#print "INDEX = ", index
if tablerow is None:
crow = self.sequenceTable.currentRow()
else:
crow = tablerow
#print "current row: ", crow
item = self.sequenceTable.item(crow, 2)
if item:
cbox = self.sequenceTable.item(crow, 0)
if not selectedOnly or \
cbox.checkState() == Qt.Checked:
item.setText(self.set_names[index])
item = self.sequenceTable.item(crow, 3)
aa = self._get_aa_for_index(crow)
aa.set_mutation_range(self.rosetta_set_names[index])
item.setText(self._get_mutation_descriptor(aa))
###self._write_resfile()
def _write_resfile(self):
from protein.model.Protein import write_rosetta_resfile
for chunk in self.win.assy.molecules:
if chunk.isProteinChunk():
write_rosetta_resfile("/Users/piotr/test.resfile", chunk)
return
def _addWhatsThisText(self):
#from ne1_ui.WhatsThisText_for_PropertyManagers import WhatsThis_EditResidues_PropertyManager
#WhatsThis_EditResidues_PropertyManager(self)
pass
def _addToolTipText(self):
#from ne1_ui.ToolTipText_for_PropertyManagers import ToolTip_EditProteinDisplayStyle_PropertyManager
#ToolTip_EditProteinDisplayStyle_PropertyManager(self)
pass
def scrollToPosition(self, index):
"""
Scrolls the Sequence Table to a given sequence position.
"""
item = self.sequenceTable.item(index, 0)
if item:
self.sequenceTable.scrollToItem(item)
class ValueTypeEditor(QWidget):
ValueTypes = (bool, int, float, complex, str)
def __init__(self, *args):
QWidget.__init__(self, *args)
lo = QHBoxLayout(self)
lo.setContentsMargins(0, 0, 0, 0)
lo.setSpacing(5)
# type selector
self.wtypesel = QComboBox(self)
for i, tp in enumerate(self.ValueTypes):
self.wtypesel.addItem(tp.__name__)
QObject.connect(self.wtypesel, SIGNAL("activated(int)"), self._selectTypeNum)
typesel_lab = QLabel("&Type:", self)
typesel_lab.setBuddy(self.wtypesel)
lo.addWidget(typesel_lab, 0)
lo.addWidget(self.wtypesel, 0)
self.wvalue = QLineEdit(self)
self.wvalue_lab = QLabel("&Value:", self)
self.wvalue_lab.setBuddy(self.wvalue)
self.wbool = QComboBox(self)
self.wbool.addItems(["false", "true"])
self.wbool.setCurrentIndex(1)
lo.addWidget(self.wvalue_lab, 0)
lo.addWidget(self.wvalue, 1)
lo.addWidget(self.wbool, 1)
self.wvalue.hide()
# make input validators
self._validators = {int: QIntValidator(self), float: QDoubleValidator(self)}
# select bool type initially
self._selectTypeNum(0)
def _selectTypeNum(self, index):
tp = self.ValueTypes[index]
self.wbool.setShown(tp is bool)
self.wvalue.setShown(tp is not bool)
self.wvalue_lab.setBuddy(self.wbool if tp is bool else self.wvalue)
self.wvalue.setValidator(self._validators.get(tp, None))
def setValue(self, value):
"""Sets current value"""
for i, tp in enumerate(self.ValueTypes):
if isinstance(value, tp):
self.wtypesel.setCurrentIndex(i)
self._selectTypeNum(i)
if tp is bool:
self.wbool.setCurrentIndex(1 if value else 0)
else:
self.wvalue.setText(str(value))
return
# unknown value: set bool
self.setValue(True)
def getValue(self):
"""Returns current value, or None if no legal value is set"""
tp = self.ValueTypes[self.wtypesel.currentIndex()]
if tp is bool:
return bool(self.wbool.currentIndex())
else:
try:
return tp(self.wvalue.text())
except:
print("Error converting input to type ", tp.__name__)
traceback.print_exc()
return None
class AddTagDialog(QDialog):
def __init__(self, parent, modal=True, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent, flags)
self.setModal(modal)
self.setWindowTitle("Add Tag")
lo = QVBoxLayout(self)
lo.setMargin(10)
lo.setSpacing(5)
# tag selector
lo1 = QHBoxLayout()
lo.addLayout(lo1)
lo1.setSpacing(5)
self.wtagsel = QComboBox(self)
self.wtagsel.setEditable(True)
wtagsel_lbl = QLabel("&Tag:", self)
wtagsel_lbl.setBuddy(self.wtagsel)
lo1.addWidget(wtagsel_lbl, 0)
lo1.addWidget(self.wtagsel, 1)
QObject.connect(self.wtagsel, SIGNAL("activated(int)"), self._check_tag)
QObject.connect(self.wtagsel, SIGNAL("editTextChanged(const QString &)"), self._check_tag_text)
# value editor
self.valedit = ValueTypeEditor(self)
lo.addWidget(self.valedit)
# buttons
lo.addSpacing(10)
lo2 = QHBoxLayout()
lo.addLayout(lo2)
lo2.setContentsMargins(0, 0, 0, 0)
lo2.setMargin(5)
self.wokbtn = QPushButton("OK", self)
self.wokbtn.setMinimumWidth(128)
QObject.connect(self.wokbtn, SIGNAL("clicked()"), self.accept)
self.wokbtn.setEnabled(False)
cancelbtn = QPushButton("Cancel", self)
cancelbtn.setMinimumWidth(128)
QObject.connect(cancelbtn, SIGNAL("clicked()"), self.reject)
lo2.addWidget(self.wokbtn)
lo2.addStretch(1)
lo2.addWidget(cancelbtn)
self.setMinimumWidth(384)
def setTags(self, tagnames):
self.wtagsel.clear()
self.wtagsel.addItems(list(tagnames))
self.wtagsel.addItem("")
self.wtagsel.setCurrentIndex(len(tagnames))
def setValue(self, value):
self.valedit.setValue(value)
def _check_tag(self, tag):
self.wokbtn.setEnabled(True)
def _check_tag_text(self, text):
self.wokbtn.setEnabled(bool(str(text) != ""))
def accept(self):
"""When dialog is accepted with a default (bool) tag type,
check if the user hasn't entered a name=value entry in the tag name field.
This is a common mistake, and should be treated as a shortcut for setting string tags."""
if isinstance(self.valedit.getValue(), bool):
tagval = str(self.wtagsel.currentText()).split("=", 1)
if len(tagval) > 1:
# print tagval
if QMessageBox.warning(self,
"Set a string tag instead?", """<P>You have included an "=" sign in the tag name.
Perhaps you actually mean to set tag "%s" to the string value "%s"?</P>""" % tuple(tagval),
QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes) == QMessageBox.No:
return
self.wtagsel.setEditText(tagval[0])
self.valedit.setValue(tagval[1])
return QDialog.accept(self)
def getTag(self):
return str(self.wtagsel.currentText()), self.valedit.getValue()
def _addChart(self):
fig = pyplot.figure()
canvas = FigureCanvas(fig)
iNode = 2 * model._nodes.index(self.__node)
data = {
't': list(record.times),
'pos_x': [ x[iNode+0] for x in record.states],
'pos_y': [ x[iNode+1] for x in record.states],
'v_x': [ v[iNode+0] for v in record.velocities],
'v_y': [ v[iNode+1] for v in record.velocities]
}
xBox,yBox = QComboBox(), QComboBox()
keys = list( data.keys() )
xBox.addItems(keys)
yBox.addItems(keys)
xBox.setCurrentIndex( keys.index('pos_y') )
yBox.setCurrentIndex( keys.index('v_x') )
plot = fig.add_subplot(1,1,1)
chart, = plot.plot([],[])
def replot(*args):
xSelection = str( xBox.currentText() )
ySelection = str( yBox.currentText() )
chart.set_xdata( data[xSelection] )
chart.set_ydata( data[ySelection] )
plot.relim()
plot.autoscale_view(True,True,True)
canvas.draw()
replot()
def addState(x):
assert iNode == 2 * model._nodes.index(self.__node)
data['t'].append(record.times[-1])
pos_x,pos_y = record.states[-1][iNode:iNode+2]
data['pos_x'].append(pos_x)
data['pos_y'].append(pos_y)
v_x, v_y = record.velocities[-1][iNode:iNode+2]
data['v_x'].append(v_x)
data['v_y'].append(v_y)
replot()
xBox.currentIndexChanged.connect(replot)
yBox.currentIndexChanged.connect(replot)
if hasattr(record,'changeListeners'):
record.changeListeners.append(addState)
class WidgetWithCloseEvent(QWidget):
def __init__(this):
super(WidgetWithCloseEvent,this).__init__()
def closeEvent(this,event):
super(WidgetWithCloseEvent,this).closeEvent(event)
if event.isAccepted():
del self._chart
if hasattr(record,'changeListeners'):
record.changeListeners.remove(addState)
wdgt = WidgetWithCloseEvent()
wdgt.setWindowTitle( "Line chart for node '"+self.__node+"'")
toolbar = NavigationToolbar(canvas,wdgt)
layout = QGridLayout()
layout.addWidget( toolbar, 0,0, 1,4 )
layout.addWidget(xBox,1,1)
layout.addWidget(yBox,1,3)
layout.addWidget( QLabel('x-Axis:'), 1,0, 1,1, Qt.AlignRight )
layout.addWidget( QLabel('y-Axis:'), 1,2, 1,1, Qt.AlignRight )
layout.addWidget( canvas, 2,0, 1,4 )
wdgt.setLayout(layout)
wdgt.show()
self._chart = wdgt
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, "\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]
class TwitterGui(QWidget):
URL_REGEX = re.compile(r'''((?:mailto:|ftp://|http://|https://)[^ <>'"{}|\\^`[\]]*)''')
def __init__(self, parent, logger, db_conn, update_func, safe_conn):
super(TwitterGui, self).__init__(parent)
self._db_conn = db_conn
self.logger = logger
self._reply_to_id = 0
self._update_func = update_func
self._list = None
if get_settings().get_proxy():
u = urlparse.urlsplit(get_settings().get_proxy())
proxy = QNetworkProxy()
proxy.setType(QNetworkProxy.HttpProxy)
proxy.setHostName(u.hostname);
proxy.setPort(u.port)
QNetworkProxy.setApplicationProxy(proxy);
self.msgview = QWebView(self)
self.msgview.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.msgview.linkClicked.connect(self.link_clicked)
self.userCombo = QComboBox(self)
self.userCombo.setEditable(True)
self.userCombo.activated.connect(self.toggle_user_in_list)
self.showButton = QPushButton(chr(94), self)
self.showButton.setMaximumHeight(13)
self.showButton.clicked.connect(self.show_hide_animation)
self.post_field = QTextEdit(self)
self.post_field.setMaximumHeight(50)
self.post_field.textChanged.connect(self.text_changed)
self.send_button = QPushButton("Post", self)
self.send_button.clicked.connect(self.post_status_clicked)
self.refresh_button = QPushButton("Refresh", self)
self.refresh_button.clicked.connect(self._update_func)
self.attach_button = QPushButton("Attach", self)
self.attach_button.clicked.connect(lambda _ : self.set_status("Attach something"))
self.lists_box = QComboBox(self)
self.lists_box.currentIndexChanged.connect(self.list_changed)
self.lists_box.setEditable(False)
self.lists_box.addItems([u"Home"] + self._db_conn.get_lists())
self.statusLabel = QLabel("Status", self)
self.charCounter = QLabel("0", self)
self.gridw = QWidget(self)
self.gridw.setContentsMargins(0, 0, 0, 0)
gridlay = QGridLayout(self.gridw)
gridlay.setContentsMargins(0, 0, 0, 0)
gridlay.addWidget(self.post_field, 0, 0, 2, 1)
gridlay.addWidget(self.attach_button, 0, 1, 1, 1)
gridlay.addWidget(self.send_button, 1, 1, 1, 1)
gridlay.addWidget(self.lists_box, 0, 2, 1, 1)
gridlay.addWidget(self.refresh_button, 1, 2, 1, 1)
gridlay.addWidget(self.statusLabel, 2, 0, 1, 1)
gridlay.addWidget(self.charCounter, 2, 1, 1, 2)
hlay = QVBoxLayout(self)
hlay.addWidget(self.msgview)
hlay.addWidget(self.userCombo)
hlay.addWidget(self.showButton)
hlay.addWidget(self.gridw)
safe_conn.connect_home_timeline_updated(self.update_view)
safe_conn.connect_twitter_loop_started(self.start_refresh_animation)
safe_conn.connect_twitter_loop_stopped(self.stop_refresh_animation)
safe_conn.connect_update_posted(self.enable_posting)
safe_conn.connect_range_limit_exceeded(lambda _ : self.set_status("Range limit exceeded"))
safe_conn.connect_not_authenticated(lambda _ : self.set_status("Authentication failed"))
self.gridw.hide()
self.update_view()
self.set_status("Twitter plugin initialized")
def enable_posting(self, q_id, m_id):
if m_id>1:
self.post_field.setText("")
self.set_status("Tweet posted")
else:
self.set_status("Failed to post tweet, Error: " + str(abs(m_id)))
self.post_field.setEnabled(True)
def link_clicked(self, url):
if not url.host():
if url.hasQueryItem("reply-to") and url.hasQueryItem("screen-name"):
self._reply_to_id = long(convert_string(url.queryItemValue("reply-to")))
self.post_field.setPlainText("@"+convert_string(url.queryItemValue("screen-name"))+" ")
self.set_status("Reply to @"+convert_string(url.queryItemValue("screen-name")))
else:
self.logger.error("Unknown command from link: "+str(url.toString()))
else:
webbrowser.open(str(url.toString()))
def list_changed(self, list_idx):
if list_idx:
self._list = convert_string(self.lists_box.currentText())
self.userCombo.clear()
self.userCombo.addItems(self._db_conn.get_known_users())
self.userCombo.completer().setCompletionMode(QCompleter.PopupCompletion)
self.userCombo.show()
self.set_status(self._list)
else:
self.userCombo.hide()
self._list = None
self.update_view()
def post_status_clicked(self):
msg = unicode(self.post_field.toPlainText().toUtf8(), encoding="UTF-8")
if msg:
self._db_conn.insert_post_queue(msg, self._reply_to_id)
self._reply_to_id = 0
self._update_func()
self.post_field.setDisabled(True)
def start_refresh_animation(self):
self.refresh_button.setDisabled(True)
def stop_refresh_animation(self):
self.refresh_button.setEnabled(True)
def show_hide_animation(self):
if self.gridw.isHidden():
self.gridw.show()
self.showButton.setText("v")
else:
self.gridw.hide()
self.showButton.setText(chr(94))
def text_changed(self):
count = len(self.post_field.toPlainText())
if count==0:
self._reply_to_id = 0
if self._reply_to_id:
self.charCounter.setText(str(count) + " - reply to ")
else:
self.charCounter.setText(str(count))
def toggle_user_in_list(self, _):
user = convert_string(self.userCombo.currentText())
if user in self._db_conn.get_users_from_list(self._list):
self._db_conn.delete_user_from_list(user, self._list)
self.set_status("Removed user %s from list %s"%(user, self._list))
else:
self._db_conn.add_user_to_list(user, self._list)
self.set_status("Added user %s to list %s"%(user, self._list))
self.update_view()
@pyqtSlot(object)
def update_view(self, _ = None):
template_file_path = os.path.join(get_settings().get_main_config_dir(),"tweet.thtml")
tweets = self._db_conn.get_last_tweets(user_list = self._list)
if len(tweets)==0:
return 0
templ_text = '<div>\
<a href="http://twitter.com/$NAME$/status/$ID$">\
<img src="$IMAGE$" style="float: left; margin-right: 2px" alt="$NAME$" title="$NAME$"/>\
</a>\
<p>$TEXT$</p>\
<span><a href="http://twitter.com/$RT_USER$">$RT_USER$</a></span>\
<span style="float: right">$CREATE_TIME$ <a href="?retweet=$ID$">retweet</a> <a href="?reply-to=$ID$&screen-name=$NAME$">reply</a></span>\
</div>\
<hr style="clear: both" />\
'
if os.path.exists(template_file_path):
t_file = open(template_file_path, "r")
templ_text = t_file.read()
t_file.close()
txt = ""
for t in tweets:
"""m_id, screen_name, user_image, create_time, message_text, retweeted_by"""
text = self.URL_REGEX.sub(r'<a href="\1">\1</a>', t[4])
t_txt = templ_text.replace("$IMAGE$", t[2]).replace("$NAME$", t[1])
t_txt = t_txt.replace("$ID$", str(t[0])).replace("$TEXT$", text)
t_txt = t_txt.replace("$CREATE_TIME$", self.humanReadableTime(t[3]))
t_txt = t_txt.replace("$RT_USER$", t[5] if t[5] else "")
txt += t_txt
txt += "<p style=\"float:right\">Updated: %s</p>"%time.strftime("%H:%M")
self.msgview.setHtml(txt)
"""helper:"""
def set_status(self, status_text):
self.statusLabel.setText(status_text)
self.showButton.setToolTip(status_text)
def humanReadableTime(self, post_time):
fudge = 1.25
delta = long(time.time()) - long(post_time)
if delta < (1 * fudge):
return 'about a second ago'
elif delta < (60 * (1 / fudge)):
return 'about %d seconds ago' % (delta)
elif delta < (60 * fudge):
return 'about a minute ago'
elif delta < (60 * 60 * (1 / fudge)):
return 'about %d minutes ago' % (delta / 60)
elif delta < (60 * 60 * fudge) or delta / (60 * 60) == 1:
return 'about an hour ago'
elif delta < (60 * 60 * 24 * (1 / fudge)):
return 'about %d hours ago' % (delta / (60 * 60))
elif delta < (60 * 60 * 24 * fudge) or delta / (60 * 60 * 24) == 1:
return 'about a day ago'
else:
return 'about %d days ago' % (delta / (60 * 60 * 24))
class SourceSelectorDialog(QDialog):
def __init__(self, parent, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent, flags)
self.setModal(False)
self.setWindowTitle("Select sources by...")
lo = QVBoxLayout(self)
lo.setMargin(10)
lo.setSpacing(5)
# select by
lo1 = QHBoxLayout()
lo.addLayout(lo1)
lo1.setContentsMargins(0, 0, 0, 0)
# lab = QLabel("Select:")
# lo1.addWidget(lab)
self.wselby = QComboBox(self)
lo1.addWidget(self.wselby, 0)
QObject.connect(self.wselby, SIGNAL("activated(const QString &)"), self._setup_selection_by)
# under/over
self.wgele = QComboBox(self)
lo1.addWidget(self.wgele, 0)
self.wgele.addItems([">", ">=", "<=", "<", "sum<=", "sum>"])
QObject.connect(self.wgele, SIGNAL("activated(const QString &)"), self._select_threshold)
# threshold value
self.wthreshold = QLineEdit(self)
QObject.connect(self.wthreshold, SIGNAL("editingFinished()"), self._select_threshold)
lo1.addWidget(self.wthreshold, 1)
# min and max label
self.wminmax = QLabel(self)
lo.addWidget(self.wminmax)
# selection slider
lo1 = QHBoxLayout()
lo.addLayout(lo1)
self.wpercent = QSlider(self)
self.wpercent.setTracking(False)
QObject.connect(self.wpercent, SIGNAL("valueChanged(int)"), self._select_percentile)
QObject.connect(self.wpercent, SIGNAL("sliderMoved(int)"), self._select_percentile_threshold)
self.wpercent.setRange(0, 100)
self.wpercent.setOrientation(Qt.Horizontal)
lo1.addWidget(self.wpercent)
self.wpercent_lbl = QLabel("0%", self)
self.wpercent_lbl.setMinimumWidth(64)
lo1.addWidget(self.wpercent_lbl)
# # hide button
# lo.addSpacing(10)
# lo2 = QHBoxLayout()
# lo.addLayout(lo2)
# lo2.setContentsMargins(0,0,0,0)
# hidebtn = QPushButton("Close",self)
# hidebtn.setMinimumWidth(128)
# QObject.connect(hidebtn,SIGNAL("clicked()"),self.hide)
# lo2.addStretch(1)
# lo2.addWidget(hidebtn)
# lo2.addStretch(1)
# self.setMinimumWidth(384)
self._in_select_threshold = False
self._sort_index = None
self.qerrmsg = QErrorMessage(self)
def resetModel(self):
"""Resets dialog based on current model."""
if not self.model:
return
# getset of model tags, and remove the non-sorting tags
alltags = set(self.model.tagnames)
alltags -= NonSortingTags
# make list of tags from StandardTags that are present in model
self.sorttags = [tag for tag in StandardTags if tag in alltags or tag in TagAccessors]
# append model tags that were not in StandardTags
self.sorttags += list(alltags - set(self.sorttags))
# set selector
self.wselby.clear()
self.wselby.addItems(self.sorttags)
for tag in "Iapp", "I":
if tag in self.sorttags:
self.wselby.setCurrentIndex(self.sorttags.index(tag))
break
self._setup_selection_by(self.wselby.currentText())
def _reset_percentile(self):
self.wthreshold.setText("")
self.wpercent.setValue(50)
self.wpercent_lbl.setText("--%")
def _setup_selection_by(self, tag):
tag = str(tag); # may be QString
# clear threshold value and percentiles
self._reset_percentile()
# get min/max values, and sort indices
# _sort_index will be an array of (value,src,cumsum) tuples, sorted by tag value (high to low),
# where src is the source, and cumsum is the sum of all values in the list from 0 up to and including the current one
self._sort_index = []
minval = maxval = None
for isrc, src in enumerate(self.model.sources):
try:
if hasattr(src, tag):
value = float(getattr(src, tag))
else:
value = float(TagAccessors[tag](src))
# skip source if failed to access this tag as a float
except:
traceback.print_exc()
continue
self._sort_index.append([value, src, 0])
minval = min(minval, value) if minval is not None else value
maxval = max(maxval, value) if maxval is not None else value
# add label
if minval is None:
self._range = None
self.wminmax.setText("<font color=red>'%s' is not a numeric attribute</font>" % tag)
for w in self.wgele, self.wthreshold, self.wpercent, self.wpercent_lbl:
w.setEnabled(False)
else:
self._range = (minval, maxval)
self.wminmax.setText("min: %g max: %g" % self._range)
for w in self.wgele, self.wthreshold, self.wpercent, self.wpercent_lbl:
w.setEnabled(True)
# sort index by descending values
self._sort_index.sort(reverse=True)
# generate cumulative sums
cumsum = 0.
for entry in self._sort_index:
cumsum += entry[0]
entry[2] = cumsum
# Maps comparison operators to callables. Used in _select_threshold.
# Each callable takes two arguments: e is a tuple of (value,src,cumsum) (see _sort_index above), and x is a threshold
# Second argument is a flag: if False, selection is inverted w.r.t. operator
Operators = {
"<": ((lambda e, x: e[0] >= x), False),
"<=": ((lambda e, x: e[0] > x), False),
">": ((lambda e, x: e[0] > x), True),
">=": ((lambda e, x: e[0] >= x), True),
"sum<=": ((lambda e, x: e[2] <= x), True),
"sum>": ((lambda e, x: e[2] <= x), False)
}
def _select_threshold(self, *dum):
dprint(1, "select_threshold", dum)
self._in_select_threshold = True
busy = BusyIndicator()
try:
# get threshold, ignore if not set
threshold = str(self.wthreshold.text())
if not threshold:
self._reset_percentile()
return
# try to parse threshold, ignore if invalid
try:
threshold = float(threshold)
except:
self._reset_percentile()
return
# get comparison operator
op, select = self.Operators[str(self.wgele.currentText())]
# apply to initial segment (that matches operator)
for num, entry in enumerate(self._sort_index):
if not op(entry, threshold):
break
entry[1].selected = select
else:
num = len(self._sort_index)
# apply to remaining segment
for val, src, cumsum in self._sort_index[num:]:
src.selected = not select
# set percentile
percent = round(float(num * 100) / len(self._sort_index))
if not select:
percent = 100 - percent
self.wpercent.setValue(percent)
self.wpercent_lbl.setText("%3d%%" % percent)
# emit signal
self.model.emitSelection(self)
finally:
self._in_select_threshold = False
busy = None
def _select_percentile(self, percent):
self._select_percentile_threshold(percent, do_select=True)
def _select_percentile_threshold(self, percent, do_select=False):
# ignore if no sort index set up, or if _select_threshold() is being called
if self._sort_index is None or self._in_select_threshold:
return
dprint(1, "select_precentile_threshold", percent)
busy = BusyIndicator()
# number of objects to select
nsrc = len(self._sort_index)
nsel = int(math.ceil(nsrc * float(percent) / 100))
# get comparison operator
opstr = str(self.wgele.currentText())
op, select = self.Operators[opstr]
# select head or tail of list, depending on direction of operator
if select:
thr = self._sort_index[min(nsel, nsrc - 1)]
slc1 = slice(0, nsel)
slc2 = slice(nsel, None)
else:
thr = self._sort_index[-min(nsel + 1, nsrc)]
slc1 = slice(nsrc - nsel, None)
slc2 = slice(0, nsrc - nsel)
if do_select:
for val, src, cumsum in self._sort_index[slc1]:
src.selected = True
for val, src, cumsum in self._sort_index[slc2]:
src.selected = False
self.model.emitSelection(self)
self.wpercent_lbl.setText("%3d%%" % percent)
self.wthreshold.setText("%g" % (thr[2] if opstr.startswith("sum") else thr[0]))
return nsel
def setModel(self, model):
"""Sets the current model. If dialog is visible, applies the changes"""
self.model = model
if self.isVisible():
self.resetModel()
if not model:
self.hide()
def show(self):
"""Shows dialog, resetting the model if it was invisible."""
if not self.isVisible():
self.resetModel()
QDialog.show(self)
class ConfigWidget(QWidget, Logger):
'''
Config dialog for Marvin Manager
'''
WIZARD_PROFILES = {
'Annotations': {
'label': 'mm_annotations',
'datatype': 'comments',
'display': {},
'is_multiple': False
},
'Collections': {
'label': 'mm_collections',
'datatype': 'text',
'display': {
u'is_names': False
},
'is_multiple': True
},
'Last read': {
'label': 'mm_date_read',
'datatype': 'datetime',
'display': {},
'is_multiple': False
},
'Progress': {
'label': 'mm_progress',
'datatype': 'float',
'display': {
u'number_format': u'{0:.0f}%'
},
'is_multiple': False
},
'Read': {
'label': 'mm_read',
'datatype': 'bool',
'display': {},
'is_multiple': False
},
'Reading list': {
'label': 'mm_reading_list',
'datatype': 'bool',
'display': {},
'is_multiple': False
},
'Word count': {
'label': 'mm_word_count',
'datatype': 'int',
'display': {
u'number_format': u'{0:n}'
},
'is_multiple': False
}
}
def __init__(self, plugin_action):
QWidget.__init__(self)
self.parent = plugin_action
self.gui = get_gui()
self.icon = plugin_action.icon
self.opts = plugin_action.opts
self.prefs = plugin_prefs
self.resources_path = plugin_action.resources_path
self.verbose = plugin_action.verbose
self.restart_required = False
self._log_location()
self.l = QGridLayout()
self.setLayout(self.l)
self.column1_layout = QVBoxLayout()
self.l.addLayout(self.column1_layout, 0, 0)
self.column2_layout = QVBoxLayout()
self.l.addLayout(self.column2_layout, 0, 1)
# ----------------------------- Column 1 -----------------------------
# ~~~~~~~~ Create the Custom fields options group box ~~~~~~~~
self.cfg_custom_fields_gb = QGroupBox(self)
self.cfg_custom_fields_gb.setTitle('Custom column assignments')
self.column1_layout.addWidget(self.cfg_custom_fields_gb)
self.cfg_custom_fields_qgl = QGridLayout(self.cfg_custom_fields_gb)
current_row = 0
# ++++++++ Labels + HLine ++++++++
self.marvin_source_label = QLabel("Marvin source")
self.cfg_custom_fields_qgl.addWidget(self.marvin_source_label,
current_row, 0)
self.calibre_destination_label = QLabel("calibre destination")
self.cfg_custom_fields_qgl.addWidget(self.calibre_destination_label,
current_row, 1)
current_row += 1
self.sd_hl = QFrame(self.cfg_custom_fields_gb)
self.sd_hl.setFrameShape(QFrame.HLine)
self.sd_hl.setFrameShadow(QFrame.Raised)
self.cfg_custom_fields_qgl.addWidget(self.sd_hl, current_row, 0, 1, 3)
current_row += 1
# ++++++++ Annotations ++++++++
self.cfg_annotations_label = QLabel('Annotations')
self.cfg_annotations_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_annotations_label,
current_row, 0)
self.annotations_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.annotations_field_comboBox.setObjectName(
'annotations_field_comboBox')
self.annotations_field_comboBox.setToolTip(
'Select a custom column to store Marvin annotations')
self.cfg_custom_fields_qgl.addWidget(self.annotations_field_comboBox,
current_row, 1)
self.cfg_highlights_wizard = QToolButton()
self.cfg_highlights_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_highlights_wizard.setToolTip(
"Create a custom column to store Marvin annotations")
self.cfg_highlights_wizard.clicked.connect(
partial(self.launch_cc_wizard, 'Annotations'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_highlights_wizard,
current_row, 2)
current_row += 1
# ++++++++ Collections ++++++++
self.cfg_collections_label = QLabel('Collections')
self.cfg_collections_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_collections_label,
current_row, 0)
self.collection_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.collection_field_comboBox.setObjectName(
'collection_field_comboBox')
self.collection_field_comboBox.setToolTip(
'Select a custom column to store Marvin collection assignments')
self.cfg_custom_fields_qgl.addWidget(self.collection_field_comboBox,
current_row, 1)
self.cfg_collections_wizard = QToolButton()
self.cfg_collections_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_collections_wizard.setToolTip(
"Create a custom column for Marvin collection assignments")
self.cfg_collections_wizard.clicked.connect(
partial(self.launch_cc_wizard, 'Collections'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_collections_wizard,
current_row, 2)
current_row += 1
# ++++++++ Last read ++++++++
self.cfg_date_read_label = QLabel("Last read")
self.cfg_date_read_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_date_read_label,
current_row, 0)
self.date_read_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.date_read_field_comboBox.setObjectName('date_read_field_comboBox')
self.date_read_field_comboBox.setToolTip(
'Select a custom column to store Last read date')
self.cfg_custom_fields_qgl.addWidget(self.date_read_field_comboBox,
current_row, 1)
self.cfg_collections_wizard = QToolButton()
self.cfg_collections_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_collections_wizard.setToolTip(
"Create a custom column to store Last read date")
self.cfg_collections_wizard.clicked.connect(
partial(self.launch_cc_wizard, 'Last read'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_collections_wizard,
current_row, 2)
current_row += 1
# ++++++++ Progress ++++++++
self.cfg_progress_label = QLabel('Progress')
self.cfg_progress_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_progress_label,
current_row, 0)
self.progress_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.progress_field_comboBox.setObjectName('progress_field_comboBox')
self.progress_field_comboBox.setToolTip(
'Select a custom column to store Marvin reading progress')
self.cfg_custom_fields_qgl.addWidget(self.progress_field_comboBox,
current_row, 1)
self.cfg_progress_wizard = QToolButton()
self.cfg_progress_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_progress_wizard.setToolTip(
"Create a custom column to store Marvin reading progress")
self.cfg_progress_wizard.clicked.connect(
partial(self.launch_cc_wizard, 'Progress'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_progress_wizard,
current_row, 2)
current_row += 1
# ++++++++ Read flag ++++++++
self.cfg_read_label = QLabel('Read')
self.cfg_read_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_read_label, current_row,
0)
self.read_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.read_field_comboBox.setObjectName('read_field_comboBox')
self.read_field_comboBox.setToolTip(
'Select a custom column to store Marvin Read status')
self.cfg_custom_fields_qgl.addWidget(self.read_field_comboBox,
current_row, 1)
self.cfg_read_wizard = QToolButton()
self.cfg_read_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_read_wizard.setToolTip(
"Create a custom column to store Marvin Read status")
self.cfg_read_wizard.clicked.connect(
partial(self.launch_cc_wizard, 'Read'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_read_wizard, current_row,
2)
current_row += 1
# ++++++++ Reading list flag ++++++++
self.cfg_reading_list_label = QLabel('Reading list')
self.cfg_reading_list_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_reading_list_label,
current_row, 0)
self.reading_list_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.reading_list_field_comboBox.setObjectName(
'reading_list_field_comboBox')
self.reading_list_field_comboBox.setToolTip(
'Select a custom column to store Marvin Reading list status')
self.cfg_custom_fields_qgl.addWidget(self.reading_list_field_comboBox,
current_row, 1)
self.cfg_reading_list_wizard = QToolButton()
self.cfg_reading_list_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_reading_list_wizard.setToolTip(
"Create a custom column to store Marvin Reading list status")
self.cfg_reading_list_wizard.clicked.connect(
partial(self.launch_cc_wizard, 'Reading list'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_reading_list_wizard,
current_row, 2)
current_row += 1
# ++++++++ Word count ++++++++
self.cfg_word_count_label = QLabel('Word count')
self.cfg_word_count_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_word_count_label,
current_row, 0)
self.word_count_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.word_count_field_comboBox.setObjectName(
'word_count_field_comboBox')
self.word_count_field_comboBox.setToolTip(
'Select a custom column to store Marvin word counts')
self.cfg_custom_fields_qgl.addWidget(self.word_count_field_comboBox,
current_row, 1)
self.cfg_word_count_wizard = QToolButton()
self.cfg_word_count_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_word_count_wizard.setToolTip(
"Create a custom column to store Marvin word counts")
self.cfg_word_count_wizard.clicked.connect(
partial(self.launch_cc_wizard, 'Word count'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_word_count_wizard,
current_row, 2)
current_row += 1
self.spacerItem1 = QSpacerItem(20, 20, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.column1_layout.addItem(self.spacerItem1)
# ----------------------------- Column 2 -----------------------------
# ~~~~~~~~ Create the CSS group box ~~~~~~~~
self.cfg_css_options_gb = QGroupBox(self)
self.cfg_css_options_gb.setTitle('CSS')
self.column2_layout.addWidget(self.cfg_css_options_gb)
self.cfg_css_options_qgl = QGridLayout(self.cfg_css_options_gb)
current_row = 0
# ++++++++ Annotations appearance ++++++++
self.annotations_icon = QIcon(
os.path.join(self.resources_path, 'icons',
'annotations_hiliter.png'))
self.cfg_annotations_appearance_toolbutton = QToolButton()
self.cfg_annotations_appearance_toolbutton.setIcon(
self.annotations_icon)
self.cfg_annotations_appearance_toolbutton.clicked.connect(
self.configure_appearance)
self.cfg_css_options_qgl.addWidget(
self.cfg_annotations_appearance_toolbutton, current_row, 0)
self.cfg_annotations_label = ClickableQLabel("Annotations")
self.connect(self.cfg_annotations_label, SIGNAL('clicked()'),
self.configure_appearance)
self.cfg_css_options_qgl.addWidget(self.cfg_annotations_label,
current_row, 1)
current_row += 1
# ++++++++ Injected CSS ++++++++
self.css_editor_icon = QIcon(I('format-text-heading.png'))
self.cfg_css_editor_toolbutton = QToolButton()
self.cfg_css_editor_toolbutton.setIcon(self.css_editor_icon)
self.cfg_css_editor_toolbutton.clicked.connect(self.edit_css)
self.cfg_css_options_qgl.addWidget(self.cfg_css_editor_toolbutton,
current_row, 0)
self.cfg_css_editor_label = ClickableQLabel("Articles, Vocabulary")
self.connect(self.cfg_css_editor_label, SIGNAL('clicked()'),
self.edit_css)
self.cfg_css_options_qgl.addWidget(self.cfg_css_editor_label,
current_row, 1)
"""
# ~~~~~~~~ Create the Dropbox syncing group box ~~~~~~~~
self.cfg_dropbox_syncing_gb = QGroupBox(self)
self.cfg_dropbox_syncing_gb.setTitle('Dropbox')
self.column2_layout.addWidget(self.cfg_dropbox_syncing_gb)
self.cfg_dropbox_syncing_qgl = QGridLayout(self.cfg_dropbox_syncing_gb)
current_row = 0
# ++++++++ Syncing enabled checkbox ++++++++
self.dropbox_syncing_checkbox = QCheckBox('Enable Dropbox updates')
self.dropbox_syncing_checkbox.setObjectName('dropbox_syncing')
self.dropbox_syncing_checkbox.setToolTip('Refresh custom column content from Marvin metadata')
self.cfg_dropbox_syncing_qgl.addWidget(self.dropbox_syncing_checkbox,
current_row, 0, 1, 3)
current_row += 1
# ++++++++ Dropbox folder picker ++++++++
self.dropbox_folder_icon = QIcon(os.path.join(self.resources_path, 'icons', 'dropbox.png'))
self.cfg_dropbox_folder_toolbutton = QToolButton()
self.cfg_dropbox_folder_toolbutton.setIcon(self.dropbox_folder_icon)
self.cfg_dropbox_folder_toolbutton.setToolTip("Specify Dropbox folder location on your computer")
self.cfg_dropbox_folder_toolbutton.clicked.connect(self.select_dropbox_folder)
self.cfg_dropbox_syncing_qgl.addWidget(self.cfg_dropbox_folder_toolbutton,
current_row, 1)
# ++++++++ Dropbox location lineedit ++++++++
self.dropbox_location_lineedit = QLineEdit()
self.dropbox_location_lineedit.setPlaceholderText("Dropbox folder location")
self.cfg_dropbox_syncing_qgl.addWidget(self.dropbox_location_lineedit,
current_row, 2)
"""
# ~~~~~~~~ Create the General options group box ~~~~~~~~
self.cfg_runtime_options_gb = QGroupBox(self)
self.cfg_runtime_options_gb.setTitle('General options')
self.column2_layout.addWidget(self.cfg_runtime_options_gb)
self.cfg_runtime_options_qvl = QVBoxLayout(self.cfg_runtime_options_gb)
# ++++++++ Auto refresh checkbox ++++++++
self.auto_refresh_checkbox = QCheckBox(
'Automatically refresh custom column content')
self.auto_refresh_checkbox.setObjectName('auto_refresh_at_startup')
self.auto_refresh_checkbox.setToolTip(
'Update calibre custom column when Marvin XD is opened')
self.cfg_runtime_options_qvl.addWidget(self.auto_refresh_checkbox)
# ++++++++ Progress as percentage checkbox ++++++++
self.reading_progress_checkbox = QCheckBox(
'Show reading progress as percentage')
self.reading_progress_checkbox.setObjectName(
'show_progress_as_percentage')
self.reading_progress_checkbox.setToolTip(
'Display percentage in Progress column')
self.cfg_runtime_options_qvl.addWidget(self.reading_progress_checkbox)
# ~~~~~~~~ Create the Debug options group box ~~~~~~~~
self.cfg_debug_options_gb = QGroupBox(self)
self.cfg_debug_options_gb.setTitle('Debug options')
self.column2_layout.addWidget(self.cfg_debug_options_gb)
self.cfg_debug_options_qvl = QVBoxLayout(self.cfg_debug_options_gb)
# ++++++++ Debug logging checkboxes ++++++++
self.debug_plugin_checkbox = QCheckBox(
'Enable debug logging for Marvin XD')
self.debug_plugin_checkbox.setObjectName('debug_plugin_checkbox')
self.debug_plugin_checkbox.setToolTip(
'Print plugin diagnostic messages to console')
self.cfg_debug_options_qvl.addWidget(self.debug_plugin_checkbox)
self.debug_libimobiledevice_checkbox = QCheckBox(
'Enable debug logging for libiMobileDevice')
self.debug_libimobiledevice_checkbox.setObjectName(
'debug_libimobiledevice_checkbox')
self.debug_libimobiledevice_checkbox.setToolTip(
'Print libiMobileDevice diagnostic messages to console')
self.cfg_debug_options_qvl.addWidget(
self.debug_libimobiledevice_checkbox)
self.spacerItem2 = QSpacerItem(20, 20, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.column2_layout.addItem(self.spacerItem2)
# ~~~~~~~~ End of construction zone ~~~~~~~~
self.resize(self.sizeHint())
# ~~~~~~~~ Populate/restore config options ~~~~~~~~
# Annotations comboBox
self.populate_annotations()
self.populate_collections()
self.populate_date_read()
self.populate_progress()
self.populate_read()
self.populate_reading_list()
self.populate_word_count()
"""
# Restore Dropbox settings, hook changes
dropbox_syncing = self.prefs.get('dropbox_syncing', False)
self.dropbox_syncing_checkbox.setChecked(dropbox_syncing)
self.set_dropbox_syncing(dropbox_syncing)
self.dropbox_syncing_checkbox.clicked.connect(partial(self.set_dropbox_syncing))
self.dropbox_location_lineedit.setText(self.prefs.get('dropbox_folder', ''))
"""
# Restore general settings
self.auto_refresh_checkbox.setChecked(
self.prefs.get('auto_refresh_at_startup', False))
self.reading_progress_checkbox.setChecked(
self.prefs.get('show_progress_as_percentage', False))
# Restore debug settings, hook changes
self.debug_plugin_checkbox.setChecked(
self.prefs.get('debug_plugin', False))
self.debug_plugin_checkbox.stateChanged.connect(
self.set_restart_required)
self.debug_libimobiledevice_checkbox.setChecked(
self.prefs.get('debug_libimobiledevice', False))
self.debug_libimobiledevice_checkbox.stateChanged.connect(
self.set_restart_required)
# Hook changes to Annotations comboBox
# self.annotations_field_comboBox.currentIndexChanged.connect(
# partial(self.save_combobox_setting, 'annotations_field_comboBox'))
self.connect(self.annotations_field_comboBox,
SIGNAL('currentIndexChanged(const QString &)'),
self.annotations_destination_changed)
# Launch the annotated_books_scanner
field = get_cc_mapping('annotations', 'field', None)
self.annotated_books_scanner = InventoryAnnotatedBooks(self.gui, field)
self.connect(self.annotated_books_scanner,
self.annotated_books_scanner.signal,
self.inventory_complete)
QTimer.singleShot(1, self.start_inventory)
def annotations_destination_changed(self, qs_new_destination_name):
'''
If the destination field changes, move all existing annotations from old to new
'''
self._log_location(str(qs_new_destination_name))
#self._log("self.eligible_annotations_fields: %s" % self.eligible_annotations_fields)
old_destination_field = get_cc_mapping('annotations', 'field', None)
old_destination_name = get_cc_mapping('annotations', 'combobox', None)
self._log("old_destination_field: %s" % old_destination_field)
self._log("old_destination_name: %s" % old_destination_name)
new_destination_name = unicode(qs_new_destination_name)
self._log("new_destination_name: %s" % new_destination_name)
if old_destination_name == new_destination_name:
self._log_location(
"old_destination_name = new_destination_name, no changes")
return
new_destination_field = self.eligible_annotations_fields[
new_destination_name]
if existing_annotations(self.parent, old_destination_field):
command = self.launch_new_destination_dialog(
old_destination_name, new_destination_name)
if command == 'move':
set_cc_mapping('annotations',
field=new_destination_field,
combobox=new_destination_name)
if self.annotated_books_scanner.isRunning():
self.annotated_books_scanner.wait()
move_annotations(self,
self.annotated_books_scanner.annotation_map,
old_destination_field, new_destination_field)
elif command == 'change':
# Keep the updated destination field, but don't move annotations
pass
elif command == 'cancel':
# Restore previous destination
self.annotations_field_comboBox.blockSignals(True)
old_index = self.annotations_field_comboBox.findText(
old_destination_name)
self.annotations_field_comboBox.setCurrentIndex(old_index)
self.annotations_field_comboBox.blockSignals(False)
else:
# No existing annotations, just update prefs
self._log("no existing annotations, updating destination to '{0}'".
format(new_destination_name))
set_cc_mapping('annotations',
field=new_destination_field,
combobox=new_destination_name)
def configure_appearance(self):
'''
'''
self._log_location()
appearance_settings = {
'appearance_css': default_elements,
'appearance_hr_checkbox': False,
'appearance_timestamp_format': default_timestamp
}
# Save, hash the original settings
original_settings = {}
osh = hashlib.md5()
for setting in appearance_settings:
original_settings[setting] = plugin_prefs.get(
setting, appearance_settings[setting])
osh.update(
repr(plugin_prefs.get(setting, appearance_settings[setting])))
# Display the Annotations appearance dialog
aa = AnnotationsAppearance(self, self.annotations_icon, plugin_prefs)
cancelled = False
if aa.exec_():
# appearance_hr_checkbox and appearance_timestamp_format changed live to prefs during previews
plugin_prefs.set('appearance_css', aa.elements_table.get_data())
# Generate a new hash
nsh = hashlib.md5()
for setting in appearance_settings:
nsh.update(
repr(
plugin_prefs.get(setting,
appearance_settings[setting])))
else:
for setting in appearance_settings:
plugin_prefs.set(setting, original_settings[setting])
nsh = osh
# If there were changes, and there are existing annotations,
# and there is an active Annotations field, offer to re-render
field = get_cc_mapping('annotations', 'field', None)
if osh.digest() != nsh.digest() and existing_annotations(
self.parent, field):
title = 'Update annotations?'
msg = '<p>Update existing annotations to new appearance settings?</p>'
d = MessageBox(MessageBox.QUESTION,
title,
msg,
show_copy_button=False)
self._log_location("QUESTION: %s" % msg)
if d.exec_():
self._log_location(
"Updating existing annotations to modified appearance")
# Wait for indexing to complete
while not self.annotated_books_scanner.isFinished():
Application.processEvents()
move_annotations(self,
self.annotated_books_scanner.annotation_map,
field,
field,
window_title="Updating appearance")
def edit_css(self):
'''
'''
self._log_location()
from calibre_plugins.marvin_manager.book_status import dialog_resources_path
klass = os.path.join(dialog_resources_path, 'css_editor.py')
if os.path.exists(klass):
sys.path.insert(0, dialog_resources_path)
this_dc = importlib.import_module('css_editor')
sys.path.remove(dialog_resources_path)
dlg = this_dc.CSSEditorDialog(self, 'css_editor')
dlg.initialize(self)
dlg.exec_()
def get_eligible_custom_fields(self, eligible_types=[], is_multiple=None):
'''
Discover qualifying custom fields for eligible_types[]
'''
#self._log_location(eligible_types)
eligible_custom_fields = {}
for cf in self.gui.current_db.custom_field_keys():
cft = self.gui.current_db.metadata_for_field(cf)['datatype']
cfn = self.gui.current_db.metadata_for_field(cf)['name']
cfim = self.gui.current_db.metadata_for_field(cf)['is_multiple']
#self._log("cf: %s cft: %s cfn: %s cfim: %s" % (cf, cft, cfn, cfim))
if cft in eligible_types:
if is_multiple is not None:
if bool(cfim) == is_multiple:
eligible_custom_fields[cfn] = cf
else:
eligible_custom_fields[cfn] = cf
return eligible_custom_fields
def inventory_complete(self, msg):
self._log_location(msg)
def launch_cc_wizard(self, column_type):
'''
'''
def _update_combo_box(comboBox, destination, previous):
'''
'''
cb = getattr(self, comboBox)
cb.blockSignals(True)
all_items = [str(cb.itemText(i)) for i in range(cb.count())]
if previous and previous in all_items:
all_items.remove(previous)
all_items.append(destination)
cb.clear()
cb.addItems(sorted(all_items, key=lambda s: s.lower()))
# Select the new destination in the comboBox
idx = cb.findText(destination)
if idx > -1:
cb.setCurrentIndex(idx)
cb.blockSignals(False)
from calibre_plugins.marvin_manager.book_status import dialog_resources_path
klass = os.path.join(dialog_resources_path, 'cc_wizard.py')
if os.path.exists(klass):
#self._log("importing CC Wizard dialog from '%s'" % klass)
sys.path.insert(0, dialog_resources_path)
this_dc = importlib.import_module('cc_wizard')
sys.path.remove(dialog_resources_path)
dlg = this_dc.CustomColumnWizard(self,
column_type,
self.WIZARD_PROFILES[column_type],
verbose=True)
dlg.exec_()
if dlg.modified_column:
self._log("modified_column: %s" % dlg.modified_column)
self.restart_required = True
destination = dlg.modified_column['destination']
label = dlg.modified_column['label']
previous = dlg.modified_column['previous']
source = dlg.modified_column['source']
if source == "Annotations":
_update_combo_box("annotations_field_comboBox",
destination, previous)
# Add/update the new destination so save_settings() can find it
self.eligible_annotations_fields[destination] = label
# Save manually in case user cancels
set_cc_mapping('annotations',
combobox=destination,
field=label)
elif source == 'Collections':
_update_combo_box("collection_field_comboBox", destination,
previous)
# Add/update the new destination so save_settings() can find it
self.eligible_collection_fields[destination] = label
# Save manually in case user cancels
set_cc_mapping('collections',
combobox=destination,
field=label)
elif source == 'Last read':
_update_combo_box("date_read_field_comboBox", destination,
previous)
# Add/update the new destination so save_settings() can find it
self.eligible_date_read_fields[destination] = label
# Save manually in case user cancels
set_cc_mapping('date_read',
combobox=destination,
field=label)
elif source == "Progress":
_update_combo_box("progress_field_comboBox", destination,
previous)
# Add/update the new destination so save_settings() can find it
self.eligible_progress_fields[destination] = label
# Save manually in case user cancels
set_cc_mapping('progress',
combobox=destination,
field=label)
elif source == "Read":
_update_combo_box("read_field_comboBox", destination,
previous)
# Add/update the new destination so save_settings() can find it
self.eligible_read_fields[destination] = label
# Save manually in case user cancels
set_cc_mapping('read', combobox=destination, field=label)
elif source == "Reading list":
_update_combo_box("reading_list_field_comboBox",
destination, previous)
# Add/update the new destination so save_settings() can find it
self.eligible_reading_list_fields[destination] = label
# Save manually in case user cancels
set_cc_mapping('reading_list',
combobox=destination,
field=label)
elif source == "Word count":
_update_combo_box("word_count_field_comboBox", destination,
previous)
# Add/update the new destination so save_settings() can find it
self.eligible_word_count_fields[destination] = label
# Save manually in case user cancels
set_cc_mapping('word_count',
combobox=destination,
field=label)
else:
self._log("ERROR: Can't import from '%s'" % klass)
def launch_new_destination_dialog(self, old, new):
'''
Return 'move', 'change' or 'cancel'
'''
from calibre_plugins.marvin_manager.book_status import dialog_resources_path
self._log_location()
klass = os.path.join(dialog_resources_path, 'new_destination.py')
if os.path.exists(klass):
self._log("importing new destination dialog from '%s'" % klass)
sys.path.insert(0, dialog_resources_path)
this_dc = importlib.import_module('new_destination')
sys.path.remove(dialog_resources_path)
dlg = this_dc.NewDestinationDialog(self, old, new)
dlg.exec_()
return dlg.command
def populate_annotations(self):
datatype = self.WIZARD_PROFILES['Annotations']['datatype']
self.eligible_annotations_fields = self.get_eligible_custom_fields(
[datatype])
self.annotations_field_comboBox.addItems([''])
ecf = sorted(self.eligible_annotations_fields.keys(),
key=lambda s: s.lower())
self.annotations_field_comboBox.addItems(ecf)
# Retrieve stored value
existing = get_cc_mapping('annotations', 'combobox')
if existing:
ci = self.annotations_field_comboBox.findText(existing)
self.annotations_field_comboBox.setCurrentIndex(ci)
def populate_collections(self):
datatype = self.WIZARD_PROFILES['Collections']['datatype']
self.eligible_collection_fields = self.get_eligible_custom_fields(
[datatype], is_multiple=True)
self.collection_field_comboBox.addItems([''])
ecf = sorted(self.eligible_collection_fields.keys(),
key=lambda s: s.lower())
self.collection_field_comboBox.addItems(ecf)
# Retrieve stored value
existing = get_cc_mapping('collections', 'combobox')
if existing:
ci = self.collection_field_comboBox.findText(existing)
self.collection_field_comboBox.setCurrentIndex(ci)
def populate_date_read(self):
#self.eligible_date_read_fields = self.get_eligible_custom_fields(['datetime'])
datatype = self.WIZARD_PROFILES['Last read']['datatype']
self.eligible_date_read_fields = self.get_eligible_custom_fields(
[datatype])
self.date_read_field_comboBox.addItems([''])
ecf = sorted(self.eligible_date_read_fields.keys(),
key=lambda s: s.lower())
self.date_read_field_comboBox.addItems(ecf)
# Retrieve stored value
existing = get_cc_mapping('date_read', 'combobox')
if existing:
ci = self.date_read_field_comboBox.findText(existing)
self.date_read_field_comboBox.setCurrentIndex(ci)
def populate_progress(self):
#self.eligible_progress_fields = self.get_eligible_custom_fields(['float'])
datatype = self.WIZARD_PROFILES['Progress']['datatype']
self.eligible_progress_fields = self.get_eligible_custom_fields(
[datatype])
self.progress_field_comboBox.addItems([''])
ecf = sorted(self.eligible_progress_fields.keys(),
key=lambda s: s.lower())
self.progress_field_comboBox.addItems(ecf)
# Retrieve stored value
existing = get_cc_mapping('progress', 'combobox')
if existing:
ci = self.progress_field_comboBox.findText(existing)
self.progress_field_comboBox.setCurrentIndex(ci)
def populate_read(self):
datatype = self.WIZARD_PROFILES['Read']['datatype']
self.eligible_read_fields = self.get_eligible_custom_fields([datatype])
self.read_field_comboBox.addItems([''])
ecf = sorted(self.eligible_read_fields.keys(), key=lambda s: s.lower())
self.read_field_comboBox.addItems(ecf)
# Retrieve stored value
existing = get_cc_mapping('read', 'combobox')
if existing:
ci = self.read_field_comboBox.findText(existing)
self.read_field_comboBox.setCurrentIndex(ci)
def populate_reading_list(self):
datatype = self.WIZARD_PROFILES['Reading list']['datatype']
self.eligible_reading_list_fields = self.get_eligible_custom_fields(
[datatype])
self.reading_list_field_comboBox.addItems([''])
ecf = sorted(self.eligible_reading_list_fields.keys(),
key=lambda s: s.lower())
self.reading_list_field_comboBox.addItems(ecf)
# Retrieve stored value
existing = get_cc_mapping('reading_list', 'combobox')
if existing:
ci = self.reading_list_field_comboBox.findText(existing)
self.reading_list_field_comboBox.setCurrentIndex(ci)
def populate_word_count(self):
#self.eligible_word_count_fields = self.get_eligible_custom_fields(['int'])
datatype = self.WIZARD_PROFILES['Word count']['datatype']
self.eligible_word_count_fields = self.get_eligible_custom_fields(
[datatype])
self.word_count_field_comboBox.addItems([''])
ecf = sorted(self.eligible_word_count_fields.keys(),
key=lambda s: s.lower())
self.word_count_field_comboBox.addItems(ecf)
# Retrieve stored value
existing = get_cc_mapping('word_count', 'combobox')
if existing:
ci = self.word_count_field_comboBox.findText(existing)
self.word_count_field_comboBox.setCurrentIndex(ci)
"""
def select_dropbox_folder(self):
'''
'''
self._log_location()
dropbox_location = QFileDialog.getExistingDirectory(
self,
"Dropbox folder",
os.path.expanduser("~"),
QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks)
self.dropbox_location_lineedit.setText(unicode(dropbox_location))
def set_dropbox_syncing(self, state):
'''
Called when checkbox changes state, or when restoring state
Set enabled state of Dropbox folder picker to match
'''
self.cfg_dropbox_folder_toolbutton.setEnabled(state)
self.dropbox_location_lineedit.setEnabled(state)
"""
def set_restart_required(self, state):
'''
Set restart_required flag to show show dialog when closing dialog
'''
self.restart_required = True
"""
def save_combobox_setting(self, cb, index):
'''
Apply changes immediately
'''
cf = str(getattr(self, cb).currentText())
self._log_location("%s => %s" % (cb, repr(cf)))
if cb == 'annotations_field_comboBox':
field = None
if cf:
field = self.eligible_annotations_fields[cf]
set_cc_mapping('annotations', combobox=cf, field=field)
"""
def save_settings(self):
self._log_location()
# Annotations
cf = unicode(self.annotations_field_comboBox.currentText())
field = None
if cf:
field = self.eligible_annotations_fields[cf]
set_cc_mapping('annotations', combobox=cf, field=field)
# Collections
cf = unicode(self.collection_field_comboBox.currentText())
field = None
if cf:
field = self.eligible_collection_fields[cf]
set_cc_mapping('collections', combobox=cf, field=field)
# Save Date read field
cf = unicode(self.date_read_field_comboBox.currentText())
field = None
if cf:
field = self.eligible_date_read_fields[cf]
set_cc_mapping('date_read', combobox=cf, field=field)
# Save Progress field
cf = unicode(self.progress_field_comboBox.currentText())
field = None
if cf:
field = self.eligible_progress_fields[cf]
set_cc_mapping('progress', combobox=cf, field=field)
# Save Read field
cf = unicode(self.read_field_comboBox.currentText())
field = None
if cf:
field = self.eligible_read_fields[cf]
set_cc_mapping('read', combobox=cf, field=field)
# Save Reading list field
cf = unicode(self.reading_list_field_comboBox.currentText())
field = None
if cf:
field = self.eligible_reading_list_fields[cf]
set_cc_mapping('reading_list', combobox=cf, field=field)
# Save Word count field
cf = unicode(self.word_count_field_comboBox.currentText())
field = None
if cf:
field = self.eligible_word_count_fields[cf]
set_cc_mapping('word_count', combobox=cf, field=field)
'''
# Save Dropbox settings
self.prefs.set('dropbox_syncing', self.dropbox_syncing_checkbox.isChecked())
self.prefs.set('dropbox_folder', unicode(self.dropbox_location_lineedit.text()))
'''
# Save general settings
self.prefs.set('auto_refresh_at_startup',
self.auto_refresh_checkbox.isChecked())
self.prefs.set('show_progress_as_percentage',
self.reading_progress_checkbox.isChecked())
# Save debug settings
self.prefs.set('debug_plugin', self.debug_plugin_checkbox.isChecked())
self.prefs.set('debug_libimobiledevice',
self.debug_libimobiledevice_checkbox.isChecked())
# If restart needed, inform user
if self.restart_required:
do_restart = show_restart_warning(
'Restart calibre for the changes to be applied.',
parent=self.gui)
if do_restart:
self.gui.quit(restart=True)
def start_inventory(self):
self._log_location()
self.annotated_books_scanner.start()
class RuleEditor(QDialog): # {{{
def __init__(self, fm, pref_name, parent=None):
QDialog.__init__(self, parent)
self.fm = fm
if pref_name == 'column_color_rules':
self.rule_kind = 'color'
rule_text = _('coloring')
else:
self.rule_kind = 'icon'
rule_text = _('icon')
self.setWindowIcon(QIcon(I('format-fill-color.png')))
self.setWindowTitle(
_('Create/edit a column {0} rule').format(rule_text))
self.l = l = QGridLayout(self)
self.setLayout(l)
self.l1 = l1 = QLabel(
_('Create a column {0} rule by'
' filling in the boxes below'.format(rule_text)))
l.addWidget(l1, 0, 0, 1, 8)
self.f1 = QFrame(self)
self.f1.setFrameShape(QFrame.HLine)
l.addWidget(self.f1, 1, 0, 1, 8)
self.l2 = l2 = QLabel(_('Set the'))
l.addWidget(l2, 2, 0)
if self.rule_kind == 'color':
l.addWidget(QLabel(_('color')))
else:
self.kind_box = QComboBox(self)
for tt, t in icon_rule_kinds:
self.kind_box.addItem(tt, t)
l.addWidget(self.kind_box, 2, 1)
self.l3 = l3 = QLabel(_('of the column:'))
l.addWidget(l3, 2, 2)
self.column_box = QComboBox(self)
l.addWidget(self.column_box, 2, 3)
self.l4 = l4 = QLabel(_('to'))
l.addWidget(l4, 2, 4)
if self.rule_kind == 'color':
self.color_box = QComboBox(self)
self.color_label = QLabel('Sample text Sample text')
self.color_label.setTextFormat(Qt.RichText)
l.addWidget(self.color_box, 2, 5)
l.addWidget(self.color_label, 2, 6)
l.addItem(QSpacerItem(10, 10, QSizePolicy.Expanding), 2, 7)
else:
self.filename_box = QComboBox()
self.filename_box.setInsertPolicy(
self.filename_box.InsertAlphabetically)
d = os.path.join(config_dir, 'cc_icons')
self.icon_file_names = []
if os.path.exists(d):
for icon_file in os.listdir(d):
icon_file = lower(icon_file)
if os.path.exists(os.path.join(d, icon_file)):
if icon_file.endswith('.png'):
self.icon_file_names.append(icon_file)
self.icon_file_names.sort(key=sort_key)
self.update_filename_box()
l.addWidget(self.filename_box, 2, 5)
self.filename_button = QPushButton(QIcon(I('document_open.png')),
_('&Add icon'))
l.addWidget(self.filename_button, 2, 6)
l.addWidget(QLabel(_('Icons should be square or landscape')), 2, 7)
l.setColumnStretch(7, 10)
self.l5 = l5 = QLabel(
_('Only if the following conditions are all satisfied:'))
l.addWidget(l5, 3, 0, 1, 7)
self.scroll_area = sa = QScrollArea(self)
sa.setMinimumHeight(300)
sa.setMinimumWidth(950)
sa.setWidgetResizable(True)
l.addWidget(sa, 4, 0, 1, 8)
self.add_button = b = QPushButton(QIcon(I('plus.png')),
_('Add another condition'))
l.addWidget(b, 5, 0, 1, 8)
b.clicked.connect(self.add_blank_condition)
self.l6 = l6 = QLabel(
_('You can disable a condition by'
' blanking all of its boxes'))
l.addWidget(l6, 6, 0, 1, 8)
self.bb = bb = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
l.addWidget(bb, 7, 0, 1, 8)
self.conditions_widget = QWidget(self)
sa.setWidget(self.conditions_widget)
self.conditions_widget.setLayout(QVBoxLayout())
self.conditions_widget.layout().setAlignment(Qt.AlignTop)
self.conditions = []
if self.rule_kind == 'color':
for b in (self.column_box, self.color_box):
b.setSizeAdjustPolicy(b.AdjustToMinimumContentsLengthWithIcon)
b.setMinimumContentsLength(15)
for key in sorted(displayable_columns(fm),
key=lambda (k): sort_key(fm[k]['name'])
if k != color_row_key else 0):
if key == color_row_key and self.rule_kind != 'color':
continue
name = all_columns_string if key == color_row_key else fm[key][
'name']
if name:
self.column_box.addItem(name, key)
self.column_box.setCurrentIndex(0)
if self.rule_kind == 'color':
self.color_box.addItems(QColor.colorNames())
self.color_box.setCurrentIndex(0)
self.update_color_label()
self.color_box.currentIndexChanged.connect(self.update_color_label)
else:
self.filename_button.clicked.connect(self.filename_button_clicked)
self.resize(self.sizeHint())
def update_filename_box(self):
self.filename_box.clear()
self.icon_file_names.sort(key=sort_key)
self.filename_box.addItem('')
self.filename_box.addItems(self.icon_file_names)
for i, filename in enumerate(self.icon_file_names):
icon = QIcon(os.path.join(config_dir, 'cc_icons', filename))
self.filename_box.setItemIcon(i + 1, icon)
def update_color_label(self):
pal = QApplication.palette()
bg1 = unicode(pal.color(pal.Base).name())
bg2 = unicode(pal.color(pal.AlternateBase).name())
c = unicode(self.color_box.currentText())
self.color_label.setText('''
<span style="color: {c}; background-color: {bg1}"> {st} </span>
<span style="color: {c}; background-color: {bg2}"> {st} </span>
'''.format(c=c, bg1=bg1, bg2=bg2, st=_('Sample Text')))
def filename_button_clicked(self):
try:
path = choose_files(self,
'choose_category_icon',
_('Select Icon'),
filters=[('Images',
['png', 'gif', 'jpg', 'jpeg'])],
all_files=False,
select_only_single_file=True)
if path:
icon_path = path[0]
icon_name = sanitize_file_name_unicode(
os.path.splitext(os.path.basename(icon_path))[0] + '.png')
if icon_name not in self.icon_file_names:
self.icon_file_names.append(icon_name)
self.update_filename_box()
try:
p = QIcon(icon_path).pixmap(QSize(128, 128))
d = os.path.join(config_dir, 'cc_icons')
if not os.path.exists(os.path.join(d, icon_name)):
if not os.path.exists(d):
os.makedirs(d)
with open(os.path.join(d, icon_name), 'wb') as f:
f.write(pixmap_to_data(p, format='PNG'))
except:
import traceback
traceback.print_exc()
self.filename_box.setCurrentIndex(
self.filename_box.findText(icon_name))
self.filename_box.adjustSize()
except:
import traceback
traceback.print_exc()
return
def add_blank_condition(self):
c = ConditionEditor(self.fm, parent=self.conditions_widget)
self.conditions.append(c)
self.conditions_widget.layout().addWidget(c)
def apply_rule(self, kind, col, rule):
if kind == 'color':
if rule.color:
idx = self.color_box.findText(rule.color)
if idx >= 0:
self.color_box.setCurrentIndex(idx)
else:
self.kind_box.setCurrentIndex(0 if kind == 'icon' else 1)
if rule.color:
idx = self.filename_box.findText(rule.color)
if idx >= 0:
self.filename_box.setCurrentIndex(idx)
else:
self.filename_box.setCurrentIndex(0)
for i in range(self.column_box.count()):
c = unicode(self.column_box.itemData(i).toString())
if col == c:
self.column_box.setCurrentIndex(i)
break
for c in rule.conditions:
ce = ConditionEditor(self.fm, parent=self.conditions_widget)
self.conditions.append(ce)
self.conditions_widget.layout().addWidget(ce)
try:
ce.condition = c
except:
import traceback
traceback.print_exc()
def accept(self):
if self.rule_kind != 'color':
fname = lower(unicode(self.filename_box.currentText()))
if not fname:
error_dialog(self,
_('No icon selected'),
_('You must choose an icon for this rule'),
show=True)
return
if self.validate():
QDialog.accept(self)
def validate(self):
r = Rule(self.fm)
for c in self.conditions:
condition = c.condition
if condition is not None:
try:
r.add_condition(*condition)
except Exception as e:
import traceback
error_dialog(self,
_('Invalid condition'),
_('One of the conditions for this rule is'
' invalid: <b>%s</b>') % e,
det_msg=traceback.format_exc(),
show=True)
return False
if len(r.conditions) < 1:
error_dialog(self,
_('No conditions'),
_('You must specify at least one non-empty condition'
' for this rule'),
show=True)
return False
return True
@property
def rule(self):
r = Rule(self.fm)
if self.rule_kind != 'color':
r.color = unicode(self.filename_box.currentText())
else:
r.color = unicode(self.color_box.currentText())
idx = self.column_box.currentIndex()
col = unicode(self.column_box.itemData(idx).toString())
for c in self.conditions:
condition = c.condition
if condition is not None:
r.add_condition(*condition)
if self.rule_kind == 'icon':
kind = unicode(
self.kind_box.itemData(
self.kind_box.currentIndex()).toString())
else:
kind = 'color'
return kind, col, r
class SourceSelectorDialog(QDialog):
def __init__(self, parent, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent, flags)
self.setModal(False)
self.setWindowTitle("Select sources by...")
lo = QVBoxLayout(self)
lo.setMargin(10)
lo.setSpacing(5)
# select by
lo1 = QHBoxLayout()
lo.addLayout(lo1)
lo1.setContentsMargins(0, 0, 0, 0)
# lab = QLabel("Select:")
# lo1.addWidget(lab)
self.wselby = QComboBox(self)
lo1.addWidget(self.wselby, 0)
QObject.connect(self.wselby, SIGNAL("activated(const QString &)"),
self._setup_selection_by)
# under/over
self.wgele = QComboBox(self)
lo1.addWidget(self.wgele, 0)
self.wgele.addItems([">", ">=", "<=", "<", "sum<=", "sum>"])
QObject.connect(self.wgele, SIGNAL("activated(const QString &)"),
self._select_threshold)
# threshold value
self.wthreshold = QLineEdit(self)
QObject.connect(self.wthreshold, SIGNAL("editingFinished()"),
self._select_threshold)
lo1.addWidget(self.wthreshold, 1)
# min and max label
self.wminmax = QLabel(self)
lo.addWidget(self.wminmax)
# selection slider
lo1 = QHBoxLayout()
lo.addLayout(lo1)
self.wpercent = QSlider(self)
self.wpercent.setTracking(False)
QObject.connect(self.wpercent, SIGNAL("valueChanged(int)"),
self._select_percentile)
QObject.connect(self.wpercent, SIGNAL("sliderMoved(int)"),
self._select_percentile_threshold)
self.wpercent.setRange(0, 100)
self.wpercent.setOrientation(Qt.Horizontal)
lo1.addWidget(self.wpercent)
self.wpercent_lbl = QLabel("0%", self)
self.wpercent_lbl.setMinimumWidth(64)
lo1.addWidget(self.wpercent_lbl)
# # hide button
# lo.addSpacing(10)
# lo2 = QHBoxLayout()
# lo.addLayout(lo2)
# lo2.setContentsMargins(0,0,0,0)
# hidebtn = QPushButton("Close",self)
# hidebtn.setMinimumWidth(128)
# QObject.connect(hidebtn,SIGNAL("clicked()"),self.hide)
# lo2.addStretch(1)
# lo2.addWidget(hidebtn)
# lo2.addStretch(1)
# self.setMinimumWidth(384)
self._in_select_threshold = False
self._sort_index = None
self.qerrmsg = QErrorMessage(self)
def resetModel(self):
"""Resets dialog based on current model."""
if not self.model:
return
# getset of model tags, and remove the non-sorting tags
alltags = set(self.model.tagnames)
alltags -= NonSortingTags
# make list of tags from StandardTags that are present in model
self.sorttags = [
tag for tag in StandardTags
if tag in alltags or tag in TagAccessors
]
# append model tags that were not in StandardTags
self.sorttags += list(alltags - set(self.sorttags))
# set selector
self.wselby.clear()
self.wselby.addItems(self.sorttags)
for tag in "Iapp", "I":
if tag in self.sorttags:
self.wselby.setCurrentIndex(self.sorttags.index(tag))
break
self._setup_selection_by(self.wselby.currentText())
def _reset_percentile(self):
self.wthreshold.setText("")
self.wpercent.setValue(50)
self.wpercent_lbl.setText("--%")
def _setup_selection_by(self, tag):
tag = str(tag)
# may be QString
# clear threshold value and percentiles
self._reset_percentile()
# get min/max values, and sort indices
# _sort_index will be an array of (value,src,cumsum) tuples, sorted by tag value (high to low),
# where src is the source, and cumsum is the sum of all values in the list from 0 up to and including the current one
self._sort_index = []
minval = maxval = None
for isrc, src in enumerate(self.model.sources):
try:
if hasattr(src, tag):
value = float(getattr(src, tag))
else:
value = float(TagAccessors[tag](src))
# skip source if failed to access this tag as a float
except:
traceback.print_exc()
continue
self._sort_index.append([value, src, 0])
minval = min(minval, value) if minval is not None else value
maxval = max(maxval, value) if maxval is not None else value
# add label
if minval is None:
self._range = None
self.wminmax.setText(
"<font color=red>'%s' is not a numeric attribute</font>" % tag)
for w in self.wgele, self.wthreshold, self.wpercent, self.wpercent_lbl:
w.setEnabled(False)
else:
self._range = (minval, maxval)
self.wminmax.setText("min: %g max: %g" % self._range)
for w in self.wgele, self.wthreshold, self.wpercent, self.wpercent_lbl:
w.setEnabled(True)
# sort index by descending values
self._sort_index.sort(reverse=True)
# generate cumulative sums
cumsum = 0.
for entry in self._sort_index:
cumsum += entry[0]
entry[2] = cumsum
# Maps comparison operators to callables. Used in _select_threshold.
# Each callable takes two arguments: e is a tuple of (value,src,cumsum) (see _sort_index above), and x is a threshold
# Second argument is a flag: if False, selection is inverted w.r.t. operator
Operators = {
"<": ((lambda e, x: e[0] >= x), False),
"<=": ((lambda e, x: e[0] > x), False),
">": ((lambda e, x: e[0] > x), True),
">=": ((lambda e, x: e[0] >= x), True),
"sum<=": ((lambda e, x: e[2] <= x), True),
"sum>": ((lambda e, x: e[2] <= x), False)
}
def _select_threshold(self, *dum):
dprint(1, "select_threshold", dum)
self._in_select_threshold = True
busy = BusyIndicator()
try:
# get threshold, ignore if not set
threshold = str(self.wthreshold.text())
if not threshold:
self._reset_percentile()
return
# try to parse threshold, ignore if invalid
try:
threshold = float(threshold)
except:
self._reset_percentile()
return
# get comparison operator
op, select = self.Operators[str(self.wgele.currentText())]
# apply to initial segment (that matches operator)
for num, entry in enumerate(self._sort_index):
if not op(entry, threshold):
break
entry[1].selected = select
else:
num = len(self._sort_index)
# apply to remaining segment
for val, src, cumsum in self._sort_index[num:]:
src.selected = not select
# set percentile
percent = round(float(num * 100) / len(self._sort_index))
if not select:
percent = 100 - percent
self.wpercent.setValue(percent)
self.wpercent_lbl.setText("%3d%%" % percent)
# emit signal
self.model.emitSelection(self)
finally:
self._in_select_threshold = False
busy = None
def _select_percentile(self, percent):
self._select_percentile_threshold(percent, do_select=True)
def _select_percentile_threshold(self, percent, do_select=False):
# ignore if no sort index set up, or if _select_threshold() is being called
if self._sort_index is None or self._in_select_threshold:
return
dprint(1, "select_precentile_threshold", percent)
busy = BusyIndicator()
# number of objects to select
nsrc = len(self._sort_index)
nsel = int(math.ceil(nsrc * float(percent) / 100))
# get comparison operator
opstr = str(self.wgele.currentText())
op, select = self.Operators[opstr]
# select head or tail of list, depending on direction of operator
if select:
thr = self._sort_index[min(nsel, nsrc - 1)]
slc1 = slice(0, nsel)
slc2 = slice(nsel, None)
else:
thr = self._sort_index[-min(nsel + 1, nsrc)]
slc1 = slice(nsrc - nsel, None)
slc2 = slice(0, nsrc - nsel)
if do_select:
for val, src, cumsum in self._sort_index[slc1]:
src.selected = True
for val, src, cumsum in self._sort_index[slc2]:
src.selected = False
self.model.emitSelection(self)
self.wpercent_lbl.setText("%3d%%" % percent)
self.wthreshold.setText(
"%g" % (thr[2] if opstr.startswith("sum") else thr[0]))
return nsel
def setModel(self, model):
"""Sets the current model. If dialog is visible, applies the changes"""
self.model = model
if self.isVisible():
self.resetModel()
if not model:
self.hide()
def show(self):
"""Shows dialog, resetting the model if it was invisible."""
if not self.isVisible():
self.resetModel()
QDialog.show(self)
def _updateModel(self, what=SkyModel.UpdateAll, origin=None):
if origin is self or not what & (SkyModel.UpdateTags
| SkyModel.UpdateGroupStyle):
return
model = self.model
self._setting_model = True
# to ignore cellChanged() signals (in valueChanged())
# _item_cb is a dict (with row,col keys) containing the widgets (CheckBoxes ComboBoxes) per each cell
self._item_cb = {}
# lists of "list" and "plot" checkboxes per each grouping (excepting the default grouping); each entry is an (row,col,item) tuple.
# used as argument to self._showControls()
self._list_controls = []
self._plot_controls = []
# list of selection callbacks (to which signals are connected)
self._callbacks = []
# set requisite number of rows,and start filling
self.table.setRowCount(len(model.groupings))
for irow, group in enumerate(model.groupings):
self.table.setItem(irow, 0, QTableWidgetItem(group.name))
if group is model.selgroup:
self._irow_selgroup = irow
# total # source in group: skip for "current"
if group is not model.curgroup:
self.table.setItem(irow, 1, QTableWidgetItem(str(group.total)))
# selection controls: skip for current and selection
if group not in (model.curgroup, model.selgroup):
btns = QWidget()
lo = QHBoxLayout(btns)
lo.setContentsMargins(0, 0, 0, 0)
lo.setSpacing(0)
# make selector buttons (depending on which group we're in)
if group is model.defgroup:
Buttons = (("+", lambda src, grp=group: True,
"select all sources"),
("-", lambda src, grp=group: False,
"unselect all sources"))
else:
Buttons = (
("=", lambda src, grp=group: grp.func(src),
"select only this grouping"),
("+",
lambda src, grp=group: src.selected or grp.func(src),
"add grouping to selection"),
("-", lambda src, grp=group: src.selected and not grp.
func(src), "remove grouping from selection"),
("&&",
lambda src, grp=group: src.selected and grp.func(src),
"intersect selection with grouping"))
lo.addStretch(1)
for label, predicate, tooltip in Buttons:
btn = QToolButton(btns)
btn.setText(label)
btn.setMinimumWidth(24)
btn.setMaximumWidth(24)
btn.setToolTip(tooltip)
lo.addWidget(btn)
# add callback
QObject.connect(
btn, SIGNAL("clicked()"),
self._currier.curry(self.selectSources, predicate))
lo.addStretch(1)
self.table.setCellWidget(irow, 2, btns)
# "list" checkbox (not for current and selected groupings: these are always listed)
if group not in (model.curgroup, model.selgroup):
item = self._makeCheckItem("", group, "show_list")
self.table.setItem(irow, self.ColList, item)
item.setToolTip(
"""<P>If checked, sources in this grouping will be listed in the source table. If un-checked, sources will be
excluded from the table. If partially checked, then the default list/no list setting of "all sources" will be in effect.
</P>""")
# "plot" checkbox (not for the current grouping, since that's always plotted)
if group is not model.curgroup:
item = self._makeCheckItem("", group, "show_plot")
self.table.setItem(irow, self.ColPlot, item)
item.setToolTip(
"""<P>If checked, sources in this grouping will be included in the plot. If un-checked, sources will be
excluded from the plot. If partially checked, then the default plot/no plot setting of "all sources" will be in effect.
</P>""")
# custom style control
# for default, current and selected, this is just a text label
if group is model.defgroup:
item = QTableWidgetItem("default:")
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setToolTip(
"""<P>This is the default plot style used for all sources for which a custom grouping style is not selected.</P>"""
)
self.table.setItem(irow, self.ColApply, item)
elif group is model.curgroup:
item = QTableWidgetItem("")
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setToolTip(
"""<P>This is the plot style used for the highlighted source, if any.</P>"""
)
self.table.setItem(irow, self.ColApply, item)
elif group is model.selgroup:
item = QTableWidgetItem("")
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setToolTip(
"""<P>This is the plot style used for the currently selected sources.</P>"""
)
self.table.setItem(irow, self.ColApply, item)
# for the rest, a combobox with custom priorities
else:
cb = QComboBox()
cb.addItems(["default"] +
["custom %d" % p for p in range(1, 10)])
index = max(0, min(group.style.apply, 9))
# dprint(0,group.name,"apply",index)
cb.setCurrentIndex(index)
QObject.connect(
cb, SIGNAL("activated(int)"),
self._currier.xcurry(self._valueChanged,
(irow, self.ColApply)))
self.table.setCellWidget(irow, self.ColApply, cb)
cb.setToolTip(
"""<P>This controls whether sources within this group are plotted with a customized
plot style. Customized styles have numeric priority; if a source belongs to multiple groups, then
the style with the lowest priority takes precedence.<P>""")
# attribute comboboxes
for icol, attr in self.AttrByCol.items():
# get list of options for this style attribute. If dealing with first grouping (i==0), which is
# the "all sources" grouping, then remove the "default" option (which is always first in the list)
options = PlotStyles.StyleAttributeOptions[attr]
if irow == 0:
options = options[1:]
# make combobox
cb = QComboBox()
cb.addItems(list(map(str, options)))
# the "label" option is also editable
if attr == "label":
cb.setEditable(True)
try:
index = options.index(getattr(group.style, attr))
cb.setCurrentIndex(index)
except ValueError:
cb.setEditText(str(getattr(group.style, attr)))
slot = self._currier.xcurry(self._valueChanged, (irow, icol))
QObject.connect(cb, SIGNAL("activated(int)"), slot)
QObject.connect(cb, SIGNAL("editTextChanged(const QString &)"),
slot)
cb.setEnabled(group is model.defgroup or group.style.apply)
self.table.setCellWidget(irow, icol, cb)
label = attr
if irow:
cb.setToolTip(
"""<P>This is the %s used to plot sources in this group, when a "custom" style for the group
is enabled via the style control.<P>""" % label)
else:
cb.setToolTip(
"<P>This is the default %s used for all sources for which a custom style is not specified below.<P>"
% label)
self.table.resizeColumnsToContents()
# re-enable processing of cellChanged() signals
self._setting_model = False
class AddTagDialog(QDialog):
def __init__(self, parent, modal=True, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent, flags)
self.setModal(modal)
self.setWindowTitle("Add Tag")
lo = QVBoxLayout(self)
lo.setMargin(10)
lo.setSpacing(5)
# tag selector
lo1 = QHBoxLayout()
lo.addLayout(lo1)
lo1.setSpacing(5)
self.wtagsel = QComboBox(self)
self.wtagsel.setEditable(True)
wtagsel_lbl = QLabel("&Tag:", self)
wtagsel_lbl.setBuddy(self.wtagsel)
lo1.addWidget(wtagsel_lbl, 0)
lo1.addWidget(self.wtagsel, 1)
QObject.connect(self.wtagsel, SIGNAL("activated(int)"),
self._check_tag)
QObject.connect(self.wtagsel,
SIGNAL("editTextChanged(const QString &)"),
self._check_tag_text)
# value editor
self.valedit = ValueTypeEditor(self)
lo.addWidget(self.valedit)
# buttons
lo.addSpacing(10)
lo2 = QHBoxLayout()
lo.addLayout(lo2)
lo2.setContentsMargins(0, 0, 0, 0)
lo2.setMargin(5)
self.wokbtn = QPushButton("OK", self)
self.wokbtn.setMinimumWidth(128)
QObject.connect(self.wokbtn, SIGNAL("clicked()"), self.accept)
self.wokbtn.setEnabled(False)
cancelbtn = QPushButton("Cancel", self)
cancelbtn.setMinimumWidth(128)
QObject.connect(cancelbtn, SIGNAL("clicked()"), self.reject)
lo2.addWidget(self.wokbtn)
lo2.addStretch(1)
lo2.addWidget(cancelbtn)
self.setMinimumWidth(384)
def setTags(self, tagnames):
self.wtagsel.clear()
self.wtagsel.addItems(list(tagnames))
self.wtagsel.addItem("")
self.wtagsel.setCurrentIndex(len(tagnames))
def setValue(self, value):
self.valedit.setValue(value)
def _check_tag(self, tag):
self.wokbtn.setEnabled(True)
def _check_tag_text(self, text):
self.wokbtn.setEnabled(bool(str(text) != ""))
def accept(self):
"""When dialog is accepted with a default (bool) tag type,
check if the user hasn't entered a name=value entry in the tag name field.
This is a common mistake, and should be treated as a shortcut for setting string tags."""
if isinstance(self.valedit.getValue(), bool):
tagval = str(self.wtagsel.currentText()).split("=", 1)
if len(tagval) > 1:
# print tagval
if QMessageBox.warning(
self, "Set a string tag instead?",
"""<P>You have included an "=" sign in the tag name.
Perhaps you actually mean to set tag "%s" to the string value "%s"?</P>"""
% tuple(tagval), QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes) == QMessageBox.No:
return
self.wtagsel.setEditText(tagval[0])
self.valedit.setValue(tagval[1])
return QDialog.accept(self)
def getTag(self):
return str(self.wtagsel.currentText()), self.valedit.getValue()
class RuleEditor(QDialog): # {{{
def __init__(self, fm, parent=None):
QDialog.__init__(self, parent)
self.fm = fm
self.setWindowIcon(QIcon(I('format-fill-color.png')))
self.setWindowTitle(_('Create/edit a column coloring rule'))
self.l = l = QGridLayout(self)
self.setLayout(l)
self.l1 = l1 = QLabel(_('Create a coloring rule by'
' filling in the boxes below'))
l.addWidget(l1, 0, 0, 1, 5)
self.f1 = QFrame(self)
self.f1.setFrameShape(QFrame.HLine)
l.addWidget(self.f1, 1, 0, 1, 5)
self.l2 = l2 = QLabel(_('Set the color of the column:'))
l.addWidget(l2, 2, 0)
self.column_box = QComboBox(self)
l.addWidget(self.column_box, 2, 1)
self.l3 = l3 = QLabel(_('to'))
l.addWidget(l3, 2, 2)
self.color_box = QComboBox(self)
self.color_label = QLabel('Sample text Sample text')
self.color_label.setTextFormat(Qt.RichText)
l.addWidget(self.color_box, 2, 3)
l.addWidget(self.color_label, 2, 4)
l.addItem(QSpacerItem(10, 10, QSizePolicy.Expanding), 2, 5)
self.l4 = l4 = QLabel(
_('Only if the following conditions are all satisfied:'))
l.addWidget(l4, 3, 0, 1, 6)
self.scroll_area = sa = QScrollArea(self)
sa.setMinimumHeight(300)
sa.setMinimumWidth(950)
sa.setWidgetResizable(True)
l.addWidget(sa, 4, 0, 1, 6)
self.add_button = b = QPushButton(QIcon(I('plus.png')),
_('Add another condition'))
l.addWidget(b, 5, 0, 1, 6)
b.clicked.connect(self.add_blank_condition)
self.l5 = l5 = QLabel(_('You can disable a condition by'
' blanking all of its boxes'))
l.addWidget(l5, 6, 0, 1, 6)
self.bb = bb = QDialogButtonBox(
QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
l.addWidget(bb, 7, 0, 1, 6)
self.conditions_widget = QWidget(self)
sa.setWidget(self.conditions_widget)
self.conditions_widget.setLayout(QVBoxLayout())
self.conditions_widget.layout().setAlignment(Qt.AlignTop)
self.conditions = []
for b in (self.column_box, self.color_box):
b.setSizeAdjustPolicy(b.AdjustToMinimumContentsLengthWithIcon)
b.setMinimumContentsLength(15)
for key in sorted(
displayable_columns(fm),
key=sort_key):
name = fm[key]['name']
if name:
self.column_box.addItem(key, key)
self.column_box.setCurrentIndex(0)
self.color_box.addItems(QColor.colorNames())
self.color_box.setCurrentIndex(0)
self.update_color_label()
self.color_box.currentIndexChanged.connect(self.update_color_label)
self.resize(self.sizeHint())
def update_color_label(self):
pal = QApplication.palette()
bg1 = unicode(pal.color(pal.Base).name())
bg2 = unicode(pal.color(pal.AlternateBase).name())
c = unicode(self.color_box.currentText())
self.color_label.setText('''
<span style="color: {c}; background-color: {bg1}"> {st} </span>
<span style="color: {c}; background-color: {bg2}"> {st} </span>
'''.format(c=c, bg1=bg1, bg2=bg2, st=_('Sample Text')))
def add_blank_condition(self):
c = ConditionEditor(self.fm, parent=self.conditions_widget)
self.conditions.append(c)
self.conditions_widget.layout().addWidget(c)
def apply_rule(self, col, rule):
for i in range(self.column_box.count()):
c = unicode(self.column_box.itemData(i).toString())
if col == c:
self.column_box.setCurrentIndex(i)
break
if rule.color:
idx = self.color_box.findText(rule.color)
if idx >= 0:
self.color_box.setCurrentIndex(idx)
for c in rule.conditions:
ce = ConditionEditor(self.fm, parent=self.conditions_widget)
self.conditions.append(ce)
self.conditions_widget.layout().addWidget(ce)
try:
ce.condition = c
except:
import traceback
traceback.print_exc()
def accept(self):
if self.validate():
QDialog.accept(self)
def validate(self):
r = Rule(self.fm)
for c in self.conditions:
condition = c.condition
if condition is not None:
try:
r.add_condition(*condition)
except Exception as e:
import traceback
error_dialog(self, _('Invalid condition'),
_('One of the conditions for this rule is'
' invalid: <b>%s</b>')%e,
det_msg=traceback.format_exc(), show=True)
return False
if len(r.conditions) < 1:
error_dialog(self, _('No conditions'),
_('You must specify at least one non-empty condition'
' for this rule'), show=True)
return False
return True
@property
def rule(self):
r = Rule(self.fm)
r.color = unicode(self.color_box.currentText())
idx = self.column_box.currentIndex()
col = unicode(self.column_box.itemData(idx).toString())
for c in self.conditions:
condition = c.condition
if condition is not None:
r.add_condition(*condition)
return col, r
class ValueTypeEditor(QWidget):
ValueTypes = (bool, int, float, complex, str)
def __init__(self, *args):
QWidget.__init__(self, *args)
lo = QHBoxLayout(self)
lo.setContentsMargins(0, 0, 0, 0)
lo.setSpacing(5)
# type selector
self.wtypesel = QComboBox(self)
for i, tp in enumerate(self.ValueTypes):
self.wtypesel.addItem(tp.__name__)
QObject.connect(self.wtypesel, SIGNAL("activated(int)"),
self._selectTypeNum)
typesel_lab = QLabel("&Type:", self)
typesel_lab.setBuddy(self.wtypesel)
lo.addWidget(typesel_lab, 0)
lo.addWidget(self.wtypesel, 0)
self.wvalue = QLineEdit(self)
self.wvalue_lab = QLabel("&Value:", self)
self.wvalue_lab.setBuddy(self.wvalue)
self.wbool = QComboBox(self)
self.wbool.addItems(["false", "true"])
self.wbool.setCurrentIndex(1)
lo.addWidget(self.wvalue_lab, 0)
lo.addWidget(self.wvalue, 1)
lo.addWidget(self.wbool, 1)
self.wvalue.hide()
# make input validators
self._validators = {
int: QIntValidator(self),
float: QDoubleValidator(self)
}
# select bool type initially
self._selectTypeNum(0)
def _selectTypeNum(self, index):
tp = self.ValueTypes[index]
self.wbool.setShown(tp is bool)
self.wvalue.setShown(tp is not bool)
self.wvalue_lab.setBuddy(self.wbool if tp is bool else self.wvalue)
self.wvalue.setValidator(self._validators.get(tp, None))
def setValue(self, value):
"""Sets current value"""
for i, tp in enumerate(self.ValueTypes):
if isinstance(value, tp):
self.wtypesel.setCurrentIndex(i)
self._selectTypeNum(i)
if tp is bool:
self.wbool.setCurrentIndex(1 if value else 0)
else:
self.wvalue.setText(str(value))
return
# unknown value: set bool
self.setValue(True)
def getValue(self):
"""Returns current value, or None if no legal value is set"""
tp = self.ValueTypes[self.wtypesel.currentIndex()]
if tp is bool:
return bool(self.wbool.currentIndex())
else:
try:
return tp(self.wvalue.text())
except:
print("Error converting input to type ", tp.__name__)
traceback.print_exc()
return None
def __init__(self, parent, rc, imgman):
"""An ImageControlDialog is initialized with a parent widget, a RenderControl object,
and an ImageManager object"""
QDialog.__init__(self, parent)
image = rc.image
self.setWindowTitle("%s: Colour Controls" % image.name)
self.setWindowIcon(pixmaps.colours.icon())
self.setModal(False)
self.image = image
self._rc = rc
self._imgman = imgman
self._currier = PersistentCurrier()
# init internal state
self._prev_range = self._display_range = None, None
self._hist = None
self._geometry = None
# create layouts
lo0 = QVBoxLayout(self)
# lo0.setContentsMargins(0,0,0,0)
# histogram plot
whide = self.makeButton("Hide", self.hide, width=128)
whide.setShortcut(Qt.Key_F9)
lo0.addWidget(Separator(self, "Histogram and ITF", extra_widgets=[whide]))
lo1 = QHBoxLayout()
lo1.setContentsMargins(0, 0, 0, 0)
self._histplot = QwtPlot(self)
self._histplot.setAutoDelete(False)
lo1.addWidget(self._histplot, 1)
lo2 = QHBoxLayout()
lo2.setContentsMargins(0, 0, 0, 0)
lo2.setSpacing(2)
lo0.addLayout(lo2)
lo0.addLayout(lo1)
self._wautozoom = QCheckBox("autozoom", self)
self._wautozoom.setChecked(True)
self._wautozoom.setToolTip("""<P>If checked, then the histrogram plot will zoom in automatically when
you narrow the current intensity range.</P>""")
self._wlogy = QCheckBox("log Y", self)
self._wlogy.setChecked(True)
self._ylogscale = True
self._wlogy.setToolTip(
"""<P>If checked, a log-scale Y axis is used for the histogram plot instead of a linear one.""")
QObject.connect(self._wlogy, SIGNAL("toggled(bool)"), self._setHistLogScale)
self._whistunzoom = self.makeButton("", self._unzoomHistogram, icon=pixmaps.full_range.icon())
self._whistzoomout = self.makeButton("-", self._currier.curry(self._zoomHistogramByFactor, math.sqrt(.1)))
self._whistzoomin = self.makeButton("+", self._currier.curry(self._zoomHistogramByFactor, math.sqrt(10)))
self._whistzoomin.setToolTip("""<P>Click to zoom into the histogram plot by one step. This does not
change the current intensity range.</P>""")
self._whistzoomout.setToolTip("""<P>Click to zoom out of the histogram plot by one step. This does not
change the current intensity range.</P>""")
self._whistunzoom.setToolTip("""<P>Click to reset the histogram plot back to its full extent.
This does not change the current intensity range.</P>""")
self._whistzoom = QwtWheel(self)
self._whistzoom.setOrientation(Qt.Horizontal)
self._whistzoom.setMaximumWidth(80)
self._whistzoom.setRange(10, 0)
self._whistzoom.setStep(0.1)
self._whistzoom.setTickCnt(30)
self._whistzoom.setTracking(False)
QObject.connect(self._whistzoom, SIGNAL("valueChanged(double)"), self._zoomHistogramFinalize)
QObject.connect(self._whistzoom, SIGNAL("sliderMoved(double)"), self._zoomHistogramPreview)
self._whistzoom.setToolTip("""<P>Use this wheel control to zoom in/out of the histogram plot.
This does not change the current intensity range.
Note that the zoom wheel should also respond to your mouse wheel, if you have one.</P>""")
# This works around a stupid bug in QwtSliders -- when using the mousewheel, only sliderMoved() signals are emitted,
# with no final valueChanged(). If we want to do a fast preview of something on sliderMoved(), and a "slow" final
# step on valueChanged(), we're in trouble. So we start a timer on sliderMoved(), and if the timer expires without
# anything else happening, do a valueChanged().
# Here we use a timer to call zoomHistogramFinalize() w/o an argument.
self._whistzoom_timer = QTimer(self)
self._whistzoom_timer.setSingleShot(True)
self._whistzoom_timer.setInterval(500)
QObject.connect(self._whistzoom_timer, SIGNAL("timeout()"), self._zoomHistogramFinalize)
# set same size for all buttons and controls
width = 24
for w in self._whistunzoom, self._whistzoomin, self._whistzoomout:
w.setMinimumSize(width, width)
w.setMaximumSize(width, width)
self._whistzoom.setMinimumSize(80, width)
self._wlab_histpos_text = "(hover here for help)"
self._wlab_histpos = QLabel(self._wlab_histpos_text, self)
self._wlab_histpos.setToolTip("""
<P>The plot shows a histogram of either the full image or its selected subset
(as per the "Data subset" section below).</P>
<P>The current intensity range is indicated by the grey box
in the plot.</P>
<P>Use the left mouse button to change the low intensity limit, and the right
button (on Macs, use Ctrl-click) to change the high limit.</P>
<P>Use Shift with the left mouse button to zoom into an area of the histogram,
or else use the "zoom wheel" control or the plus/minus toolbuttons above the histogram to zoom in or out.
To zoom back out to the full extent of the histogram, click on the rightmost button above the histogram.</P>
""")
lo2.addWidget(self._wlab_histpos, 1)
lo2.addWidget(self._wautozoom)
lo2.addWidget(self._wlogy, 0)
lo2.addWidget(self._whistzoomin, 0)
lo2.addWidget(self._whistzoom, 0)
lo2.addWidget(self._whistzoomout, 0)
lo2.addWidget(self._whistunzoom, 0)
self._zooming_histogram = False
sliced_axes = rc.slicedAxes()
dprint(1, "sliced axes are", sliced_axes)
self._stokes_axis = None
# subset indication
lo0.addWidget(Separator(self, "Data subset"))
# sliced axis selectors
self._wslicers = []
if sliced_axes:
lo1 = QHBoxLayout()
lo1.setContentsMargins(0, 0, 0, 0)
lo1.setSpacing(2)
lo0.addLayout(lo1)
lo1.addWidget(QLabel("Current slice: ", self))
for i, (iextra, name, labels) in enumerate(sliced_axes):
lo1.addWidget(QLabel("%s:" % name, self))
if name == "STOKES":
self._stokes_axis = iextra
# add controls
wslicer = QComboBox(self)
self._wslicers.append(wslicer)
wslicer.addItems(labels)
wslicer.setToolTip("""<P>Selects current slice along the %s axis.</P>""" % name)
wslicer.setCurrentIndex(self._rc.currentSlice()[iextra])
QObject.connect(wslicer, SIGNAL("activated(int)"), self._currier.curry(self._rc.changeSlice, iextra))
lo2 = QVBoxLayout()
lo1.addLayout(lo2)
lo2.setContentsMargins(0, 0, 0, 0)
lo2.setSpacing(0)
wminus = QToolButton(self)
wminus.setArrowType(Qt.UpArrow)
QObject.connect(wminus, SIGNAL("clicked()"), self._currier.curry(self._rc.incrementSlice, iextra, 1))
if i == 0:
wminus.setShortcut(Qt.SHIFT + Qt.Key_F7)
elif i == 1:
wminus.setShortcut(Qt.SHIFT + Qt.Key_F8)
wplus = QToolButton(self)
wplus.setArrowType(Qt.DownArrow)
QObject.connect(wplus, SIGNAL("clicked()"), self._currier.curry(self._rc.incrementSlice, iextra, -1))
if i == 0:
wplus.setShortcut(Qt.Key_F7)
elif i == 1:
wplus.setShortcut(Qt.Key_F8)
wminus.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
wplus.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
sz = QSize(12, 8)
wminus.setMinimumSize(sz)
wplus.setMinimumSize(sz)
wminus.resize(sz)
wplus.resize(sz)
lo2.addWidget(wminus)
lo2.addWidget(wplus)
lo1.addWidget(wslicer)
lo1.addSpacing(5)
lo1.addStretch(1)
# subset indicator
lo1 = QHBoxLayout()
lo1.setContentsMargins(0, 0, 0, 0)
lo1.setSpacing(2)
lo0.addLayout(lo1)
self._wlab_subset = QLabel("Subset: xxx", self)
self._wlab_subset.setToolTip("""<P>This indicates the current data subset to which the histogram
and the stats given here apply. Use the "Reset to" control on the right to change the
current subset and recompute the histogram and stats.</P>""")
lo1.addWidget(self._wlab_subset, 1)
self._wreset_full = self.makeButton("\u2192 full", self._rc.setFullSubset)
lo1.addWidget(self._wreset_full)
if sliced_axes:
# if self._stokes_axis is not None and len(sliced_axes)>1:
# self._wreset_stokes = self.makeButton(u"\u21920Stokes",self._rc.setFullSubset)
self._wreset_slice = self.makeButton("\u2192 slice", self._rc.setSliceSubset)
lo1.addWidget(self._wreset_slice)
else:
self._wreset_slice = None
# min/max controls
lo1 = QHBoxLayout()
lo1.setContentsMargins(0, 0, 0, 0)
lo0.addLayout(lo1, 0)
self._wlab_stats = QLabel(self)
lo1.addWidget(self._wlab_stats, 0)
self._wmore_stats = self.makeButton("more...", self._showMeanStd)
self._wlab_stats.setMinimumHeight(self._wmore_stats.height())
lo1.addWidget(self._wmore_stats, 0)
lo1.addStretch(1)
# intensity controls
lo0.addWidget(Separator(self, "Intensity mapping"))
lo1 = QHBoxLayout()
lo1.setContentsMargins(0, 0, 0, 0)
lo1.setSpacing(2)
lo0.addLayout(lo1, 0)
self._range_validator = FloatValidator(self)
self._wrange = QLineEdit(self), QLineEdit(self)
self._wrange[0].setToolTip("""<P>This is the low end of the intensity range.</P>""")
self._wrange[1].setToolTip("""<P>This is the high end of the intensity range.</P>""")
for w in self._wrange:
w.setValidator(self._range_validator)
QObject.connect(w, SIGNAL("editingFinished()"), self._changeDisplayRange)
lo1.addWidget(QLabel("low:", self), 0)
lo1.addWidget(self._wrange[0], 1)
self._wrangeleft0 = self.makeButton("\u21920", self._setZeroLeftLimit, width=32)
self._wrangeleft0.setToolTip("""<P>Click this to set the low end of the intensity range to 0.</P>""")
lo1.addWidget(self._wrangeleft0, 0)
lo1.addSpacing(8)
lo1.addWidget(QLabel("high:", self), 0)
lo1.addWidget(self._wrange[1], 1)
lo1.addSpacing(8)
self._wrange_full = self.makeButton(None, self._setHistDisplayRange, icon=pixmaps.intensity_graph.icon())
lo1.addWidget(self._wrange_full)
self._wrange_full.setToolTip(
"""<P>Click this to reset the intensity range to the current extent of the histogram plot.</P>""")
# add menu for display range
range_menu = QMenu(self)
wrange_menu = QToolButton(self)
wrange_menu.setText("Reset to")
wrange_menu.setToolTip("""<P>Use this to reset the intensity range to various pre-defined settings.</P>""")
lo1.addWidget(wrange_menu)
self._qa_range_full = range_menu.addAction(pixmaps.full_range.icon(), "Full subset",
self._rc.resetSubsetDisplayRange)
self._qa_range_hist = range_menu.addAction(pixmaps.intensity_graph.icon(), "Current histogram limits",
self._setHistDisplayRange)
for percent in (99.99, 99.9, 99.5, 99, 98, 95):
range_menu.addAction("%g%%" % percent, self._currier.curry(self._changeDisplayRangeToPercent, percent))
wrange_menu.setMenu(range_menu)
wrange_menu.setPopupMode(QToolButton.InstantPopup)
lo1 = QGridLayout()
lo1.setContentsMargins(0, 0, 0, 0)
lo0.addLayout(lo1, 0)
self._wimap = QComboBox(self)
lo1.addWidget(QLabel("Intensity policy:", self), 0, 0)
lo1.addWidget(self._wimap, 1, 0)
self._wimap.addItems(rc.getIntensityMapNames())
QObject.connect(self._wimap, SIGNAL("currentIndexChanged(int)"), self._rc.setIntensityMapNumber)
self._wimap.setToolTip("""<P>Use this to change the type of the intensity transfer function (ITF).</P>""")
# log cycles control
lo1.setColumnStretch(1, 1)
self._wlogcycles_label = QLabel("Log cycles: ", self)
lo1.addWidget(self._wlogcycles_label, 0, 1)
# self._wlogcycles = QwtWheel(self)
# self._wlogcycles.setTotalAngle(360)
self._wlogcycles = QwtSlider(self)
self._wlogcycles.setToolTip(
"""<P>Use this to change the log-base for the logarithmic intensity transfer function (ITF).</P>""")
# This works around a stupid bug in QwtSliders -- see comments on histogram zoom wheel above
self._wlogcycles_timer = QTimer(self)
self._wlogcycles_timer.setSingleShot(True)
self._wlogcycles_timer.setInterval(500)
QObject.connect(self._wlogcycles_timer, SIGNAL("timeout()"), self._setIntensityLogCycles)
lo1.addWidget(self._wlogcycles, 1, 1)
self._wlogcycles.setRange(1., 10)
self._wlogcycles.setStep(0.1)
self._wlogcycles.setTracking(False)
QObject.connect(self._wlogcycles, SIGNAL("valueChanged(double)"), self._setIntensityLogCycles)
QObject.connect(self._wlogcycles, SIGNAL("sliderMoved(double)"), self._previewIntensityLogCycles)
self._updating_imap = False
# lock intensity map
lo1 = QHBoxLayout()
lo1.setContentsMargins(0, 0, 0, 0)
lo0.addLayout(lo1, 0)
# lo1.addWidget(QLabel("Lock range accross",self))
wlock = QCheckBox("Lock display range", self)
wlock.setToolTip("""<P>If checked, then the intensity range will be locked. The ranges of all locked images
change simultaneously.</P>""")
lo1.addWidget(wlock)
wlockall = QToolButton(self)
wlockall.setIcon(pixmaps.locked.icon())
wlockall.setText("Lock all to this")
wlockall.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
wlockall.setAutoRaise(True)
wlockall.setToolTip("""<P>Click this to lock together the intensity ranges of all images.</P>""")
lo1.addWidget(wlockall)
wunlockall = QToolButton(self)
wunlockall.setIcon(pixmaps.unlocked.icon())
wunlockall.setText("Unlock all")
wunlockall.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
wunlockall.setAutoRaise(True)
wunlockall.setToolTip("""<P>Click this to unlock the intensity ranges of all images.</P>""")
lo1.addWidget(wunlockall)
wlock.setChecked(self._rc.isDisplayRangeLocked())
QObject.connect(wlock, SIGNAL("clicked(bool)"), self._rc.lockDisplayRange)
QObject.connect(wlockall, SIGNAL("clicked()"),
self._currier.curry(self._imgman.lockAllDisplayRanges, self._rc))
QObject.connect(wunlockall, SIGNAL("clicked()"), self._imgman.unlockAllDisplayRanges)
QObject.connect(self._rc, SIGNAL("displayRangeLocked"), wlock.setChecked)
# self._wlock_imap_axis = [ QCheckBox(name,self) for iaxis,name,labels in sliced_axes ]
# for iw,w in enumerate(self._wlock_imap_axis):
# QObject.connect(w,SIGNAL("toggled(bool)"),self._currier.curry(self._rc.lockDisplayRangeForAxis,iw))
# lo1.addWidget(w,0)
lo1.addStretch(1)
# lo0.addWidget(Separator(self,"Colourmap"))
# color bar
self._colorbar = QwtPlot(self)
lo0.addWidget(self._colorbar)
self._colorbar.setAutoDelete(False)
self._colorbar.setMinimumHeight(32)
self._colorbar.enableAxis(QwtPlot.yLeft, False)
self._colorbar.enableAxis(QwtPlot.xBottom, False)
# color plot
self._colorplot = QwtPlot(self)
lo0.addWidget(self._colorplot)
self._colorplot.setAutoDelete(False)
self._colorplot.setMinimumHeight(64)
self._colorplot.enableAxis(QwtPlot.yLeft, False)
self._colorplot.enableAxis(QwtPlot.xBottom, False)
# self._colorplot.setSizePolicy(QSizePolicy.Expanding,QSizePolicy.Preferred)
self._colorbar.hide()
self._colorplot.hide()
# color controls
lo1 = QHBoxLayout()
lo1.setContentsMargins(0, 0, 0, 0)
lo0.addLayout(lo1, 1)
lo1.addWidget(QLabel("Colourmap:", self))
# colormap list
### NB: use setIconSize() and icons in QComboBox!!!
self._wcolmaps = QComboBox(self)
self._wcolmaps.setIconSize(QSize(128, 16))
self._wcolmaps.setToolTip("""<P>Use this to select a different colourmap.</P>""")
for cmap in self._rc.getColormapList():
self._wcolmaps.addItem(QIcon(cmap.makeQPixmap(128, 16)), cmap.name)
lo1.addWidget(self._wcolmaps)
QObject.connect(self._wcolmaps, SIGNAL("activated(int)"), self._rc.setColorMapNumber)
# add widgetstack for colormap controls
self._wcolmap_control_stack = QStackedWidget(self)
self._wcolmap_control_blank = QWidget(self._wcolmap_control_stack)
self._wcolmap_control_stack.addWidget(self._wcolmap_control_blank)
lo0.addWidget(self._wcolmap_control_stack)
self._colmap_controls = []
# add controls to stack
for index, cmap in enumerate(self._rc.getColormapList()):
if isinstance(cmap, Colormaps.ColormapWithControls):
controls = cmap.makeControlWidgets(self._wcolmap_control_stack)
self._wcolmap_control_stack.addWidget(controls)
QObject.connect(cmap, SIGNAL("colormapChanged"),
self._currier.curry(self._previewColormapParameters, index, cmap))
QObject.connect(cmap, SIGNAL("colormapPreviewed"),
self._currier.curry(self._previewColormapParameters, index, cmap))
self._colmap_controls.append(controls)
else:
self._colmap_controls.append(self._wcolmap_control_blank)
# connect updates from renderControl and image
self.image.connect(SIGNAL("slice"), self._updateImageSlice)
QObject.connect(self._rc, SIGNAL("intensityMapChanged"), self._updateIntensityMap)
QObject.connect(self._rc, SIGNAL("colorMapChanged"), self._updateColorMap)
QObject.connect(self._rc, SIGNAL("dataSubsetChanged"), self._updateDataSubset)
QObject.connect(self._rc, SIGNAL("displayRangeChanged"), self._updateDisplayRange)
# update widgets
self._setupHistogramPlot()
self._updateDataSubset(*self._rc.currentSubset())
self._updateColorMap(image.colorMap())
self._updateIntensityMap(rc.currentIntensityMap(), rc.currentIntensityMapNumber())
self._updateDisplayRange(*self._rc.displayRange())
class StepEditDialog(QDialog):
def __init__(self, parent, step):
super(StepEditDialog, self).__init__(parent)
self._step = step
self._initGui()
#--------------------------------------------------------------------#
def _initGui(self):
layout = QVBoxLayout()
self.setLayout(layout)
self.cb_step_type = QComboBox()
self.widgets = QStackedWidget()
layout.addWidget(self.cb_step_type)
layout.addWidget(self.widgets)
if self._step is None:
for step_class in Step.REGISTERED_STEPS.values():
self.cb_step_type.addItem(step_class.NAME)
w = step_class.GET_WIDGET()
self.widgets.addWidget(w)
self.cb_step_type.currentIndexChanged.connect(
self._stepTypeChanged)
else:
self.cb_step_type.addItems(Step.REGISTERED_STEPS.keys())
self.cb_step_type.setEnabled(False)
index = self.cb_step_type.findText(QString(str(self._step.NAME)))
self.cb_step_type.setCurrentIndex(index)
w = self._step.getWidget()
self.widgets.addWidget(w)
self._showStepProperties()
###################
# Action Buttons: #
###################
buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
layout.addWidget(buttons)
#--------------------------------------------------------------------#
def _showStepProperties(self):
index = self.cb_step_type.currentIndex()
self.widgets.setCurrentIndex(index)
#--------------------------------------------------------------------#
def _stepTypeChanged(self):
self._showStepProperties()
#--------------------------------------------------------------------#
def sizeHint(self):
hint = QDialog.sizeHint(self)
hint.setWidth(500)
return hint
#--------------------------------------------------------------------#
def step(self):
return self._step
#--------------------------------------------------------------------#
def accept(self, *args, **kwargs):
if self._step is None:
name = str(self.cb_step_type.currentText())
step_class = Step.REGISTERED_STEPS[name]
self._step = step_class()
self.widgets.currentWidget().save(self._step.attributes())
else:
self._selected_widget.save()
return QDialog.accept(self, *args, **kwargs)
class ConfigWidget(QWidget, Logger):
'''
Config dialog for Marvin Manager
'''
WIZARD_PROFILES = {
'Annotations': {
'label': 'mm_annotations',
'datatype': 'comments',
'display': {},
'is_multiple': False
},
'Collections': {
'label': 'mm_collections',
'datatype': 'text',
'display': {u'is_names': False},
'is_multiple': True
},
'Last read': {
'label': 'mm_date_read',
'datatype': 'datetime',
'display': {},
'is_multiple': False
},
'Locked': {
'label': 'mm_locked',
'datatype': 'bool',
'display': {},
'is_multiple': False
},
'Progress': {
'label': 'mm_progress',
'datatype': 'float',
'display': {u'number_format': u'{0:.0f}%'},
'is_multiple': False
},
'Read': {
'label': 'mm_read',
'datatype': 'bool',
'display': {},
'is_multiple': False
},
'Reading list': {
'label': 'mm_reading_list',
'datatype': 'bool',
'display': {},
'is_multiple': False
},
'Word count': {
'label': 'mm_word_count',
'datatype': 'int',
'display': {u'number_format': u'{0:n}'},
'is_multiple': False
}
}
def __init__(self, plugin_action):
QWidget.__init__(self)
self.parent = plugin_action
self.gui = get_gui()
self.icon = plugin_action.icon
self.opts = plugin_action.opts
self.prefs = plugin_prefs
self.resources_path = plugin_action.resources_path
self.verbose = plugin_action.verbose
self.restart_required = False
self._log_location()
self.l = QGridLayout()
self.setLayout(self.l)
self.column1_layout = QVBoxLayout()
self.l.addLayout(self.column1_layout, 0, 0)
self.column2_layout = QVBoxLayout()
self.l.addLayout(self.column2_layout, 0, 1)
# ----------------------------- Column 1 -----------------------------
# ~~~~~~~~ Create the Custom fields options group box ~~~~~~~~
self.cfg_custom_fields_gb = QGroupBox(self)
self.cfg_custom_fields_gb.setTitle('Custom column assignments')
self.column1_layout.addWidget(self.cfg_custom_fields_gb)
self.cfg_custom_fields_qgl = QGridLayout(self.cfg_custom_fields_gb)
current_row = 0
# ++++++++ Labels + HLine ++++++++
self.marvin_source_label = QLabel("Marvin source")
self.cfg_custom_fields_qgl.addWidget(self.marvin_source_label, current_row, 0)
self.calibre_destination_label = QLabel("calibre destination")
self.cfg_custom_fields_qgl.addWidget(self.calibre_destination_label, current_row, 1)
current_row += 1
self.sd_hl = QFrame(self.cfg_custom_fields_gb)
self.sd_hl.setFrameShape(QFrame.HLine)
self.sd_hl.setFrameShadow(QFrame.Raised)
self.cfg_custom_fields_qgl.addWidget(self.sd_hl, current_row, 0, 1, 3)
current_row += 1
# ++++++++ Annotations ++++++++
self.cfg_annotations_label = QLabel('Annotations')
self.cfg_annotations_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_annotations_label, current_row, 0)
self.annotations_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.annotations_field_comboBox.setObjectName('annotations_field_comboBox')
self.annotations_field_comboBox.setToolTip('Select a custom column to store Marvin annotations')
self.cfg_custom_fields_qgl.addWidget(self.annotations_field_comboBox, current_row, 1)
self.cfg_highlights_wizard = QToolButton()
self.cfg_highlights_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_highlights_wizard.setToolTip("Create a custom column to store Marvin annotations")
self.cfg_highlights_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Annotations'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_highlights_wizard, current_row, 2)
current_row += 1
# ++++++++ Collections ++++++++
self.cfg_collections_label = QLabel('Collections')
self.cfg_collections_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_collections_label, current_row, 0)
self.collection_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.collection_field_comboBox.setObjectName('collection_field_comboBox')
self.collection_field_comboBox.setToolTip('Select a custom column to store Marvin collection assignments')
self.cfg_custom_fields_qgl.addWidget(self.collection_field_comboBox, current_row, 1)
self.cfg_collections_wizard = QToolButton()
self.cfg_collections_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_collections_wizard.setToolTip("Create a custom column for Marvin collection assignments")
self.cfg_collections_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Collections'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_collections_wizard, current_row, 2)
current_row += 1
# ++++++++ Last read ++++++++
self.cfg_date_read_label = QLabel("Last read")
self.cfg_date_read_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_date_read_label, current_row, 0)
self.date_read_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.date_read_field_comboBox.setObjectName('date_read_field_comboBox')
self.date_read_field_comboBox.setToolTip('Select a custom column to store Last read date')
self.cfg_custom_fields_qgl.addWidget(self.date_read_field_comboBox, current_row, 1)
self.cfg_collections_wizard = QToolButton()
self.cfg_collections_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_collections_wizard.setToolTip("Create a custom column to store Last read date")
self.cfg_collections_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Last read'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_collections_wizard, current_row, 2)
current_row += 1
# ++++++++ Locked ++++++++
self.cfg_locked_label = QLabel("Locked")
self.cfg_locked_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_locked_label, current_row, 0)
self.locked_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.locked_field_comboBox.setObjectName('locked_field_comboBox')
self.locked_field_comboBox.setToolTip('Select a custom column to store Locked status')
self.cfg_custom_fields_qgl.addWidget(self.locked_field_comboBox, current_row, 1)
self.cfg_locked_wizard = QToolButton()
self.cfg_locked_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_locked_wizard.setToolTip("Create a custom column to store Locked status")
self.cfg_locked_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Locked'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_locked_wizard, current_row, 2)
current_row += 1
# ++++++++ Progress ++++++++
self.cfg_progress_label = QLabel('Progress')
self.cfg_progress_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_progress_label, current_row, 0)
self.progress_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.progress_field_comboBox.setObjectName('progress_field_comboBox')
self.progress_field_comboBox.setToolTip('Select a custom column to store Marvin reading progress')
self.cfg_custom_fields_qgl.addWidget(self.progress_field_comboBox, current_row, 1)
self.cfg_progress_wizard = QToolButton()
self.cfg_progress_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_progress_wizard.setToolTip("Create a custom column to store Marvin reading progress")
self.cfg_progress_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Progress'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_progress_wizard, current_row, 2)
current_row += 1
# ++++++++ Read flag ++++++++
self.cfg_read_label = QLabel('Read')
self.cfg_read_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_read_label, current_row, 0)
self.read_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.read_field_comboBox.setObjectName('read_field_comboBox')
self.read_field_comboBox.setToolTip('Select a custom column to store Marvin Read status')
self.cfg_custom_fields_qgl.addWidget(self.read_field_comboBox, current_row, 1)
self.cfg_read_wizard = QToolButton()
self.cfg_read_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_read_wizard.setToolTip("Create a custom column to store Marvin Read status")
self.cfg_read_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Read'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_read_wizard, current_row, 2)
current_row += 1
# ++++++++ Reading list flag ++++++++
self.cfg_reading_list_label = QLabel('Reading list')
self.cfg_reading_list_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_reading_list_label, current_row, 0)
self.reading_list_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.reading_list_field_comboBox.setObjectName('reading_list_field_comboBox')
self.reading_list_field_comboBox.setToolTip('Select a custom column to store Marvin Reading list status')
self.cfg_custom_fields_qgl.addWidget(self.reading_list_field_comboBox, current_row, 1)
self.cfg_reading_list_wizard = QToolButton()
self.cfg_reading_list_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_reading_list_wizard.setToolTip("Create a custom column to store Marvin Reading list status")
self.cfg_reading_list_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Reading list'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_reading_list_wizard, current_row, 2)
current_row += 1
# ++++++++ Word count ++++++++
self.cfg_word_count_label = QLabel('Word count')
self.cfg_word_count_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_word_count_label, current_row, 0)
self.word_count_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.word_count_field_comboBox.setObjectName('word_count_field_comboBox')
self.word_count_field_comboBox.setToolTip('Select a custom column to store Marvin word counts')
self.cfg_custom_fields_qgl.addWidget(self.word_count_field_comboBox, current_row, 1)
self.cfg_word_count_wizard = QToolButton()
self.cfg_word_count_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_word_count_wizard.setToolTip("Create a custom column to store Marvin word counts")
self.cfg_word_count_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Word count'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_word_count_wizard, current_row, 2)
current_row += 1
self.spacerItem1 = QSpacerItem(20, 20, QSizePolicy.Minimum, QSizePolicy.Expanding)
self.column1_layout.addItem(self.spacerItem1)
# ----------------------------- Column 2 -----------------------------
# ~~~~~~~~ Create the CSS group box ~~~~~~~~
self.cfg_css_options_gb = QGroupBox(self)
self.cfg_css_options_gb.setTitle('CSS')
self.column2_layout.addWidget(self.cfg_css_options_gb)
self.cfg_css_options_qgl = QGridLayout(self.cfg_css_options_gb)
current_row = 0
# ++++++++ Annotations appearance ++++++++
self.annotations_icon = QIcon(os.path.join(self.resources_path, 'icons', 'annotations_hiliter.png'))
self.cfg_annotations_appearance_toolbutton = QToolButton()
self.cfg_annotations_appearance_toolbutton.setIcon(self.annotations_icon)
self.cfg_annotations_appearance_toolbutton.clicked.connect(self.configure_appearance)
self.cfg_css_options_qgl.addWidget(self.cfg_annotations_appearance_toolbutton, current_row, 0)
self.cfg_annotations_label = ClickableQLabel("Book notes, Bookmark notes and Annotations")
self.connect(self.cfg_annotations_label, SIGNAL('clicked()'), self.configure_appearance)
self.cfg_css_options_qgl.addWidget(self.cfg_annotations_label, current_row, 1)
current_row += 1
# ++++++++ Injected CSS ++++++++
self.css_editor_icon = QIcon(I('format-text-heading.png'))
self.cfg_css_editor_toolbutton = QToolButton()
self.cfg_css_editor_toolbutton.setIcon(self.css_editor_icon)
self.cfg_css_editor_toolbutton.clicked.connect(self.edit_css)
self.cfg_css_options_qgl.addWidget(self.cfg_css_editor_toolbutton, current_row, 0)
self.cfg_css_editor_label = ClickableQLabel("Articles, Vocabulary")
self.connect(self.cfg_css_editor_label, SIGNAL('clicked()'), self.edit_css)
self.cfg_css_options_qgl.addWidget(self.cfg_css_editor_label, current_row, 1)
"""
# ~~~~~~~~ Create the Dropbox syncing group box ~~~~~~~~
self.cfg_dropbox_syncing_gb = QGroupBox(self)
self.cfg_dropbox_syncing_gb.setTitle('Dropbox')
self.column2_layout.addWidget(self.cfg_dropbox_syncing_gb)
self.cfg_dropbox_syncing_qgl = QGridLayout(self.cfg_dropbox_syncing_gb)
current_row = 0
# ++++++++ Syncing enabled checkbox ++++++++
self.dropbox_syncing_checkbox = QCheckBox('Enable Dropbox updates')
self.dropbox_syncing_checkbox.setObjectName('dropbox_syncing')
self.dropbox_syncing_checkbox.setToolTip('Refresh custom column content from Marvin metadata')
self.cfg_dropbox_syncing_qgl.addWidget(self.dropbox_syncing_checkbox,
current_row, 0, 1, 3)
current_row += 1
# ++++++++ Dropbox folder picker ++++++++
self.dropbox_folder_icon = QIcon(os.path.join(self.resources_path, 'icons', 'dropbox.png'))
self.cfg_dropbox_folder_toolbutton = QToolButton()
self.cfg_dropbox_folder_toolbutton.setIcon(self.dropbox_folder_icon)
self.cfg_dropbox_folder_toolbutton.setToolTip("Specify Dropbox folder location on your computer")
self.cfg_dropbox_folder_toolbutton.clicked.connect(self.select_dropbox_folder)
self.cfg_dropbox_syncing_qgl.addWidget(self.cfg_dropbox_folder_toolbutton,
current_row, 1)
# ++++++++ Dropbox location lineedit ++++++++
self.dropbox_location_lineedit = QLineEdit()
self.dropbox_location_lineedit.setPlaceholderText("Dropbox folder location")
self.cfg_dropbox_syncing_qgl.addWidget(self.dropbox_location_lineedit,
current_row, 2)
"""
# ~~~~~~~~ Create the General options group box ~~~~~~~~
self.cfg_runtime_options_gb = QGroupBox(self)
self.cfg_runtime_options_gb.setTitle('General options')
self.column2_layout.addWidget(self.cfg_runtime_options_gb)
self.cfg_runtime_options_qvl = QVBoxLayout(self.cfg_runtime_options_gb)
# ++++++++ Temporary markers: Duplicates ++++++++
self.duplicate_markers_checkbox = QCheckBox('Apply temporary markers to duplicate books')
self.duplicate_markers_checkbox.setObjectName('apply_markers_to_duplicates')
self.duplicate_markers_checkbox.setToolTip('Books with identical content will be flagged in the Library window')
self.cfg_runtime_options_qvl.addWidget(self.duplicate_markers_checkbox)
# ++++++++ Temporary markers: Updated ++++++++
self.updated_markers_checkbox = QCheckBox('Apply temporary markers to books with updated content')
self.updated_markers_checkbox.setObjectName('apply_markers_to_updated')
self.updated_markers_checkbox.setToolTip('Books with updated content will be flagged in the Library window')
self.cfg_runtime_options_qvl.addWidget(self.updated_markers_checkbox)
# ++++++++ Auto refresh checkbox ++++++++
self.auto_refresh_checkbox = QCheckBox('Automatically refresh custom column content')
self.auto_refresh_checkbox.setObjectName('auto_refresh_at_startup')
self.auto_refresh_checkbox.setToolTip('Update calibre custom column when Marvin XD is opened')
self.cfg_runtime_options_qvl.addWidget(self.auto_refresh_checkbox)
# ++++++++ Progress as percentage checkbox ++++++++
self.reading_progress_checkbox = QCheckBox('Show reading progress as percentage')
self.reading_progress_checkbox.setObjectName('show_progress_as_percentage')
self.reading_progress_checkbox.setToolTip('Display percentage in Progress column')
self.cfg_runtime_options_qvl.addWidget(self.reading_progress_checkbox)
# ~~~~~~~~ Create the Debug options group box ~~~~~~~~
self.cfg_debug_options_gb = QGroupBox(self)
self.cfg_debug_options_gb.setTitle('Debug options')
self.column2_layout.addWidget(self.cfg_debug_options_gb)
self.cfg_debug_options_qvl = QVBoxLayout(self.cfg_debug_options_gb)
# ++++++++ Debug logging checkboxes ++++++++
self.debug_plugin_checkbox = QCheckBox('Enable debug logging for Marvin XD')
self.debug_plugin_checkbox.setObjectName('debug_plugin_checkbox')
self.debug_plugin_checkbox.setToolTip('Print plugin diagnostic messages to console')
self.cfg_debug_options_qvl.addWidget(self.debug_plugin_checkbox)
self.debug_libimobiledevice_checkbox = QCheckBox('Enable debug logging for libiMobileDevice')
self.debug_libimobiledevice_checkbox.setObjectName('debug_libimobiledevice_checkbox')
self.debug_libimobiledevice_checkbox.setToolTip('Print libiMobileDevice diagnostic messages to console')
self.cfg_debug_options_qvl.addWidget(self.debug_libimobiledevice_checkbox)
self.spacerItem2 = QSpacerItem(20, 20, QSizePolicy.Minimum, QSizePolicy.Expanding)
self.column2_layout.addItem(self.spacerItem2)
# ~~~~~~~~ End of construction zone ~~~~~~~~
self.resize(self.sizeHint())
# ~~~~~~~~ Populate/restore config options ~~~~~~~~
# Annotations comboBox
self.populate_annotations()
self.populate_collections()
self.populate_date_read()
self.populate_locked()
self.populate_progress()
self.populate_read()
self.populate_reading_list()
self.populate_word_count()
"""
# Restore Dropbox settings, hook changes
dropbox_syncing = self.prefs.get('dropbox_syncing', False)
self.dropbox_syncing_checkbox.setChecked(dropbox_syncing)
self.set_dropbox_syncing(dropbox_syncing)
self.dropbox_syncing_checkbox.clicked.connect(partial(self.set_dropbox_syncing))
self.dropbox_location_lineedit.setText(self.prefs.get('dropbox_folder', ''))
"""
# Restore general settings
self.duplicate_markers_checkbox.setChecked(self.prefs.get('apply_markers_to_duplicates', True))
self.updated_markers_checkbox.setChecked(self.prefs.get('apply_markers_to_updated', True))
self.auto_refresh_checkbox.setChecked(self.prefs.get('auto_refresh_at_startup', False))
self.reading_progress_checkbox.setChecked(self.prefs.get('show_progress_as_percentage', False))
# Restore debug settings, hook changes
self.debug_plugin_checkbox.setChecked(self.prefs.get('debug_plugin', False))
self.debug_plugin_checkbox.stateChanged.connect(self.set_restart_required)
self.debug_libimobiledevice_checkbox.setChecked(self.prefs.get('debug_libimobiledevice', False))
self.debug_libimobiledevice_checkbox.stateChanged.connect(self.set_restart_required)
# Hook changes to Annotations comboBox
# self.annotations_field_comboBox.currentIndexChanged.connect(
# partial(self.save_combobox_setting, 'annotations_field_comboBox'))
self.connect(self.annotations_field_comboBox,
SIGNAL('currentIndexChanged(const QString &)'),
self.annotations_destination_changed)
# Launch the annotated_books_scanner
field = get_cc_mapping('annotations', 'field', None)
self.annotated_books_scanner = InventoryAnnotatedBooks(self.gui, field)
self.connect(self.annotated_books_scanner, self.annotated_books_scanner.signal,
self.inventory_complete)
QTimer.singleShot(1, self.start_inventory)
def annotations_destination_changed(self, qs_new_destination_name):
'''
If the destination field changes, move all existing annotations from old to new
'''
self._log_location(str(qs_new_destination_name))
#self._log("self.eligible_annotations_fields: %s" % self.eligible_annotations_fields)
old_destination_field = get_cc_mapping('annotations', 'field', None)
old_destination_name = get_cc_mapping('annotations', 'combobox', None)
self._log("old_destination_field: %s" % old_destination_field)
self._log("old_destination_name: %s" % old_destination_name)
new_destination_name = unicode(qs_new_destination_name)
self._log("new_destination_name: %s" % repr(new_destination_name))
if old_destination_name == new_destination_name:
self._log_location("old_destination_name = new_destination_name, no changes")
return
if new_destination_name == '':
self._log_location("annotations storage disabled")
set_cc_mapping('annotations', field=None, combobox=new_destination_name)
return
new_destination_field = self.eligible_annotations_fields[new_destination_name]
if existing_annotations(self.parent, old_destination_field):
command = self.launch_new_destination_dialog(old_destination_name, new_destination_name)
if command == 'move':
set_cc_mapping('annotations', field=new_destination_field, combobox=new_destination_name)
if self.annotated_books_scanner.isRunning():
self.annotated_books_scanner.wait()
move_annotations(self, self.annotated_books_scanner.annotation_map,
old_destination_field, new_destination_field)
elif command == 'change':
# Keep the updated destination field, but don't move annotations
pass
elif command == 'cancel':
# Restore previous destination
self.annotations_field_comboBox.blockSignals(True)
old_index = self.annotations_field_comboBox.findText(old_destination_name)
self.annotations_field_comboBox.setCurrentIndex(old_index)
self.annotations_field_comboBox.blockSignals(False)
else:
# No existing annotations, just update prefs
self._log("no existing annotations, updating destination to '{0}'".format(new_destination_name))
set_cc_mapping('annotations', field=new_destination_field, combobox=new_destination_name)
def configure_appearance(self):
'''
'''
self._log_location()
appearance_settings = {
'appearance_css': default_elements,
'appearance_hr_checkbox': False,
'appearance_timestamp_format': default_timestamp
}
# Save, hash the original settings
original_settings = {}
osh = hashlib.md5()
for setting in appearance_settings:
original_settings[setting] = plugin_prefs.get(setting, appearance_settings[setting])
osh.update(repr(plugin_prefs.get(setting, appearance_settings[setting])))
# Display the Annotations appearance dialog
aa = AnnotationsAppearance(self, self.annotations_icon, plugin_prefs)
cancelled = False
if aa.exec_():
# appearance_hr_checkbox and appearance_timestamp_format changed live to prefs during previews
plugin_prefs.set('appearance_css', aa.elements_table.get_data())
# Generate a new hash
nsh = hashlib.md5()
for setting in appearance_settings:
nsh.update(repr(plugin_prefs.get(setting, appearance_settings[setting])))
else:
for setting in appearance_settings:
plugin_prefs.set(setting, original_settings[setting])
nsh = osh
# If there were changes, and there are existing annotations,
# and there is an active Annotations field, offer to re-render
field = get_cc_mapping('annotations', 'field', None)
if osh.digest() != nsh.digest() and existing_annotations(self.parent, field):
title = 'Update annotations?'
msg = '<p>Update existing annotations to new appearance settings?</p>'
d = MessageBox(MessageBox.QUESTION,
title, msg,
show_copy_button=False)
self._log_location("QUESTION: %s" % msg)
if d.exec_():
self._log_location("Updating existing annotations to modified appearance")
# Wait for indexing to complete
while not self.annotated_books_scanner.isFinished():
Application.processEvents()
move_annotations(self, self.annotated_books_scanner.annotation_map,
field, field, window_title="Updating appearance")
def edit_css(self):
'''
'''
self._log_location()
from calibre_plugins.marvin_manager.book_status import dialog_resources_path
klass = os.path.join(dialog_resources_path, 'css_editor.py')
if os.path.exists(klass):
sys.path.insert(0, dialog_resources_path)
this_dc = importlib.import_module('css_editor')
sys.path.remove(dialog_resources_path)
dlg = this_dc.CSSEditorDialog(self, 'css_editor')
dlg.initialize(self)
dlg.exec_()
def get_eligible_custom_fields(self, eligible_types=[], is_multiple=None):
'''
Discover qualifying custom fields for eligible_types[]
'''
#self._log_location(eligible_types)
eligible_custom_fields = {}
for cf in self.gui.current_db.custom_field_keys():
cft = self.gui.current_db.metadata_for_field(cf)['datatype']
cfn = self.gui.current_db.metadata_for_field(cf)['name']
cfim = self.gui.current_db.metadata_for_field(cf)['is_multiple']
#self._log("cf: %s cft: %s cfn: %s cfim: %s" % (cf, cft, cfn, cfim))
if cft in eligible_types:
if is_multiple is not None:
if bool(cfim) == is_multiple:
eligible_custom_fields[cfn] = cf
else:
eligible_custom_fields[cfn] = cf
return eligible_custom_fields
def inventory_complete(self, msg):
self._log_location(msg)
def launch_cc_wizard(self, column_type):
'''
'''
def _update_combo_box(comboBox, destination, previous):
'''
'''
cb = getattr(self, comboBox)
cb.blockSignals(True)
all_items = [str(cb.itemText(i))
for i in range(cb.count())]
if previous and previous in all_items:
all_items.remove(previous)
all_items.append(destination)
cb.clear()
cb.addItems(sorted(all_items, key=lambda s: s.lower()))
# Select the new destination in the comboBox
idx = cb.findText(destination)
if idx > -1:
cb.setCurrentIndex(idx)
cb.blockSignals(False)
from calibre_plugins.marvin_manager.book_status import dialog_resources_path
klass = os.path.join(dialog_resources_path, 'cc_wizard.py')
if os.path.exists(klass):
#self._log("importing CC Wizard dialog from '%s'" % klass)
sys.path.insert(0, dialog_resources_path)
this_dc = importlib.import_module('cc_wizard')
sys.path.remove(dialog_resources_path)
dlg = this_dc.CustomColumnWizard(self,
column_type,
self.WIZARD_PROFILES[column_type],
verbose=True)
dlg.exec_()
if dlg.modified_column:
self._log("modified_column: %s" % dlg.modified_column)
self.restart_required = True
destination = dlg.modified_column['destination']
label = dlg.modified_column['label']
previous = dlg.modified_column['previous']
source = dlg.modified_column['source']
if source == "Annotations":
_update_combo_box("annotations_field_comboBox", destination, previous)
# Add/update the new destination so save_settings() can find it
self.eligible_annotations_fields[destination] = label
# Save manually in case user cancels
set_cc_mapping('annotations', combobox=destination, field=label)
elif source == 'Collections':
_update_combo_box("collection_field_comboBox", destination, previous)
# Add/update the new destination so save_settings() can find it
self.eligible_collection_fields[destination] = label
# Save manually in case user cancels
set_cc_mapping('collections', combobox=destination, field=label)
elif source == 'Last read':
_update_combo_box("date_read_field_comboBox", destination, previous)
# Add/update the new destination so save_settings() can find it
self.eligible_date_read_fields[destination] = label
# Save manually in case user cancels
set_cc_mapping('date_read', combobox=destination, field=label)
elif source == 'Locked':
_update_combo_box("locked_field_comboBox", destination, previous)
# Add/update the new destination so save_settings() can find it
self.eligible_locked_fields[destination] = label
# Save manually in case user cancels
set_cc_mapping('locked', combobox=destination, field=label)
elif source == "Progress":
_update_combo_box("progress_field_comboBox", destination, previous)
# Add/update the new destination so save_settings() can find it
self.eligible_progress_fields[destination] = label
# Save manually in case user cancels
set_cc_mapping('progress', combobox=destination, field=label)
elif source == "Read":
_update_combo_box("read_field_comboBox", destination, previous)
# Add/update the new destination so save_settings() can find it
self.eligible_read_fields[destination] = label
# Save manually in case user cancels
set_cc_mapping('read', combobox=destination, field=label)
elif source == "Reading list":
_update_combo_box("reading_list_field_comboBox", destination, previous)
# Add/update the new destination so save_settings() can find it
self.eligible_reading_list_fields[destination] = label
# Save manually in case user cancels
set_cc_mapping('reading_list', combobox=destination, field=label)
elif source == "Word count":
_update_combo_box("word_count_field_comboBox", destination, previous)
# Add/update the new destination so save_settings() can find it
self.eligible_word_count_fields[destination] = label
# Save manually in case user cancels
set_cc_mapping('word_count', combobox=destination, field=label)
else:
self._log("ERROR: Can't import from '%s'" % klass)
def launch_new_destination_dialog(self, old, new):
'''
Return 'move', 'change' or 'cancel'
'''
from calibre_plugins.marvin_manager.book_status import dialog_resources_path
self._log_location()
klass = os.path.join(dialog_resources_path, 'new_destination.py')
if os.path.exists(klass):
self._log("importing new destination dialog from '%s'" % klass)
sys.path.insert(0, dialog_resources_path)
this_dc = importlib.import_module('new_destination')
sys.path.remove(dialog_resources_path)
dlg = this_dc.NewDestinationDialog(self, old, new)
dlg.exec_()
return dlg.command
def populate_annotations(self):
datatype = self.WIZARD_PROFILES['Annotations']['datatype']
self.eligible_annotations_fields = self.get_eligible_custom_fields([datatype])
self.annotations_field_comboBox.addItems([''])
ecf = sorted(self.eligible_annotations_fields.keys(), key=lambda s: s.lower())
self.annotations_field_comboBox.addItems(ecf)
# Retrieve stored value
existing = get_cc_mapping('annotations', 'combobox')
if existing:
ci = self.annotations_field_comboBox.findText(existing)
self.annotations_field_comboBox.setCurrentIndex(ci)
def populate_collections(self):
datatype = self.WIZARD_PROFILES['Collections']['datatype']
self.eligible_collection_fields = self.get_eligible_custom_fields([datatype],
is_multiple=True)
self.collection_field_comboBox.addItems([''])
ecf = sorted(self.eligible_collection_fields.keys(), key=lambda s: s.lower())
self.collection_field_comboBox.addItems(ecf)
# Retrieve stored value
existing = get_cc_mapping('collections', 'combobox')
if existing:
ci = self.collection_field_comboBox.findText(existing)
self.collection_field_comboBox.setCurrentIndex(ci)
def populate_date_read(self):
#self.eligible_date_read_fields = self.get_eligible_custom_fields(['datetime'])
datatype = self.WIZARD_PROFILES['Last read']['datatype']
self.eligible_date_read_fields = self.get_eligible_custom_fields([datatype])
self.date_read_field_comboBox.addItems([''])
ecf = sorted(self.eligible_date_read_fields.keys(), key=lambda s: s.lower())
self.date_read_field_comboBox.addItems(ecf)
# Retrieve stored value
existing = get_cc_mapping('date_read', 'combobox')
if existing:
ci = self.date_read_field_comboBox.findText(existing)
self.date_read_field_comboBox.setCurrentIndex(ci)
def populate_locked(self):
datatype = self.WIZARD_PROFILES['Locked']['datatype']
self.eligible_locked_fields = self.get_eligible_custom_fields([datatype])
self.locked_field_comboBox.addItems([''])
ecf = sorted(self.eligible_locked_fields.keys(), key=lambda s: s.lower())
self.locked_field_comboBox.addItems(ecf)
# Retrieve stored value
existing = get_cc_mapping('locked', 'combobox')
if existing:
ci = self.locked_field_comboBox.findText(existing)
self.locked_field_comboBox.setCurrentIndex(ci)
def populate_progress(self):
#self.eligible_progress_fields = self.get_eligible_custom_fields(['float'])
datatype = self.WIZARD_PROFILES['Progress']['datatype']
self.eligible_progress_fields = self.get_eligible_custom_fields([datatype])
self.progress_field_comboBox.addItems([''])
ecf = sorted(self.eligible_progress_fields.keys(), key=lambda s: s.lower())
self.progress_field_comboBox.addItems(ecf)
# Retrieve stored value
existing = get_cc_mapping('progress', 'combobox')
if existing:
ci = self.progress_field_comboBox.findText(existing)
self.progress_field_comboBox.setCurrentIndex(ci)
def populate_read(self):
datatype = self.WIZARD_PROFILES['Read']['datatype']
self.eligible_read_fields = self.get_eligible_custom_fields([datatype])
self.read_field_comboBox.addItems([''])
ecf = sorted(self.eligible_read_fields.keys(), key=lambda s: s.lower())
self.read_field_comboBox.addItems(ecf)
# Retrieve stored value
existing = get_cc_mapping('read', 'combobox')
if existing:
ci = self.read_field_comboBox.findText(existing)
self.read_field_comboBox.setCurrentIndex(ci)
def populate_reading_list(self):
datatype = self.WIZARD_PROFILES['Reading list']['datatype']
self.eligible_reading_list_fields = self.get_eligible_custom_fields([datatype])
self.reading_list_field_comboBox.addItems([''])
ecf = sorted(self.eligible_reading_list_fields.keys(), key=lambda s: s.lower())
self.reading_list_field_comboBox.addItems(ecf)
# Retrieve stored value
existing = get_cc_mapping('reading_list', 'combobox')
if existing:
ci = self.reading_list_field_comboBox.findText(existing)
self.reading_list_field_comboBox.setCurrentIndex(ci)
def populate_word_count(self):
#self.eligible_word_count_fields = self.get_eligible_custom_fields(['int'])
datatype = self.WIZARD_PROFILES['Word count']['datatype']
self.eligible_word_count_fields = self.get_eligible_custom_fields([datatype])
self.word_count_field_comboBox.addItems([''])
ecf = sorted(self.eligible_word_count_fields.keys(), key=lambda s: s.lower())
self.word_count_field_comboBox.addItems(ecf)
# Retrieve stored value
existing = get_cc_mapping('word_count', 'combobox')
if existing:
ci = self.word_count_field_comboBox.findText(existing)
self.word_count_field_comboBox.setCurrentIndex(ci)
"""
def select_dropbox_folder(self):
'''
'''
self._log_location()
dropbox_location = QFileDialog.getExistingDirectory(
self,
"Dropbox folder",
os.path.expanduser("~"),
QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks)
self.dropbox_location_lineedit.setText(unicode(dropbox_location))
def set_dropbox_syncing(self, state):
'''
Called when checkbox changes state, or when restoring state
Set enabled state of Dropbox folder picker to match
'''
self.cfg_dropbox_folder_toolbutton.setEnabled(state)
self.dropbox_location_lineedit.setEnabled(state)
"""
def set_restart_required(self, state):
'''
Set restart_required flag to show show dialog when closing dialog
'''
self.restart_required = True
"""
def save_combobox_setting(self, cb, index):
'''
Apply changes immediately
'''
cf = str(getattr(self, cb).currentText())
self._log_location("%s => %s" % (cb, repr(cf)))
if cb == 'annotations_field_comboBox':
field = None
if cf:
field = self.eligible_annotations_fields[cf]
set_cc_mapping('annotations', combobox=cf, field=field)
"""
def save_settings(self):
self._log_location()
# Annotations field
cf = unicode(self.annotations_field_comboBox.currentText())
field = None
if cf:
field = self.eligible_annotations_fields[cf]
set_cc_mapping('annotations', combobox=cf, field=field)
# Collections field
cf = unicode(self.collection_field_comboBox.currentText())
field = None
if cf:
field = self.eligible_collection_fields[cf]
set_cc_mapping('collections', combobox=cf, field=field)
# Date read field
cf = unicode(self.date_read_field_comboBox.currentText())
field = None
if cf:
field = self.eligible_date_read_fields[cf]
set_cc_mapping('date_read', combobox=cf, field=field)
# Locked field
cf = unicode(self.locked_field_comboBox.currentText())
field = None
if cf:
field = self.eligible_locked_fields[cf]
set_cc_mapping('locked', combobox=cf, field=field)
# Progress field
cf = unicode(self.progress_field_comboBox.currentText())
field = None
if cf:
field = self.eligible_progress_fields[cf]
set_cc_mapping('progress', combobox=cf, field=field)
# Read field
cf = unicode(self.read_field_comboBox.currentText())
field = None
if cf:
field = self.eligible_read_fields[cf]
set_cc_mapping('read', combobox=cf, field=field)
# Reading list field
cf = unicode(self.reading_list_field_comboBox.currentText())
field = None
if cf:
field = self.eligible_reading_list_fields[cf]
set_cc_mapping('reading_list', combobox=cf, field=field)
# Word count field
cf = unicode(self.word_count_field_comboBox.currentText())
field = None
if cf:
field = self.eligible_word_count_fields[cf]
set_cc_mapping('word_count', combobox=cf, field=field)
'''
# Save Dropbox settings
self.prefs.set('dropbox_syncing', self.dropbox_syncing_checkbox.isChecked())
self.prefs.set('dropbox_folder', unicode(self.dropbox_location_lineedit.text()))
'''
# Save general settings
self.prefs.set('apply_markers_to_duplicates', self.duplicate_markers_checkbox.isChecked())
self.prefs.set('apply_markers_to_updated', self.updated_markers_checkbox.isChecked())
self.prefs.set('auto_refresh_at_startup', self.auto_refresh_checkbox.isChecked())
self.prefs.set('show_progress_as_percentage', self.reading_progress_checkbox.isChecked())
# Save debug settings
self.prefs.set('debug_plugin', self.debug_plugin_checkbox.isChecked())
self.prefs.set('debug_libimobiledevice', self.debug_libimobiledevice_checkbox.isChecked())
# If restart needed, inform user
if self.restart_required:
do_restart = show_restart_warning('Restart calibre for the changes to be applied.',
parent=self.gui)
if do_restart:
self.gui.quit(restart=True)
def start_inventory(self):
self._log_location()
self.annotated_books_scanner.start()
class EditResidues_PropertyManager( PM_Dialog, DebugMenuMixin ):
"""
The ProteinDisplayStyle_PropertyManager class provides a Property Manager
for the B{Display Style} command on the flyout toolbar in the
Build > Protein mode.
@ivar title: The title that appears in the property manager header.
@type title: str
@ivar pmName: The name of this property manager. This is used to set
the name of the PM_Dialog object via setObjectName().
@type name: str
@ivar iconPath: The relative path to the PNG file that contains a
22 x 22 icon image that appears in the PM header.
@type iconPath: str
"""
title = "Edit Residues"
pmName = title
iconPath = "ui/actions/Edit/EditProteinDisplayStyle.png"
def __init__( self, parentCommand ):
"""
Constructor for the property manager.
"""
self.parentMode = parentCommand
self.w = self.parentMode.w
self.win = self.parentMode.w
self.pw = self.parentMode.pw
self.o = self.win.glpane
self.currentWorkingDirectory = env.prefs[workingDirectory_prefs_key]
PM_Dialog.__init__(self, self.pmName, self.iconPath, self.title)
DebugMenuMixin._init1( self )
self.showTopRowButtons( PM_DONE_BUTTON | \
PM_WHATS_THIS_BUTTON)
msg = "Edit residues."
self.updateMessage(msg)
def connect_or_disconnect_signals(self, isConnect = True):
if isConnect:
change_connect = self.win.connect
else:
change_connect = self.win.disconnect
#change_connect(self.nextAAPushButton,
# SIGNAL("clicked()"),
# self._expandNextRotamer)
def ok_btn_clicked(self):
"""
Slot for the OK button
"""
self.win.toolsDone()
def cancel_btn_clicked(self):
"""
Slot for the Cancel button.
"""
#TODO: Cancel button needs to be removed. See comment at the top
self.win.toolsDone()
def show(self):
"""
Shows the Property Manager. Overrides PM_Dialog.show.
"""
self.sequenceEditor = self.win.createProteinSequenceEditorIfNeeded()
self.sequenceEditor.hide()
PM_Dialog.show(self)
# Update all PM widgets, then establish their signal-slot connections.
# note: It is important to update the widgets *first* since doing
# it in the reverse order will generate signals when updating
# the PM widgets (via updateDnaDisplayStyleWidgets()), causing
# unneccessary repaints of the model view.
self._fillSequenceTable()
self.connect_or_disconnect_signals(isConnect = True)
def close(self):
"""
Closes the Property Manager. Overrides PM_Dialog.close.
"""
self.connect_or_disconnect_signals(False)
PM_Dialog.close(self)
def _addGroupBoxes( self ):
"""
Add the Property Manager group boxes.
"""
self._pmGroupBox1 = PM_GroupBox( self,
title = "Sequence")
self._loadGroupBox1( self._pmGroupBox1 )
#self._pmGroupBox2 = PM_GroupBox( self,
# title = "Rotamer")
#self._loadGroupBox2( self._pmGroupBox2 )
def _loadGroupBox1(self, pmGroupBox):
"""
Load widgets in group box.
"""
self.labelfont = QFont("Helvetica", 12)
self.descriptorfont = QFont("Courier New", 12)
self.headerdata = ['', 'ID', 'Set', 'Descriptor']
self.set_names = ["Any", "Same", "Locked", "Polar", "Apolar"]
self.rosetta_set_names = ["ALLAA", "NATRO", "NATAA", "POLAR", "APOLA"]
self.descriptor_list = ["GAVILMFWCSTYNQDEHKRP",
"____________________",
"____________________",
"________CSTYNQDEHKR_",
"GAVILMFW___________P"]
self.descriptorsTable = PM_TableWidget( pmGroupBox)
self.descriptorsTable.setFixedHeight(100)
self.descriptorsTable.setRowCount(len(self.set_names))
self.descriptorsTable.setColumnCount(2)
self.descriptorsTable.verticalHeader().setVisible(False)
self.descriptorsTable.horizontalHeader().setVisible(False)
for index in range(len(self.set_names)):
item_widget = QTableWidgetItem(self.set_names[index])
item_widget.setFont(self.labelfont)
item_widget.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable)
item_widget.setTextAlignment(Qt.AlignCenter)
self.descriptorsTable.setItem(index, 0, item_widget)
item_widget = QTableWidgetItem(self.descriptor_list[index])
item_widget.setFont(self.descriptorfont)
item_widget.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable)
item_widget.setTextAlignment(Qt.AlignCenter)
self.descriptorsTable.setItem(index, 1, item_widget)
self.descriptorsTable.setRowHeight(index, 16)
pass
self.descriptorsTable.resizeColumnsToContents()
self.applyDescriptorPushButton = PM_PushButton( pmGroupBox,
text = "Apply",
setAsDefault = True)
self.selectAllPushButton = PM_PushButton( pmGroupBox,
text = "All",
setAsDefault = True)
self.selectNonePushButton = PM_PushButton( pmGroupBox,
text = "None",
setAsDefault = True)
self.selectInvertPushButton = PM_PushButton( pmGroupBox,
text = "Invert",
setAsDefault = True)
self.win.connect(self.applyDescriptorPushButton,
SIGNAL("clicked()"),
self._applyDescriptor)
self.win.connect(self.selectAllPushButton,
SIGNAL("clicked()"),
self._selectAll)
self.win.connect(self.selectNonePushButton,
SIGNAL("clicked()"),
self._selectNone)
self.win.connect(self.selectInvertPushButton,
SIGNAL("clicked()"),
self._invertSelection)
buttonList = [('PM_PushButton', self.applyDescriptorPushButton, 0, 0),
('QSpacerItem', 5, 5, 1, 0),
('PM_PushButton', self.selectAllPushButton, 2, 0),
('PM_PushButton', self.selectNonePushButton, 3, 0),
('PM_PushButton', self.selectInvertPushButton, 4, 0)]
self.buttonGrid = PM_WidgetGrid( pmGroupBox,
widgetList = buttonList)
self.recenterViewCheckBox = \
PM_CheckBox( pmGroupBox,
text = "Re-center view",
setAsDefault = True,
state = Qt.Checked)
self.sequenceTable = PM_TableWidget( pmGroupBox)
#self.sequenceTable.setModel(self.tableModel)
self.sequenceTable.resizeColumnsToContents()
self.sequenceTable.verticalHeader().setVisible(False)
#self.sequenceTable.setRowCount(0)
self.sequenceTable.setColumnCount(4)
self.checkbox = QCheckBox()
self.sequenceTable.setFixedHeight(345)
self.sequenceTable.setHorizontalHeaderLabels(self.headerdata)
###self._fillSequenceTable()
def _fillSequenceTable(self):
"""
"""
self.setComboBox = QComboBox()
for chunk in self.win.assy.molecules:
if chunk.isProteinChunk():
aa_list = chunk.protein.get_amino_acids()
aa_list_len = len(aa_list)
self.sequenceTable.setRowCount(aa_list_len)
for index in range(aa_list_len):
item_widget = QTableWidgetItem("")
item_widget.setFont(self.labelfont)
item_widget.setCheckState(Qt.Checked)
item_widget.setTextAlignment(Qt.AlignLeft)
item_widget.setSizeHint(QSize(20,12))
item_widget.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsUserCheckable)
self.sequenceTable.setItem(index, 0, item_widget)
item_widget = QTableWidgetItem(str(index+1))
item_widget.setFont(self.labelfont)
item_widget.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_widget.setTextAlignment(Qt.AlignCenter)
self.sequenceTable.setItem(index, 1, item_widget)
item_widget = QTableWidgetItem("Any")
item_widget.setFont(self.labelfont)
item_widget.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_widget.setTextAlignment(Qt.AlignCenter)
self.sequenceTable.setItem(index, 2, item_widget)
aa_string = self._get_mutation_descriptor(
self._get_aa_for_index(index))
item_widget = QTableWidgetItem(aa_string)
item_widget.setFont(self.descriptorfont)
self.sequenceTable.setItem(index, 3, item_widget)
self.sequenceTable.setRowHeight(index, 16)
self.win.connect(self.sequenceTable,
SIGNAL("cellClicked(int, int)"),
self._sequenceTableCellChanged)
self.sequenceTable.resizeColumnsToContents()
self.sequenceTable.setColumnWidth(0, 35)
self.sequenceTable.setColumnWidth(2, 80)
def _selectAll(self):
for row in range(self.sequenceTable.rowCount()):
self.sequenceTable.item(row, 0).setCheckState(Qt.Checked)
def _selectNone(self):
for row in range(self.sequenceTable.rowCount()):
self.sequenceTable.item(row, 0).setCheckState(Qt.Unchecked)
def _invertSelection(self):
for row in range(self.sequenceTable.rowCount()):
item_widget = self.sequenceTable.item(row, 0)
if item_widget.checkState() == Qt.Checked:
item_widget.setCheckState(Qt.Unchecked)
else:
item_widget.setCheckState(Qt.Checked)
def _get_mutation_descriptor(self, aa):
"""
"""
aa_string = "GAVILMFWCSTYNQDEHKRP"
range = aa.get_mutation_range()
if range == "NATRO" or \
range == "NATAA":
code = aa.get_one_letter_code()
aa_string = re.sub("[^"+code+"]",'_', aa_string)
elif range == "POLAR":
aa_string = "________CSTYNQDEHKR_"
elif range == "APOLA":
aa_string = "GAVILMFW___________P"
return aa_string
def _get_aa_for_index(self, index, expand=False):
"""
"""
# Center on a selected amino acid.
for chunk in self.win.assy.molecules:
if chunk.isProteinChunk():
chunk.protein.set_current_amino_acid_index(index)
current_aa = chunk.protein.get_current_amino_acid()
if expand:
chunk.protein.collapse_all_rotamers()
chunk.protein.expand_rotamer(current_aa)
return current_aa
return None
def _sequenceTableCellChanged(self, crow, ccol):
#print "CELL CHANGED: ", (crow, ccol)
item = self.sequenceTable.item(crow, ccol)
#print "ITEM = ", item
for row in range(self.sequenceTable.rowCount()):
self.sequenceTable.removeCellWidget(row, 2)
self.sequenceTable.setRowHeight(row, 16)
if ccol == 2:
# Make the row a little bit wider.
self.sequenceTable.setRowHeight(crow, 22)
# Create and insert a Combo Box into a current cell.
self.setComboBox = QComboBox()
self.setComboBox.addItems(self.set_names)
self.win.connect(self.setComboBox,
SIGNAL("currentIndexChanged(int)"),
self._setComboBoxIndexChanged)
self.sequenceTable.setCellWidget(crow, 2, self.setComboBox)
current_aa = self._get_aa_for_index(crow, expand=True)
if current_aa:
# Center on the selected amino acid.
if self.recenterViewCheckBox.isChecked():
ca_atom = current_aa.get_c_alpha_atom()
if ca_atom:
self.win.glpane.pov = -ca_atom.posn()
self.win.glpane.gl_update()
def _applyDescriptor(self):
"""
"""
cdes = self.descriptorsTable.currentRow()
for row in range(self.sequenceTable.rowCount()):
#print "row = ", row
self._setComboBoxIndexChanged(cdes, tablerow = row, selectedOnly = True)
def _setComboBoxIndexChanged( self, index, tablerow = None, selectedOnly = False):
"""
"""
#print "INDEX = ", index
if tablerow is None:
crow = self.sequenceTable.currentRow()
else:
crow = tablerow
#print "current row: ", crow
item = self.sequenceTable.item(crow, 2)
if item:
cbox = self.sequenceTable.item(crow, 0)
if not selectedOnly or \
cbox.checkState() == Qt.Checked:
item.setText(self.set_names[index])
item = self.sequenceTable.item(crow, 3)
aa = self._get_aa_for_index(crow)
aa.set_mutation_range(self.rosetta_set_names[index])
item.setText(self._get_mutation_descriptor(aa))
###self._write_resfile()
def _write_resfile(self):
from protein.model.Protein import write_rosetta_resfile
for chunk in self.win.assy.molecules:
if chunk.isProteinChunk():
write_rosetta_resfile("/Users/piotr/test.resfile", chunk)
return
def _addWhatsThisText( self ):
#from ne1_ui.WhatsThisText_for_PropertyManagers import WhatsThis_EditResidues_PropertyManager
#WhatsThis_EditResidues_PropertyManager(self)
pass
def _addToolTipText(self):
#from ne1_ui.ToolTipText_for_PropertyManagers import ToolTip_EditProteinDisplayStyle_PropertyManager
#ToolTip_EditProteinDisplayStyle_PropertyManager(self)
pass
def scrollToPosition(self, index):
"""
Scrolls the Sequence Table to a given sequence position.
"""
item = self.sequenceTable.item(index, 0)
if item:
self.sequenceTable.scrollToItem(item)
