def __init__(self, parent=None, mm=None):
SizePersistedDialog.__init__(self, parent, 'casanova plugin:search dialog')
self.setWindowTitle('Search Casanova:')
self.gui = parent
self.mm = mm
layout = QVBoxLayout(self)
self.setLayout(layout)
self.search_label = QLabel('Search for:')
layout.addWidget(self.search_label)
self.search_str = QLineEdit(self)
self.search_str.setText('')
layout.addWidget(self.search_str)
self.search_label.setBuddy(self.search_str)
self.find_button = QPushButton("&Find")
self.search_button_box = QDialogButtonBox(Qt.Horizontal)
self.search_button_box.addButton(self.find_button, QDialogButtonBox.ActionRole)
self.search_button_box.clicked.connect(self._find_clicked)
layout.addWidget(self.search_button_box)
self.values_list = QListWidget(self)
self.values_list.setSelectionMode(QAbstractItemView.ExtendedSelection)
layout.addWidget(self.values_list)
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_box.accepted.connect(self._accept_clicked)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
# Cause our dialog size to be restored from prefs or created on first usage
self.resize_dialog()
class HelpView(SizePersistedDialog):
"""
Modeless dialog for presenting HTML help content
"""
def __init__(self, parent, icon, prefs, html=None, page=None, title=""):
self.prefs = prefs
# QDialog.__init__(self, parent=parent)
super(HelpView, self).__init__(parent, "help_dialog")
self.setWindowTitle(title)
self.setWindowIcon(icon)
self.l = QVBoxLayout(self)
self.setLayout(self.l)
self.wv = QWebView()
if html is not None:
self.wv.setHtml(html)
elif page is not None:
self.wv.load(QUrl(page))
self.wv.setMinimumHeight(100)
self.wv.setMaximumHeight(16777215)
self.wv.setMinimumWidth(400)
self.wv.setMaximumWidth(16777215)
self.wv.setGeometry(0, 0, 400, 100)
self.wv.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.l.addWidget(self.wv)
# Sizing
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(sizePolicy)
self.resize_dialog()
def _init_controls(self):
layout = QVBoxLayout(self)
self.setLayout(layout)
ml = QHBoxLayout()
layout.addLayout(ml, 1)
self.keys_list = QListWidget(self)
self.keys_list.setSelectionMode(QAbstractItemView.SingleSelection)
self.keys_list.setFixedWidth(150)
self.keys_list.setAlternatingRowColors(True)
ml.addWidget(self.keys_list)
self.value_text = QTextEdit(self)
self.value_text.setTabStopWidth(24)
self.value_text.setReadOnly(False)
ml.addWidget(self.value_text, 1)
button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
button_box.accepted.connect(self._apply_changes)
button_box.rejected.connect(self.reject)
self.clear_button = button_box.addButton('Clear', QDialogButtonBox.ResetRole)
self.clear_button.setIcon(get_icon('trash.png'))
self.clear_button.setToolTip('Clear all settings for this plugin')
self.clear_button.clicked.connect(self._clear_settings)
layout.addWidget(button_box)
class BlockingBusy(QDialog):
def __init__(self, msg, parent=None, window_title=_('Working')):
QDialog.__init__(self, parent)
self._layout = QVBoxLayout()
self.setLayout(self._layout)
self.msg = QLabel(msg)
#self.msg.setWordWrap(True)
self.font = QFont()
self.font.setPointSize(self.font.pointSize() + 8)
self.msg.setFont(self.font)
self.pi = ProgressIndicator(self)
self.pi.setDisplaySize(100)
self._layout.addWidget(self.pi, 0, Qt.AlignHCenter)
self._layout.addSpacing(15)
self._layout.addWidget(self.msg, 0, Qt.AlignHCenter)
self.start()
self.setWindowTitle(window_title)
self.resize(self.sizeHint())
def start(self):
self.pi.startAnimation()
def stop(self):
self.pi.stopAnimation()
def accept(self):
self.stop()
return QDialog.accept(self)
def reject(self):
pass # Cannot cancel this dialog
class Comments(Base):
def setup_ui(self, parent):
self._box = QGroupBox(parent)
self._box.setTitle('&'+self.col_metadata['name'])
self._layout = QVBoxLayout()
self._tb = CommentsEditor(self._box)
self._tb.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
# self._tb.setTabChangesFocus(True)
self._layout.addWidget(self._tb)
self._box.setLayout(self._layout)
self.widgets = [self._box]
def setter(self, val):
if not val or not val.strip():
val = ''
else:
val = comments_to_html(val)
self._tb.html = val
self._tb.wyswyg_dirtied()
def getter(self):
val = unicode(self._tb.html).strip()
if not val:
val = None
return val
def __init__(self, parent):
super(CharacterDialog, self).__init__(parent)
self.setWindowTitle(_("KeepKey Seed Recovery"))
self.character_pos = 0
self.word_pos = 0
self.loop = QEventLoop()
self.word_help = QLabel()
self.char_buttons = []
vbox = QVBoxLayout(self)
vbox.addWidget(WWLabel(CHARACTER_RECOVERY))
hbox = QHBoxLayout()
hbox.addWidget(self.word_help)
for i in range(4):
char_button = CharacterButton('*')
char_button.setMaximumWidth(36)
self.char_buttons.append(char_button)
hbox.addWidget(char_button)
self.accept_button = CharacterButton(_("Accept Word"))
self.accept_button.clicked.connect(partial(self.process_key, 32))
self.rejected.connect(partial(self.loop.exit, 1))
hbox.addWidget(self.accept_button)
hbox.addStretch(1)
vbox.addLayout(hbox)
self.finished_button = QPushButton(_("Seed Entered"))
self.cancel_button = QPushButton(_("Cancel"))
self.finished_button.clicked.connect(partial(self.process_key,
Qt.Key_Return))
self.cancel_button.clicked.connect(self.rejected)
buttons = Buttons(self.finished_button, self.cancel_button)
vbox.addSpacing(40)
vbox.addLayout(buttons)
self.refresh()
self.show()
def message_dialog(self, msg):
self.clear_dialog()
self.dialog = dialog = WindowModalDialog(self.top_level_window(), _("Ledger Status"))
l = QLabel(msg)
vbox = QVBoxLayout(dialog)
vbox.addWidget(l)
dialog.show()
def __init__(self):
QGroupBox.__init__(self)
self.treemodel = treemodel = TestNe1Model()
self.view = view = ModelTree("Model tree", treemodel, self)
view.mt_update()
def thunk(str):
def _thunk(str=str):
print str
return _thunk
self.chunkNum = 2
self.gbox = QGroupBox()
vl = QVBoxLayout(self)
vl.setSpacing(0)
vl.setMargin(0)
vl.addWidget(self.view)
self.buttonLayout = hl = QHBoxLayout()
hl.setSpacing(0)
hl.setMargin(0)
vl.addLayout(hl)
self.buttonNum = 1
for func in (self.addmol, self.addjig, self.selected):
self.addButton(func)
class DebugDevice(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self._layout = QVBoxLayout(self)
self.setLayout(self._layout)
self.log = QPlainTextEdit(self)
self._layout.addWidget(self.log)
self.log.setPlainText(_('Getting debug information')+'...')
self.copy = QPushButton(_('Copy to &clipboard'))
self.copy.setDefault(True)
self.setWindowTitle(_('Debug device detection'))
self.setWindowIcon(QIcon(I('debug.png')))
self.copy.clicked.connect(self.copy_to_clipboard)
self.ok = QPushButton('&OK')
self.ok.setAutoDefault(False)
self.ok.clicked.connect(self.accept)
self.bbox = QDialogButtonBox(self)
self.bbox.addButton(self.copy, QDialogButtonBox.ActionRole)
self.bbox.addButton(self.ok, QDialogButtonBox.AcceptRole)
self._layout.addWidget(self.bbox)
self.resize(750, 500)
self.bbox.setEnabled(False)
QTimer.singleShot(1000, self.debug)
def debug(self):
try:
from calibre.devices import debug
raw = debug()
self.log.setPlainText(raw)
finally:
self.bbox.setEnabled(True)
def copy_to_clipboard(self):
QApplication.clipboard().setText(self.log.toPlainText())
def __init__(self, parent = None, name = None, modal = 1, fl = 0):
#QDialog.__init__(self,parent,name,modal,fl)
QDialog.__init__(self,parent)
self.setModal(modal)
qt4todo("handle flags in TextMessageBox.__init__")
if name is None: name = "TextMessageBox"
self.setObjectName(name)
self.setWindowTitle(name)
TextMessageLayout = QVBoxLayout(self)
TextMessageLayout.setMargin(5)
TextMessageLayout.setSpacing(1)
self.text_edit = QTextEdit(self)
TextMessageLayout.addWidget(self.text_edit)
self.close_button = QPushButton(self)
self.close_button.setText("Close")
TextMessageLayout.addWidget(self.close_button)
self.resize(QSize(350, 300).expandedTo(self.minimumSizeHint()))
# Width changed from 300 to 350. Now hscrollbar doesn't appear in
# Help > Graphics Info textbox. mark 060322
qt4todo('self.clearWState(Qt.WState_Polished)') # what is this?
self.connect(self.close_button, SIGNAL("clicked()"),self.close)
def set_viewer_group(self):
''' 1. Load Items from viewer factory '''
view_fact = ViewerPluginFactory()
self.viewer_stack = QtGui.QStackedWidget()
self.viewer_cbox = self.builder.combobox(self.groupb_viewer, [], self.set_cb_changed_event_view)
self.set_start_button = self.builder.pushbutton(self.groupb_viewer, 'Start Simulation', self.create_aut_env)
self.set_start_button.setFixedWidth(200)
self.set_start_button.setFixedHeight(25)
for viewer_plugin in view_fact.createable_objects():
view = view_fact.make(viewer_plugin)
if view != None:
view.set_monitor(self.monitor)
self.viewer_stack.addWidget(view.get_widget(self))
self.viewer_cbox.addItem(view.get_combobox_name())
''' layout '''
v_layout = QVBoxLayout()
self.viewer_cbox.setFixedHeight(25)
v_layout.addWidget(self.viewer_stack)
hl = QHBoxLayout()
hl.addWidget(self.viewer_cbox)
hl.addWidget(self.set_start_button)
v_layout.addLayout(hl)
self.groupb_viewer.setLayout(v_layout)
def __init__(self, parent, modal=True, flags=Qt.WindowFlags(), caption="Select Tags", ok_button="Select"):
QDialog.__init__(self, parent, flags)
self.setModal(modal)
self.setWindowTitle(caption)
lo = QVBoxLayout(self)
lo.setMargin(10)
lo.setSpacing(5)
# tag selector
self.wtagsel = QListWidget(self)
lo.addWidget(self.wtagsel)
# self.wtagsel.setColumnMode(QListBox.FitToWidth)
self.wtagsel.setSelectionMode(QListWidget.MultiSelection)
QObject.connect(self.wtagsel, SIGNAL("itemSelectionChanged()"), self._check_tag)
# buttons
lo.addSpacing(10)
lo2 = QHBoxLayout()
lo.addLayout(lo2)
lo2.setContentsMargins(0, 0, 0, 0)
lo2.setMargin(5)
self.wokbtn = QPushButton(ok_button, 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)
self._tagnames = []
def __init__(self, parent=None, mm=None, mi = None):
SizePersistedDialog.__init__(self, parent, 'casanova plugin:add book dialog')
self.setWindowTitle('Add text to Casanova:')
self.gui = parent
self.mm = mm
self.mi = mi
self.one_line_description = ''
layout = QVBoxLayout(self)
self.setLayout(layout)
self.one_liner_label = QLabel('Enter a short description (255 chars max) before pressing OK')
layout.addWidget(self.one_liner_label)
self.one_liner_str = QLineEdit(self)
self.one_liner_str.setText('')
layout.addWidget(self.one_liner_str)
self.one_liner_label.setBuddy(self.one_liner_str)
self.values_label = QLabel('Below are potential matches of texts that already exist - please make sure you are adding something new')
layout.addWidget(self.values_label)
self.values_list = QListWidget(self)
self.values_list.setSelectionMode(QAbstractItemView.ExtendedSelection)
layout.addWidget(self.values_list)
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_box.accepted.connect(self._accept_clicked)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self._display_choices()
# Cause our dialog size to be restored from prefs or created on first usage
self.resize_dialog()
def show_config_widget(category, name, gui=None, show_restart_msg=False,
parent=None, never_shutdown=False):
'''
Show the preferences plugin identified by category and name
:param gui: gui instance, if None a hidden gui is created
:param show_restart_msg: If True and the preferences plugin indicates a
restart is required, show a message box telling the user to restart
:param parent: The parent of the displayed dialog
:return: True iff a restart is required for the changes made by the user to
take effect
'''
from calibre.gui2 import gprefs
pl = get_plugin(category, name)
d = ConfigDialog(parent)
d.resize(750, 550)
conf_name = 'config_widget_dialog_geometry_%s_%s'%(category, name)
geom = gprefs.get(conf_name, None)
d.setWindowTitle(_('Configure ') + name)
d.setWindowIcon(QIcon(I('config.png')))
bb = QDialogButtonBox(d)
bb.setStandardButtons(bb.Apply|bb.Cancel|bb.RestoreDefaults)
bb.accepted.connect(d.accept)
bb.rejected.connect(d.reject)
w = pl.create_widget(d)
d.set_widget(w)
bb.button(bb.RestoreDefaults).clicked.connect(w.restore_defaults)
bb.button(bb.RestoreDefaults).setEnabled(w.supports_restoring_to_defaults)
bb.button(bb.Apply).setEnabled(False)
bb.button(bb.Apply).clicked.connect(d.accept)
def onchange():
b = bb.button(bb.Apply)
b.setEnabled(True)
b.setDefault(True)
b.setAutoDefault(True)
w.changed_signal.connect(onchange)
bb.button(bb.Cancel).setFocus(True)
l = QVBoxLayout()
d.setLayout(l)
l.addWidget(w)
l.addWidget(bb)
mygui = gui is None
if gui is None:
gui = init_gui()
mygui = True
w.genesis(gui)
w.initialize()
if geom is not None:
d.restoreGeometry(geom)
d.exec_()
geom = bytearray(d.saveGeometry())
gprefs[conf_name] = geom
rr = getattr(d, 'restart_required', False)
if show_restart_msg and rr:
from calibre.gui2 import warning_dialog
warning_dialog(gui, 'Restart required', 'Restart required', show=True)
if mygui and not never_shutdown:
gui.shutdown()
return rr
class CapturePhotoCover(QDialog):
def __init__(self, gui, icon, do_user_config, qaction, us):
QDialog.__init__(self, gui)
self.main_gui = gui
self.do_user_config = do_user_config
self.qaction = qaction
self.us = us
#- main UI layout -----------------------------------------------------
self.ll = QVBoxLayout()
self.l = QHBoxLayout()
self.l.setSpacing(0)
#self.l.setMargin(0) # not in Qt5
self.w = QWidget()
self.w.setLayout(self.l)
self.setLayout(self.ll)
self.setWindowIcon(icon)
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
#- webkit -------------------------------------------------------------
self.webview = QWebView()
self.webview.setMaximumWidth(680)
self.webview.setMaximumHeight(320)
self.webview.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
# self.webview.load(QUrl.fromLocalFile(
# os.path.join(self.us.portable_directory,
# "portable/kaliweb.html")))
self.loadUrl()
self.webview.page().networkAccessManager().sslErrors.connect(self.sslErrorHandler)
#self.connect(self.webview.page().networkAccessManager(),
# SIGNAL("sslErrors (QNetworkReply *, \
# const QList<QSslError> &)"),
# self.sslErrorHandler)
logger.info("KALIWEB PATH: {}".format(
os.path.join(self.us.portable_directory,
"portable/kaliweb.html")))
self.ll.addWidget(self.webview)
def loadUrl(self):
if self.us.initial:
self.webview.page().mainFrame().load(QUrl("https://google.com"))
self.us.initial = False
def keyPressEvent(self, event):
if event.key() == Qt.Key_Escape:
pass
def sslErrorHandler(self, reply, errorList):
reply.ignoreSslErrors()
logger.debug("SSL ERRORS: {}".format(errorList))
return
def closeEvent(self, e):
self.hide()
def message_dialog(self):
self.d = QDialog()
self.d.setModal(1)
self.d.setWindowTitle("Please Check Trezor Device")
self.d.setWindowFlags(self.d.windowFlags() | QtCore.Qt.WindowStaysOnTopHint)
l = QLabel(self.message)
vbox = QVBoxLayout(self.d)
vbox.addWidget(l)
self.d.show()
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 _create_widgets(self, parent):
# Layout
GBuilder().set_props(self, None, 100, 100)
main_lo = QVBoxLayout()
self.setLayout(main_lo)
# Title
main_lo.addWidget(GBuilder().label(parent, "<b>Description:</b>"))
hl = QHBoxLayout()
self.desc_label = GBuilder().label(parent, "Add a new SecureECU. This ECU resembles the ECU Part in a Lightweight Authentication Mechanism.")
self.desc_label.setFixedWidth(400)
self.icon = GBuilder().image(parent, SecLwAuthSecurityModuleAddWidget.GUI_ICON, 2)
hl.addWidget(self.desc_label)
hl.addWidget(self.icon)
main_lo.addLayout(hl)
line = GBuilder().hor_line(parent)
main_lo.addWidget(line);
# Constructor Inputs
main_lo.addWidget(GBuilder().label(parent, "<b>General Information:</b>"))
lo0, self.id_list = GBuilder().label_text(parent, "List of IDs (optional):", label_width=120)
lo1, self.send_buf_textedit = GBuilder().label_text(parent, "Sending BufferSize:", label_width=120)
lo2, self.rec_buf_textedit = GBuilder().label_text(parent, "Receiving Buffer Size:", label_width=120)
lo3, self.nr_ecus_textedit = GBuilder().label_text(parent, "Number of ECUs:", label_width=120)
main_lo.addLayout(lo0)
main_lo.addLayout(lo1)
main_lo.addLayout(lo2)
main_lo.addLayout(lo3)
# ECU Settings
items = self._get_ecu_settings()
hl, self.ecu_set_cb, self.ecu_set_te = GBuilder().combobox_text(parent, items, self._set_cb_changed)
self._cur_set_entry = self.ecu_set_cb.currentText()
main_lo.addLayout(hl)
# Timing Mapping
line = GBuilder().hor_line(parent)
main_lo.addWidget(line)
lab = GBuilder().label(parent, "<b>Timing and Certification:</b>")
lab.setFixedHeight(20)
main_lo.addWidget(lab)
itm = StdSecurLwSecModTimingFunctions()
avail_items = itm.available_tags
items = itm.function_map.keys()
hl1 = QHBoxLayout()
self.ecu_set_time_cb = GBuilder().combobox(parent, items, self._set_time_cb_changed)
self._cur_set_time_entry = self.ecu_set_time_cb.currentText()
self.ecu_set_time_sel_cb = GBuilder().combobox(parent, avail_items, self._set_time_cb_changed)
self._cur_set_time_sel_entry = self.ecu_set_time_sel_cb.currentText()
hl1.addWidget(self.ecu_set_time_cb)
hl1.addWidget(self.ecu_set_time_sel_cb)
main_lo.addLayout(hl1)
class Dialog(QDialog):
def __init__(self, title, widget=None, closeButton=True, keySequence=None, isDialog=False, icon=None):
QDialog.__init__(self, ctx.mainScreen)
self.setObjectName("dialog")
self.isDialog = isDialog
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self.wlayout= QHBoxLayout()
if icon:
self.setStyleSheet("""QDialog QLabel{ margin-left:16px;margin-right:10px}
QDialog#dialog {background-image:url(':/images/%s.png');
background-repeat:no-repeat;
background-position: top left; padding-left:500px;} """ % icon)
self.windowTitle = windowTitle(self, closeButton)
self.setTitle(title)
self.layout.setMargin(0)
self.layout.addWidget(self.windowTitle)
if widget:
self.addWidget(widget)
QObject.connect(widget, SIGNAL("finished(int)"), self.reject)
QObject.connect(widget, SIGNAL("resizeDialog(int,int)"), self.resize)
if closeButton:
QObject.connect(self.windowTitle.pushButton, SIGNAL("clicked()"), self.reject)
if keySequence:
shortCut = QShortcut(keySequence, self)
QObject.connect(shortCut, SIGNAL("activated()"), self.reject)
QMetaObject.connectSlotsByName(self)
self.resize(10,10)
def setTitle(self, title):
self.windowTitle.label.setText(title)
def addWidget(self, widget):
self.content = widget
self.wlayout.addWidget(self.content)
if self.isDialog:
widget.setStyleSheet("QMessageBox { background:none }")
self.layout.addItem(QSpacerItem(10, 10, QSizePolicy.Fixed, QSizePolicy.MinimumExpanding))
self.layout.setContentsMargins(0, 0, 0, 8)
self.layout.addLayout(self.wlayout)
def setCentered(self):
self.move(ctx.mainScreen.width()/2 - self.width()/2,
ctx.mainScreen.height()/2 - self.height()/2)
def exec_(self):
QTimer.singleShot(0, self.setCentered)
return QDialog.exec_(self)
def add_checkbuttons(self, table, row, col):
wid = QWidget()
lo = QVBoxLayout()
wid.setLayout(lo)
cb = QCheckBox()
lo.addWidget(cb)
wid.setFixedHeight(32)
table.setCellWidget(row, col, wid)
return cb
def message_dialog(self, msg, on_cancel):
# Called more than once during signing, to confirm output and fee
self.clear_dialog()
title = _('Please check your %s device') % self.device
self.dialog = dialog = WindowModalDialog(self.top_level_window(), title)
l = QLabel(msg)
vbox = QVBoxLayout(dialog)
vbox.addWidget(l)
if on_cancel:
dialog.rejected.connect(on_cancel)
vbox.addLayout(Buttons(CancelButton(dialog)))
dialog.show()
def start(self, message):
self.d = QDialog()
self.d.setModal(1)
self.d.setWindowTitle('Please Check Trezor Device')
self.d.setWindowFlags(self.d.windowFlags() | QtCore.Qt.WindowStaysOnTopHint)
l = QLabel(message)
vbox = QVBoxLayout(self.d)
vbox.addWidget(l)
self.d.show()
if not self.waiting:
self.waiting = True
self.d.connect(twd, SIGNAL('trezor_done'), self.stop)
def __init__(self, dataframe, parent=None):
super(MainForm, self).__init__(parent)
tableLabel = QLabel("Table &1")
self.tableView = IPETDataTableView(dataframe, self)
tableLabel.setBuddy(self.tableView)
layout = QVBoxLayout()
layout.addWidget(tableLabel)
layout.addWidget(self.tableView)
self.setLayout(layout)
self.tableView.resizeColumns()
def message_dialog(self, msg, on_cancel):
# Called more than once during signing, to confirm output and fee
self.clear_dialog()
title = _('Please check your %s device') % self.device
self.dialog = dialog = WindowModalDialog(self.top_level_window(), title)
l = QLabel(msg)
vbox = QVBoxLayout(dialog)
vbox.addWidget(l)
if on_cancel:
dialog.rejected.connect(on_cancel)
vbox.addLayout(Buttons(CancelButton(dialog)))
dialog.show()
def __init__(self, parent):
QWidget.__init__(self, parent)
l = QVBoxLayout()
self.setLayout(l)
l.addStretch(10)
self.pi = ProgressIndicator(self, 128)
l.addWidget(self.pi, alignment=Qt.AlignHCenter)
self.dummy = QLabel('<h2>\xa0')
l.addSpacing(10)
l.addWidget(self.dummy, alignment=Qt.AlignHCenter)
l.addStretch(10)
self.text = _('Calculating differences, please wait...')
def message_dialog(self, msg, cancel_callback):
# Called more than once during signing, to confirm output and fee
self.clear_dialog()
title = _('Please check your %s device') % self.device
self.dialog = dialog = WindowModalDialog(self.window_stack[-1], title)
l = QLabel(msg)
vbox = QVBoxLayout(dialog)
if cancel_callback:
vbox.addLayout(Buttons(CancelButton(dialog)))
dialog.connect(dialog, SIGNAL('rejected()'), cancel_callback)
vbox.addWidget(l)
dialog.show()
def pin_dialog(self, msg):
# Needed e.g. when renaming label and haven't entered PIN
dialog = WindowModalDialog(self.window_stack[-1], _("Enter PIN"))
matrix = self.pin_matrix_widget_class()
vbox = QVBoxLayout()
vbox.addWidget(QLabel(msg))
vbox.addWidget(matrix)
vbox.addLayout(Buttons(CancelButton(dialog), OkButton(dialog)))
dialog.setLayout(vbox)
dialog.exec_()
self.response = str(matrix.get_value())
self.done.set()
def start(self, message):
self.d = QDialog()
self.d.setModal(1)
self.d.setWindowTitle("Please Wait")
self.d.setWindowFlags(self.d.windowFlags() | QtCore.Qt.WindowStaysOnTopHint)
l = QLabel(message)
vbox = QVBoxLayout(self.d)
vbox.addWidget(l)
self.d.show()
if not self.waiting:
self.waiting = True
self.d.connect(waitDialog, SIGNAL("dongle_done"), self.stop)
def __init__(self, parent):
QWidget.__init__(self, parent)
l = QVBoxLayout()
self.setLayout(l)
l.addStretch(10)
self.pi = ProgressIndicator(self, 128)
l.addWidget(self.pi, alignment=Qt.AlignHCenter)
self.dummy = QLabel('<h2>\xa0')
l.addSpacing(10)
l.addWidget(self.dummy, alignment=Qt.AlignHCenter)
l.addStretch(10)
self.text = _('Calculating differences, please wait...')
def start(self, message):
self.d = QDialog()
self.d.setModal(1)
self.d.setWindowTitle('Please Wait')
self.d.setWindowFlags(self.d.windowFlags() | QtCore.Qt.WindowStaysOnTopHint)
l = QLabel(message)
vbox = QVBoxLayout(self.d)
vbox.addWidget(l)
self.d.show()
if not self.waiting:
self.waiting = True
self.d.connect(waitDialog, SIGNAL('dongle_done'), self.stop)
def setup_ui(self):
self.l = l = QVBoxLayout(self)
self.h = h = QHBoxLayout()
l.addLayout(h)
l.addWidget(self.bb)
self.bb.clear(), self.bb.addButton(self.bb.Close)
b = self.bb.addButton(_('&New dictionary'), self.bb.ActionRole)
b.setIcon(QIcon(I('spell-check.png')))
b.clicked.connect(self.new_dictionary)
self.dictionaries = d = QListWidget(self)
self.emph_font = f = QFont(self.font())
f.setBold(True)
self.build_dictionaries()
d.currentItemChanged.connect(self.show_current_dictionary)
h.addWidget(d)
l = QVBoxLayout()
h.addLayout(l)
h = QHBoxLayout()
self.remove_button = b = QPushButton(QIcon(I('trash.png')), _('&Remove dictionary'), self)
b.clicked.connect(self.remove_dictionary)
h.addWidget(b)
self.rename_button = b = QPushButton(QIcon(I('modified.png')), _('Re&name dictionary'), self)
b.clicked.connect(self.rename_dictionary)
h.addWidget(b)
self.dlabel = la = QLabel('')
l.addWidget(la)
l.addLayout(h)
self.is_active = a = QCheckBox(_('Mark this dictionary as active'))
self.is_active.stateChanged.connect(self.active_toggled)
l.addWidget(a)
self.la = la = QLabel(_('Words in this dictionary:'))
l.addWidget(la)
self.words = w = QListWidget(self)
w.setSelectionMode(w.ExtendedSelection)
l.addWidget(w)
self.add_word_button = b = QPushButton(_('&Add word'), self)
b.clicked.connect(self.add_word)
b.setIcon(QIcon(I('plus.png')))
l.h = h = QHBoxLayout()
l.addLayout(h)
h.addWidget(b)
self.remove_word_button = b = QPushButton(_('&Remove selected words'), self)
b.clicked.connect(self.remove_word)
b.setIcon(QIcon(I('minus.png')))
h.addWidget(b)
self.import_words_button = b = QPushButton(_('&Import list of words'), self)
b.clicked.connect(self.import_words)
l.addWidget(b)
self.show_current_dictionary()
class DBCheck(QDialog): # {{{
update_msg = pyqtSignal(object)
def __init__(self, parent, db):
QDialog.__init__(self, parent)
self.l = QVBoxLayout()
self.setLayout(self.l)
self.l1 = QLabel(
_('Vacuuming database to improve performance.') + ' ' +
_('This will take a while, please wait...'))
self.setWindowTitle(_('Vacuuming...'))
self.l1.setWordWrap(True)
self.l.addWidget(self.l1)
self.msg = QLabel('')
self.update_msg.connect(self.msg.setText, type=Qt.QueuedConnection)
self.l.addWidget(self.msg)
self.msg.setWordWrap(True)
self.resize(self.sizeHint() + QSize(100, 50))
self.error = None
self.db = db.new_api
self.closed_orig_conn = False
self.rejected = False
def start(self):
t = self.thread = Thread(target=self.vacuum)
t.daemon = True
t.start()
QTimer.singleShot(100, self.check)
self.exec_()
def vacuum(self):
try:
self.db.vacuum()
except Exception as e:
import traceback
self.error = (as_unicode(e), traceback.format_exc())
def reject(self):
self.rejected = True
return QDialog.reject(self)
def check(self):
if self.rejected:
return
if self.thread.is_alive():
QTimer.singleShot(100, self.check)
else:
self.accept()
def break_cycles(self):
self.db = self.thread = None
def pin_dialog(self, msg):
# Needed e.g. when resetting a device
self.clear_dialog()
dialog = WindowModalDialog(self.top_level_window(), _("Enter PIN"))
matrix = self.pin_matrix_widget_class()
vbox = QVBoxLayout()
vbox.addWidget(QLabel(msg))
vbox.addWidget(matrix)
vbox.addLayout(Buttons(CancelButton(dialog), OkButton(dialog)))
dialog.setLayout(vbox)
dialog.exec_()
self.response = str(matrix.get_value())
self.done.set()
def message_dialog(self, msg, cancel_callback):
# Called more than once during signing, to confirm output and fee
self.clear_dialog()
title = _('Please check your %s device') % self.device
self.dialog = dialog = WindowModalDialog(self.window_stack[-1], title)
self.window_stack.append(dialog)
l = QLabel(msg)
vbox = QVBoxLayout(dialog)
if cancel_callback:
vbox.addLayout(Buttons(CancelButton(dialog)))
dialog.connect(dialog, SIGNAL('rejected()'), cancel_callback)
vbox.addWidget(l)
dialog.show()
def pin_dialog(self, msg):
# Needed e.g. when resetting a device
self.clear_dialog()
dialog = WindowModalDialog(self.top_level_window(), _("Enter PIN"))
matrix = self.pin_matrix_widget_class()
vbox = QVBoxLayout()
vbox.addWidget(QLabel(msg))
vbox.addWidget(matrix)
vbox.addLayout(Buttons(CancelButton(dialog), OkButton(dialog)))
dialog.setLayout(vbox)
dialog.exec_()
self.response = str(matrix.get_value())
self.done.set()
def __init__(self, parent):
QWidget.__init__(self, parent)
l = QVBoxLayout()
self.setLayout(l)
l.addStretch(10)
self.pi = ProgressIndicator(self, 128)
l.addWidget(self.pi, alignment=Qt.AlignHCenter)
self.dummy = QLabel('<h2>\xa0')
l.addSpacing(10)
l.addWidget(self.dummy, alignment=Qt.AlignHCenter)
l.addStretch(10)
self.setVisible(False)
self.text = ''
class DBCheck(QDialog): # {{{
update_msg = pyqtSignal(object)
def __init__(self, parent, db):
QDialog.__init__(self, parent)
self.l = QVBoxLayout()
self.setLayout(self.l)
self.l1 = QLabel(_('Vacuuming database to improve performance.') + ' ' +
_('This will take a while, please wait...'))
self.setWindowTitle(_('Vacuuming...'))
self.l1.setWordWrap(True)
self.l.addWidget(self.l1)
self.msg = QLabel('')
self.update_msg.connect(self.msg.setText, type=Qt.QueuedConnection)
self.l.addWidget(self.msg)
self.msg.setWordWrap(True)
self.resize(self.sizeHint() + QSize(100, 50))
self.error = None
self.db = db.new_api
self.closed_orig_conn = False
self.rejected = False
def start(self):
t = self.thread = Thread(target=self.vacuum)
t.daemon = True
t.start()
QTimer.singleShot(100, self.check)
self.exec_()
def vacuum(self):
try:
self.db.vacuum()
except Exception as e:
import traceback
self.error = (as_unicode(e), traceback.format_exc())
def reject(self):
self.rejected = True
return QDialog.reject(self)
def check(self):
if self.rejected:
return
if self.thread.is_alive():
QTimer.singleShot(100, self.check)
else:
self.accept()
def break_cycles(self):
self.db = self.thread = None
def create_widgets(self):
''' Create Widgets'''
self.builder.set_props(self, False, 1200, 740)
self.desc_label = self.builder.label(self, "Description: \nEdit an existing Timing Mapping Parameter Set or create a new one")
self.desc_label.setFixedHeight(50)
self.set_cb = self.builder.combobox(self, [], self.set_cb_selection_changed)
self.set_cb.setFixedHeight(22)
self.set_plus_pb = self.builder.pushbutton(self, "Add", self.add_hit, os.getcwd() +r'/icons/add.png')
self.set_plus_pb.setFixedWidth(100)
self.set_plus_pb.setFixedHeight(30)
self.elem_tab = self.builder.table(self, 0, 5, ["Affiliation", "Timing Variable", "Type", "Value", "Condition"])
self.elem_tab.cellDoubleClicked.connect(self._cell_double_clicked)
''' Save and Exit Buttons '''
self.space = self.builder.label(self, "")
# self.space.setFixedWidth(300)
self.ok_pb = self.builder.pushbutton(self, "Ok", self.ok_hit)
self.ok_pb.setFixedHeight(30)
self.ok_pb.setFixedWidth(140)
self.apply_pb = self.builder.pushbutton(self, "Apply", self.apply_hit)
self.apply_pb.setFixedHeight(30)
self.apply_pb.setFixedWidth(140)
self.cancel_pb = self.builder.pushbutton(self, "Cancel", self.cancel_hit)
self.cancel_pb.setFixedHeight(30)
self.cancel_pb.setFixedWidth(140)
''' Layout '''
v_lay = QVBoxLayout()
v_lay.addWidget(self.desc_label)
hl = QHBoxLayout()
hl.addWidget(self.set_plus_pb)
hl.addWidget(self.set_cb)
v_lay.addLayout(hl)
v_lay.addWidget(self.elem_tab)
hl = QHBoxLayout()
hl.addWidget(self.space)
hl.addWidget(self.ok_pb)
hl.addWidget(self.cancel_pb)
hl.addWidget(self.apply_pb)
v_lay.addLayout(hl)
self.setLayout(v_lay)
class DBRestore(QDialog):
update_signal = pyqtSignal(object, object)
def __init__(self, parent, library_path):
QDialog.__init__(self, parent)
self.l = QVBoxLayout()
self.setLayout(self.l)
self.l1 = QLabel('<b>'+_('Restoring database from backups, do not'
' interrupt, this will happen in three stages')+'...')
self.setWindowTitle(_('Restoring database'))
self.l.addWidget(self.l1)
self.pb = QProgressBar(self)
self.l.addWidget(self.pb)
self.pb.setMaximum(0)
self.pb.setMinimum(0)
self.msg = QLabel('')
self.l.addWidget(self.msg)
self.msg.setWordWrap(True)
self.bb = QDialogButtonBox(QDialogButtonBox.Cancel)
self.l.addWidget(self.bb)
self.bb.rejected.connect(self.reject)
self.resize(self.sizeHint() + QSize(100, 50))
self.error = None
self.rejected = False
self.library_path = library_path
self.update_signal.connect(self.do_update, type=Qt.QueuedConnection)
self.restorer = Restore(library_path, self)
self.restorer.daemon = True
# Give the metadata backup thread time to stop
QTimer.singleShot(2000, self.start)
def start(self):
self.restorer.start()
QTimer.singleShot(10, self.update)
def reject(self):
self.rejected = True
self.restorer.progress_callback = lambda x, y: x
QDialog.reject(self)
def update(self):
if self.restorer.is_alive():
QTimer.singleShot(10, self.update)
else:
self.restorer.progress_callback = lambda x, y: x
self.accept()
def __call__(self, msg, step):
self.update_signal.emit(msg, step)
def do_update(self, msg, step):
if msg is None:
self.pb.setMaximum(step)
else:
self.msg.setText(msg)
self.pb.setValue(step)
def _init_controls(self):
# Add the control set
vbl = QVBoxLayout()
self.move_element_up_tb = QToolButton()
self.move_element_up_tb.setObjectName("move_element_up_tb")
self.move_element_up_tb.setToolTip('Move element up')
self.move_element_up_tb.setIcon(QIcon(I('arrow-up.png')))
self.move_element_up_tb.clicked.connect(self.move_row_up)
vbl.addWidget(self.move_element_up_tb)
self.undo_css_tb = QToolButton()
self.undo_css_tb.setObjectName("undo_css_tb")
self.undo_css_tb.setToolTip('Restore CSS to last saved')
self.undo_css_tb.setIcon(QIcon(I('edit-undo.png')))
self.undo_css_tb.clicked.connect(
partial(self.undo_reset_button_clicked, 'undo'))
vbl.addWidget(self.undo_css_tb)
self.reset_css_tb = QToolButton()
self.reset_css_tb.setObjectName("reset_css_tb")
self.reset_css_tb.setToolTip('Reset CSS to default')
self.reset_css_tb.setIcon(QIcon(I('trash.png')))
self.reset_css_tb.clicked.connect(
partial(self.undo_reset_button_clicked, 'reset'))
vbl.addWidget(self.reset_css_tb)
self.move_element_down_tb = QToolButton()
self.move_element_down_tb.setObjectName("move_element_down_tb")
self.move_element_down_tb.setToolTip('Move element down')
self.move_element_down_tb.setIcon(QIcon(I('arrow-down.png')))
self.move_element_down_tb.clicked.connect(self.move_row_down)
vbl.addWidget(self.move_element_down_tb)
self.layout.addLayout(vbl)
def __init__(
self,
parent=None,
):
print repr(self), repr(parent)
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle("{0} {1}: Rename {0}".format(
PLUGIN_NAME, PLUGIN_VERSION, parent.key_type_name))
layout = QVBoxLayout(self)
self.setLayout(layout)
data_group_box = QGroupBox('', self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
data_group_box_layout.addWidget(QLabel('New Key Name:', self))
self.key_ledit = QLineEdit(self.parent.listy.currentItem().text(),
self)
self.key_ledit.setToolTip(
u"Enter a new name for this existing {0}.".format(
parent.key_type_name))
data_group_box_layout.addWidget(self.key_ledit)
layout.addSpacing(20)
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
def pin_dialog(self, msg):
d = QDialog(None)
d.setModal(1)
d.setWindowTitle(_("Enter PIN"))
matrix = PinMatrixWidget()
vbox = QVBoxLayout()
vbox.addWidget(QLabel(msg))
vbox.addWidget(matrix)
vbox.addLayout(ok_cancel_buttons(d))
d.setLayout(vbox)
if not d.exec_(): return
return str(matrix.get_value())
def message_dialog(self):
self.d = QDialog()
self.d.setModal(1)
self.d.setWindowTitle('Please Check KeepKey Device')
self.d.setWindowFlags(self.d.windowFlags()
| QtCore.Qt.WindowStaysOnTopHint)
l = QLabel(self.message)
vbox = QVBoxLayout(self.d)
vbox.addWidget(l)
if self.messsage_code in (3, 8):
vbox.addLayout(Buttons(CancelButton(self.d)))
self.d.connect(self.d, SIGNAL('rejected()'), self.client.cancel)
self.d.show()
def pin_dialog(self):
d = QDialog(None)
d.setModal(1)
d.setWindowTitle(_("Enter PIN"))
d.setWindowFlags(d.windowFlags() | QtCore.Qt.WindowStaysOnTopHint)
matrix = PinMatrixWidget()
vbox = QVBoxLayout()
vbox.addWidget(QLabel(self.message))
vbox.addWidget(matrix)
vbox.addLayout(Buttons(CancelButton(d), OkButton(d)))
d.setLayout(vbox)
if not d.exec_():
self.response = None
self.response = str(matrix.get_value())
self.done.set()
def __init__(self, parent, modal=True, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent, flags)
self.setModal(modal)
self.setWindowTitle("Add FITS brick")
lo = QVBoxLayout(self)
lo.setMargin(10)
lo.setSpacing(5)
# file selector
self.wfile = FileSelector(self,
label="FITS filename:",
dialog_label="FITS file",
default_suffix="fits",
file_types="FITS files (*.fits *.FITS)",
file_mode=QFileDialog.ExistingFile)
lo.addWidget(self.wfile)
# overwrite or add mode
lo1 = QGridLayout()
lo.addLayout(lo1)
lo1.setContentsMargins(0, 0, 0, 0)
lo1.addWidget(QLabel("Padding factor:", self), 0, 0)
self.wpad = QLineEdit("2", self)
self.wpad.setValidator(QDoubleValidator(self))
lo1.addWidget(self.wpad, 0, 1)
lo1.addWidget(QLabel("Assign source name:", self), 1, 0)
self.wname = QLineEdit(self)
lo1.addWidget(self.wname, 1, 1)
# OK/cancel 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)
# signals
QObject.connect(self.wfile, SIGNAL("filenameSelected"),
self._fileSelected)
# internal state
self.qerrmsg = QErrorMessage(self)
def _create_widget(self):
self.builder.set_props(self, False, 820, 300)
self.setWindowIcon(QtGui.QIcon( os.getcwd() +r'/icons/tumcreatelogo2.png'))
self.tit_label = self.builder.label(self, "Description: \nEdit the Database request and the conditions")
self.left_label = self.builder.label(self, "Database request:")
self.db_textbox = QtGui.QTextEdit()
self.cond_label = self.builder.label(self, "Conditions for Database with ID:")
self.condition_tab = self.builder.table(self, len(self.condition), 6, ["ID", 'Lookup DB', "Var Name", "Var Config", "Type", "Value"], False)
self.condition_tab.verticalHeader().hide()
self.condition_tab.setColumnWidth(2, 250)
self.add_pb = self.builder.pushbutton(self, "Add Item", self.add_hit, icon_path = os.getcwd() +r'/icons/add.png')
self.add_pb.setFixedHeight(30)
self.add_pb.setFixedWidth(200)
self.del_pb = self.builder.pushbutton(self, "Delete Item", self.delete_hit, icon_path = os.getcwd() +r'/icons/delete.png')
self.del_pb.setFixedHeight(30)
self.del_pb.setFixedWidth(200)
self.space = self.builder.label(self, "")
self.ok_pb = self.builder.pushbutton(self, "Ok", self.ok_hit)
self.ok_pb.setFixedHeight(30)
self.ok_pb.setFixedWidth(140)
self.cancel_pb = self.builder.pushbutton(self, "Cancel", self.cancel_hit)
self.cancel_pb.setFixedHeight(30)
self.cancel_pb.setFixedWidth(140)
''' Layout '''
v_lay = QVBoxLayout()
v_lay.addWidget(self.tit_label)
v_lay.addWidget(self.left_label)
v_lay.addWidget(self.db_textbox)
v_lay.addWidget(self.cond_label)
v_lay.addWidget(self.condition_tab)
hl = QHBoxLayout()
hl.addWidget(self.add_pb)
hl.addWidget(self.del_pb)
hl.addWidget(self.space)
hl.addWidget(self.ok_pb)
hl.addWidget(self.cancel_pb)
v_lay.addLayout(hl)
self.setLayout(v_lay)
def __init__(self, parent=None):
super(IPETApplicationTab, self).__init__(parent)
vlayout = QVBoxLayout()
self.editablebrowser = EditableBrowser()
vlayout.addWidget(self.editablebrowser)
self.logfileview = IPETLogFileView(self)
vlayout.addWidget(self.logfileview)
self.setLayout(vlayout)
self.parser = None
self.filename = None
self.defineActions()
self.setParser(ExperimentManagement.getExperiment().getReaderManager())
self.logfileview.updateExperimentData()
def __init__(self, parent, plugin_name, html):
SizePersistedDialog.__init__(self, parent, 'Plugin Updater plugin:version history dialog')
self.setWindowTitle(_('Version History for %s')%plugin_name)
layout = QVBoxLayout(self)
self.setLayout(layout)
self.notes = QTextEdit(html, self)
self.notes.setReadOnly(True)
layout.addWidget(self.notes)
self.button_box = QDialogButtonBox(QDialogButtonBox.Close)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
# Cause our dialog size to be restored from prefs or created on first usage
self.resize_dialog()
class Browser(QScrollArea): # {{{
show_plugin = pyqtSignal(object)
def __init__(self, parent=None):
QScrollArea.__init__(self, parent)
self.setWidgetResizable(True)
category_map, category_names = {}, {}
for plugin in preferences_plugins():
if plugin.category not in category_map:
category_map[plugin.category] = plugin.category_order
if category_map[plugin.category] < plugin.category_order:
category_map[plugin.category] = plugin.category_order
if plugin.category not in category_names:
category_names[plugin.category] = (plugin.gui_category
if plugin.gui_category else
plugin.category)
self.category_names = category_names
categories = list(category_map.keys())
categories.sort(cmp=lambda x, y: cmp(category_map[x], category_map[y]))
self.category_map = OrderedDict()
for c in categories:
self.category_map[c] = []
for plugin in preferences_plugins():
self.category_map[plugin.category].append(plugin)
for plugins in self.category_map.values():
plugins.sort(cmp=lambda x, y: cmp(x.name_order, y.name_order))
self.widgets = []
self._layout = QVBoxLayout()
self.container = QWidget(self)
self.container.setLayout(self._layout)
self.setWidget(self.container)
for name, plugins in self.category_map.items():
w = Category(name, plugins, self.category_names[name], parent=self)
self.widgets.append(w)
self._layout.addWidget(w)
w.plugin_activated.connect(self.show_plugin.emit)
def __init__(self, parent=None):
QWidget.__init__(self)
self.parent = parent
self.setWindowTitle("My Part Window")
self.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
layout = QtGui.QHBoxLayout(self)
layout.setMargin(0)
layout.setSpacing(0)
#########################
holder = QWidget()
holder.setMaximumWidth(200)
sublayout = QVBoxLayout(holder)
sublayout.setMargin(0)
sublayout.setSpacing(0)
layout.addWidget(holder)
###
self.featureManager = QtGui.QTabWidget()
self.featureManager.setCurrentIndex(0)
self.featureManager.setMaximumWidth(200)
self.modelTreeTab = QtGui.QWidget()
self.featureManager.addTab(self.modelTreeTab, "Model Tree")
modelTreeTabLayout = QtGui.QVBoxLayout(self.modelTreeTab)
modelTreeTabLayout.setMargin(0)
modelTreeTabLayout.setSpacing(0)
self.propertyManagerTab = QtGui.QWidget()
self.featureManager.addTab(self.propertyManagerTab, "Property Manager")
sublayout.addWidget(self.featureManager)
###
self.modelTree = modelTreeGui.TestWrapper()
self.modelTree.addIconButton(
QIcon(icons + '/GrapheneGeneratorDialog_image3.png'), self.dismiss)
modelTreeTabLayout.addWidget(self.modelTree)
self.glpane = GLPane()
layout.addWidget(self.glpane)
def __init__(self, parent, *args):
QWidget.__init__(self, parent, *args)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
lo = QVBoxLayout(self)
lo.setContentsMargins(0, 0, 0, 0)
lo1 = QHBoxLayout()
lo.addLayout(lo1)
lo1.setContentsMargins(0, 0, 0, 0)
lbl = QLabel(QString("<nobr><b>Source groupings:</b></nobr>"), self)
lo1.addWidget(lbl, 0)
lo1.addStretch(1)
# add show/hide button
self._showattrbtn = QPushButton(self)
self._showattrbtn.setMinimumWidth(256)
lo1.addWidget(self._showattrbtn, 0)
lo1.addStretch()
QObject.connect(self._showattrbtn, SIGNAL("clicked()"),
self._togglePlotControlsVisibility)
# add table
self.table = QTableWidget(self)
lo.addWidget(self.table)
QObject.connect(self.table, SIGNAL("cellChanged(int,int)"),
self._valueChanged)
self.table.setSelectionMode(QTableWidget.NoSelection)
# setup basic columns
self.table.setColumnCount(6 + len(self.EditableAttrs))
for i, label in enumerate(
("grouping", "total", "selection", "list", "plot", "style")):
self.table.setHorizontalHeaderItem(i, QTableWidgetItem(label))
self.table.horizontalHeader().setSectionHidden(self.ColApply, True)
# setup columns for editable grouping attributes
for i, attr in self.AttrByCol.items():
self.table.setHorizontalHeaderItem(
i, QTableWidgetItem(PlotStyles.StyleAttributeLabels[attr]))
self.table.horizontalHeader().setSectionHidden(i, True)
self.table.verticalHeader().hide()
# other internal init
self._attrs_shown = False
self._togglePlotControlsVisibility()
self.model = None
self._setting_model = False
self._currier = PersistentCurrier()
# row of 'selected' grouping
self._irow_selgroup = 0
def do_config(self):
# Save values that need to be synced between the dialog and the
# search widget.
self.config['open_external'] = self.open_external.isChecked()
# Create the config dialog. It's going to put two config widgets
# into a QTabWidget for displaying all of the settings.
d = QDialog(self)
button_box = QDialogButtonBox(QDialogButtonBox.Close)
v = QVBoxLayout(d)
button_box.accepted.connect(d.accept)
button_box.rejected.connect(d.reject)
d.setWindowTitle(_('Customize get books search'))
tab_widget = QTabWidget(d)
v.addWidget(tab_widget)
v.addWidget(button_box)
chooser_config_widget = StoreChooserWidget()
search_config_widget = StoreConfigWidget(self.config)
tab_widget.addTab(chooser_config_widget, _('Choose stores'))
tab_widget.addTab(search_config_widget, _('Configure search'))
# Restore dialog state.
geometry = self.config.get('config_dialog_geometry', None)
if geometry:
d.restoreGeometry(geometry)
else:
d.resize(800, 600)
tab_index = self.config.get('config_dialog_tab_index', 0)
tab_index = min(tab_index, tab_widget.count() - 1)
tab_widget.setCurrentIndex(tab_index)
d.exec_()
# Save dialog state.
self.config['config_dialog_geometry'] = bytearray(d.saveGeometry())
self.config['config_dialog_tab_index'] = tab_widget.currentIndex()
search_config_widget.save_settings()
self.config_changed()
self.gui.load_store_plugins()
self.setup_store_checks()
def passphrase_dialog(self, msg, confirm):
# If confirm is true, require the user to enter the passphrase twice
parent = self.top_level_window()
if confirm:
d = PasswordDialog(parent, None, msg, PW_PASSPHRASE)
confirmed, p, passphrase = d.run()
else:
d = WindowModalDialog(parent, _("Enter Passphrase"))
pw = QLineEdit()
pw.setEchoMode(2)
pw.setMinimumWidth(200)
vbox = QVBoxLayout()
vbox.addWidget(WWLabel(msg))
vbox.addWidget(pw)
vbox.addLayout(Buttons(CancelButton(d), OkButton(d)))
d.setLayout(vbox)
passphrase = unicode(pw.text()) if d.exec_() else None
self.passphrase = passphrase
self.done.set()
def __init__(self, win):
QDialog.__init__(self, win)
self.setupUi(self)
self.connect(self.closePTableButton,SIGNAL("clicked()"),self.close)
self.connect(self.TransmuteButton,SIGNAL("clicked()"),self.transmutePressed)
self.connect(self.elementButtonGroup,SIGNAL("clicked(int)"),self.setElementInfo)
self.w = win
self.elemTable = PeriodicTable
self.displayMode = diTUBES
self.elemGLPane = ElementView(self.elementFrame, "element glPane", self.w.glpane)
# Put the GL widget inside the frame
flayout = QVBoxLayout(self.elementFrame,1,1,'flayout')
flayout.addWidget(self.elemGLPane,1)
self.elementFrame.setWhatsThis("""3D view of current atom type""")
self.TransmuteButton.setWhatsThis("""Transmutes selected atoms in the 3D workspace to current atom
above.""")
self.transmuteCheckBox.setWhatsThis("""Check if transmuted atoms should keep all existing bonds, even
if chemistry is wrong.""")
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 __init__(self, gui, group_name):
SizePersistedDialog.__init__(self, gui, 'Keyboard shortcut dialog')
self.gui = gui
self.setWindowTitle('Keyboard shortcuts')
layout = QVBoxLayout(self)
self.setLayout(layout)
self.keyboard_widget = ShortcutConfig(self)
layout.addWidget(self.keyboard_widget)
self.group_name = group_name
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
button_box.accepted.connect(self.commit)
button_box.rejected.connect(self.reject)
layout.addWidget(button_box)
# Cause our dialog size to be restored from prefs or created on first usage
self.resize_dialog()
self.initialize()
class Wizard(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.resize(440, 480)
self.verticalLayout = QVBoxLayout(self)
self.widget = WizardWidget(self)
self.verticalLayout.addWidget(self.widget)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
self.verticalLayout.addWidget(self.buttonBox)
self.connect(self.buttonBox, SIGNAL("accepted()"), self.accept)
self.connect(self.buttonBox, SIGNAL("rejected()"), self.reject)
self.setModal(Qt.WindowModal)
@property
def xpath(self):
return self.widget.xpath
def __init__(
self,
parent=None,
):
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle(
u"{0} {1}: Getting Default Kindle for Mac/PC Key".format(
PLUGIN_NAME, PLUGIN_VERSION))
layout = QVBoxLayout(self)
self.setLayout(layout)
try:
self.default_key = retrieve_kindle_keys()[0]
except:
self.default_key = u""
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
if len(self.default_key) > 0:
data_group_box = QGroupBox(u"", self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
key_group = QHBoxLayout()
data_group_box_layout.addLayout(key_group)
key_group.addWidget(QLabel(u"Unique Key Name:", self))
self.key_ledit = QLineEdit("", self)
self.key_ledit.setToolTip(
u"<p>Enter an identifying name for the current default Kindle for Mac/PC key."
)
key_group.addWidget(self.key_ledit)
key_label = QLabel(_(''), self)
key_label.setAlignment(Qt.AlignHCenter)
data_group_box_layout.addWidget(key_label)
self.button_box.accepted.connect(self.accept)
else:
default_key_error = QLabel(
u"The default encryption key for Kindle for Mac/PC could not be found.",
self)
default_key_error.setAlignment(Qt.AlignHCenter)
layout.addWidget(default_key_error)
# if no default, bot buttons do the same
self.button_box.accepted.connect(self.reject)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
def __init__(self):
QGroupBox.__init__(self)
self.treemodel = treemodel = TestNe1Model()
self.view = view = ModelTreeGui(TestMainWindow(), "Model tree",
treemodel, self)
view.mt_update()
self.chunkNum = 2
self.gbox = QGroupBox()
vl = QVBoxLayout(self)
vl.setSpacing(0)
vl.setMargin(0)
vl.addWidget(self.view)
self.buttonLayout = hl = QHBoxLayout()
hl.setSpacing(0)
hl.setMargin(0)
vl.addLayout(hl)
self.buttonNum = 1
for func in (self.addmol, self.addjig, self.selected):
self.addButton(func)
