def __init__(self, show_strength=True, parent=None):
super(PinMatrixWidget, self).__init__(parent)
self.password = QLineEdit()
self.password.setValidator(QRegExpValidator(QRegExp('[1-9]+'), None))
self.password.setEchoMode(QLineEdit.Password)
QObject.connect(self.password, SIGNAL('textChanged(QString)'), self._password_changed)
self.strength = QLabel()
self.strength.setMinimumWidth(75)
self.strength.setAlignment(Qt.AlignCenter)
self._set_strength(0)
grid = QGridLayout()
grid.setSpacing(0)
for y in range(3)[::-1]:
for x in range(3):
button = PinButton(self.password, x + y * 3 + 1)
button.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
button.setFocusPolicy(Qt.NoFocus)
grid.addWidget(button, 3 - y, x)
hbox = QHBoxLayout()
hbox.addWidget(self.password)
if show_strength:
hbox.addWidget(self.strength)
vbox = QVBoxLayout()
vbox.addLayout(grid)
vbox.addLayout(hbox)
self.setLayout(vbox)
def setup_store_checks(self):
first_run = self.config.get('first_run', True)
# Add check boxes for each store so the user
# can disable searching specific stores on a
# per search basis.
existing = {}
for n in self.store_checks:
existing[n] = self.store_checks[n].isChecked()
self.store_checks = {}
stores_check_widget = QWidget()
store_list_layout = QGridLayout()
stores_check_widget.setLayout(store_list_layout)
icon = QIcon(I('donate.png'))
for i, x in enumerate(
sorted(self.gui.istores.keys(), key=lambda x: x.lower())):
cbox = QCheckBox(x)
cbox.setChecked(existing.get(x, first_run))
store_list_layout.addWidget(cbox, i, 0, 1, 1)
if self.gui.istores[x].base_plugin.affiliate:
iw = QLabel(self)
iw.setToolTip('<p>' + _(
'Buying from this store supports the calibre developer: %s</p>'
) % self.gui.istores[x].base_plugin.author + '</p>')
iw.setPixmap(icon.pixmap(16, 16))
store_list_layout.addWidget(iw, i, 1, 1, 1)
self.store_checks[x] = cbox
store_list_layout.setRowStretch(store_list_layout.rowCount(), 10)
self.store_list.setWidget(stores_check_widget)
self.config['first_run'] = False
def __init__(self, text, parent=None, clicked_func=None, caption="(caption)", size=None):
QDialog.__init__(self, parent)
self.setWindowTitle(caption)
self.setWindowIcon(QtGui.QIcon("ui/border/MainWindow"))
self.setObjectName("WikiHelpBrowser")
TextBrowserLayout = QGridLayout(self)
TextBrowserLayout.setSpacing(5)
TextBrowserLayout.setMargin(2)
self.text_browser = QTextBrowser(self)
self.text_browser.setOpenExternalLinks(True)
self.text_browser.setObjectName("text_browser")
TextBrowserLayout.addWidget(self.text_browser, 0, 0, 1, 0)
self.text_browser.setMinimumSize(400, 200)
# make it pale yellow like a post-it note
self.text_browser.setHtml('<qt bgcolor="#FFFF80">' + text)
self.close_button = QPushButton(self)
self.close_button.setObjectName("close_button")
self.close_button.setText("Close")
TextBrowserLayout.addWidget(self.close_button, 1, 1)
spacer = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
TextBrowserLayout.addItem(spacer, 1, 0)
self.resize(QSize(300, 300).expandedTo(self.minimumSizeHint()))
if size == 1:
self.text_browser.setMinimumSize(200, 400)
self.resize(QSize(300, 550).expandedTo(self.minimumSizeHint()))
if size == 2:
self.resize(QSize(650, 250).expandedTo(self.minimumSizeHint()))
self.connect(self.close_button, SIGNAL("clicked()"), self.close)
return
def __init__(self,
text,
parent=None,
clicked_func=None,
caption="(caption)"):
QDialog.__init__(self, parent)
self.setWindowTitle(caption)
self.setWindowIcon(QtGui.QIcon("ui/border/MainWindow"))
self.setObjectName("WikiHelpBrowser")
TextBrowserLayout = QGridLayout(self)
TextBrowserLayout.setSpacing(5)
TextBrowserLayout.setMargin(2)
self.text_browser = QTextBrowser(self)
self.text_browser.setOpenExternalLinks(True)
self.text_browser.setObjectName("text_browser")
TextBrowserLayout.addWidget(self.text_browser, 0, 0, 1, 0)
self.text_browser.setMinimumSize(400, 200)
# make it pale yellow like a post-it note
self.text_browser.setHtml("<qt bgcolor=\"#FFFF80\">" + text)
self.close_button = QPushButton(self)
self.close_button.setObjectName("close_button")
self.close_button.setText("Close")
TextBrowserLayout.addWidget(self.close_button, 1, 1)
spacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
TextBrowserLayout.addItem(spacer, 1, 0)
self.resize(QSize(300, 300).expandedTo(self.minimumSizeHint()))
self.connect(self.close_button, SIGNAL("clicked()"), self.close)
return
def setup_store_checks(self):
first_run = self.config.get('first_run', True)
# Add check boxes for each store so the user
# can disable searching specific stores on a
# per search basis.
existing = {}
for n in self.store_checks:
existing[n] = self.store_checks[n].isChecked()
self.store_checks = {}
stores_check_widget = QWidget()
store_list_layout = QGridLayout()
stores_check_widget.setLayout(store_list_layout)
icon = QIcon(I('donate.png'))
for i, x in enumerate(sorted(self.gui.istores.keys(), key=lambda x: x.lower())):
cbox = QCheckBox(x)
cbox.setChecked(existing.get(x, first_run))
store_list_layout.addWidget(cbox, i, 0, 1, 1)
if self.gui.istores[x].base_plugin.affiliate:
iw = QLabel(self)
iw.setToolTip('<p>' + _('Buying from this store supports the calibre developer: %s</p>') % self.gui.istores[x].base_plugin.author + '</p>')
iw.setPixmap(icon.pixmap(16, 16))
store_list_layout.addWidget(iw, i, 1, 1, 1)
self.store_checks[x] = cbox
store_list_layout.setRowStretch(store_list_layout.rowCount(), 10)
self.store_list.setWidget(stores_check_widget)
self.config['first_run'] = False
class Footer(QWidget):
def __init__(self):
QWidget.__init__(self)
self.__InitUi()
def __InitUi(self):
self.setFixedHeight(160)
SetWidgetBackgroundColor(COLOR_WIDGET_2, self)
self.__Layout = QGridLayout()
self.setLayout(self.__Layout)
self.__Layout.setContentsMargins(30,30,30,30)
self.__Layout.setHorizontalSpacing(30)
self.__Layout.setVerticalSpacing(30)
self.__lblProcess = LabelSmalSize("", COLOR_FONT_4, True)
self.__Layout.addWidget(self.__lblProcess)
self.__pgbProgress = Progressbar()
self.__Layout.addWidget(self.__pgbProgress)
def ProcessStartet(self, strProcess):
self.__lblProcess.setText(strProcess)
self.__pgbProgress.setMaximum(0)
def ProcessEnded(self):
self.__lblProcess.setText("")
self.__pgbProgress.setMaximum(100)
def __init__(self, show_strength=True, parent=None):
super(PinMatrixWidget, self).__init__(parent)
self.password = QLineEdit()
self.password.setValidator(QRegExpValidator(QRegExp('[1-9]+'), None))
self.password.setEchoMode(QLineEdit.Password)
QObject.connect(self.password, SIGNAL('textChanged(QString)'), self._password_changed)
self.strength = QLabel()
self.strength.setMinimumWidth(75)
self.strength.setAlignment(Qt.AlignCenter)
self._set_strength(0)
grid = QGridLayout()
grid.setSpacing(0)
for y in range(3)[::-1]:
for x in range(3):
button = PinButton(self.password, x + y * 3 + 1)
button.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
button.setFocusPolicy(Qt.NoFocus)
grid.addWidget(button, 3 - y, x)
hbox = QHBoxLayout()
hbox.addWidget(self.password)
if show_strength:
hbox.addWidget(self.strength)
vbox = QVBoxLayout()
vbox.addLayout(grid)
vbox.addLayout(hbox)
self.setLayout(vbox)
def __init__(self, win):
self.xmlfile = os.path.join(_sponsordir, 'sponsors.xml')
self.win = win
self.needToAsk = False
self.downloadSponsors = False
threading.Thread.__init__(self)
if not self.refreshWanted():
return
if env.prefs[sponsor_permanent_permission_prefs_key]:
# We have a permanent answer so no need for a dialog
if env.prefs[sponsor_download_permission_prefs_key]:
self.downloadSponsors = True
return
self.needToAsk = True
QDialog.__init__(self, None)
self.setObjectName("Permission")
self.setModal(True) #This fixes bug 2296. Mitigates bug 2297
layout = QGridLayout()
self.setLayout(layout)
layout.setMargin(0)
layout.setSpacing(0)
layout.setObjectName("PermissionLayout")
self.text_browser = QTextBrowser(self)
self.text_browser.setObjectName("text_browser")
layout.addWidget(self.text_browser, 0, 0, 1, 4)
self.text_browser.setMinimumSize(400, 80)
self.setWindowTitle('May we use your network connection?')
self.setWindowIcon(geticon('ui/border/MainWindow.png'))
self.text_browser.setPlainText(self.text)
self.accept_button = QPushButton(self)
self.accept_button.setObjectName("accept_button")
self.accept_button.setText("Always OK")
self.accept_once_button = QPushButton(self)
self.accept_once_button.setObjectName("accept_once_button")
self.accept_once_button.setText("OK now")
self.decline_once_button = QPushButton(self)
self.decline_once_button.setObjectName("decline_once_button")
self.decline_once_button.setText("Not now")
self.decline_always_button = QPushButton(self)
self.decline_always_button.setObjectName("decline_always_button")
self.decline_always_button.setText("Never")
layout.addWidget(self.accept_button, 1, 0)
layout.addWidget(self.accept_once_button, 1, 1)
layout.addWidget(self.decline_once_button, 1, 2)
layout.addWidget(self.decline_always_button, 1, 3)
self.connect(self.accept_button, SIGNAL("clicked()"),
self.acceptAlways)
self.connect(self.accept_once_button, SIGNAL("clicked()"),
self.acceptJustOnce)
self.connect(self.decline_once_button, SIGNAL("clicked()"),
self.declineJustOnce)
self.connect(self.decline_always_button, SIGNAL("clicked()"),
self.declineAlways)
class FormWidget(QtGui.QWidget):
def __init__(self, parent, graphs):
super(FormWidget, self).__init__(parent)
self.layout = QGridLayout(self)
dim = np.ceil(np.sqrt(len(graphs)))
grid = np.arange(dim * np.ceil(len(graphs) / dim)).reshape(-1, dim)
for k in range(len(graphs)):
i, j = np.where(grid == k)
self.layout.addWidget(graphs[k], i, j)
def __init__(self, win):
self.xmlfile = os.path.join(_sponsordir, 'sponsors.xml')
self.win = win
self.needToAsk = False
self.downloadSponsors = False
threading.Thread.__init__(self)
if not self.refreshWanted():
return
if env.prefs[sponsor_permanent_permission_prefs_key]:
# We have a permanent answer so no need for a dialog
if env.prefs[sponsor_download_permission_prefs_key]:
self.downloadSponsors = True
return
self.needToAsk = True
QDialog.__init__(self, None)
self.setObjectName("Permission")
self.setModal(True) #This fixes bug 2296. Mitigates bug 2297
layout = QGridLayout()
self.setLayout(layout)
layout.setMargin(0)
layout.setSpacing(0)
layout.setObjectName("PermissionLayout")
self.text_browser = QTextBrowser(self)
self.text_browser.setObjectName("text_browser")
layout.addWidget(self.text_browser,0,0,1,4)
self.text_browser.setMinimumSize(400, 80)
self.setWindowTitle('May we use your network connection?')
self.setWindowIcon(geticon('ui/border/MainWindow.png'))
self.text_browser.setPlainText(self.text)
self.accept_button = QPushButton(self)
self.accept_button.setObjectName("accept_button")
self.accept_button.setText("Always OK")
self.accept_once_button = QPushButton(self)
self.accept_once_button.setObjectName("accept_once_button")
self.accept_once_button.setText("OK now")
self.decline_once_button = QPushButton(self)
self.decline_once_button.setObjectName("decline_once_button")
self.decline_once_button.setText("Not now")
self.decline_always_button = QPushButton(self)
self.decline_always_button.setObjectName("decline_always_button")
self.decline_always_button.setText("Never")
layout.addWidget(self.accept_button,1,0)
layout.addWidget(self.accept_once_button,1,1)
layout.addWidget(self.decline_once_button,1,2)
layout.addWidget(self.decline_always_button,1,3)
self.connect(self.accept_button,SIGNAL("clicked()"),self.acceptAlways)
self.connect(self.accept_once_button,SIGNAL("clicked()"),self.acceptJustOnce)
self.connect(self.decline_once_button,SIGNAL("clicked()"),self.declineJustOnce)
self.connect(self.decline_always_button,SIGNAL("clicked()"),self.declineAlways)
def settings_dialog(self):
get_label = lambda: self.wallet.get_client().features.label
update_label = lambda: current_label_label.setText("Label: %s" % get_label())
d = QDialog()
layout = QGridLayout(d)
layout.addWidget(QLabel("Trezor Options"),0,0)
layout.addWidget(QLabel("ID:"),1,0)
layout.addWidget(QLabel(" %s" % self.wallet.get_client().get_device_id()),1,1)
def modify_label():
response = QInputDialog().getText(None, "Set New Trezor Label", "New Trezor Label: (upon submission confirm on Trezor)")
if not response[1]:
return
new_label = str(response[0])
twd.start("Please confirm label change on Trezor")
status = self.wallet.get_client().apply_settings(label=new_label)
twd.stop()
update_label()
current_label_label = QLabel()
update_label()
change_label_button = QPushButton("Modify")
change_label_button.clicked.connect(modify_label)
layout.addWidget(current_label_label,3,0)
layout.addWidget(change_label_button,3,1)
if d.exec_():
return True
else:
return False
class ConfigWidget(QWidget):
'Configuration widget'
def __init__(self):
QWidget.__init__(self)
self.layout = QGridLayout()
self.layout.setSpacing(10)
self.setLayout(self.layout)
self.key_label = QLabel('&api key:')
self.key_msg = QLineEdit(self)
self.key_msg.setText(PREFS['api_key'])
self.layout.addWidget(self.key_label, 1, 0)
self.layout.addWidget(self.key_msg, 1, 1)
self.key_label.setBuddy(self.key_msg)
self.threads_label = QLabel('&worker_threads:')
self.threads_msg = QLineEdit(self)
self.threads_msg.setText(unicode(PREFS['worker_threads']))
self.layout.addWidget(self.threads_label, 2, 0)
self.layout.addWidget(self.threads_msg, 2, 1)
self.threads_label.setBuddy(self.threads_msg)
def save_settings(self):
'Apply new settings value'
PREFS['api_key'] = unicode(self.key_msg.text())
PREFS['worker_threads'] = int(self.threads_msg.text())
pycomicvine.api_key = PREFS['api_key']
def settings_dialog(self):
get_label = lambda: self.wallet.get_client().features.label
update_label = lambda: current_label_label.setText("Label: %s" %
get_label())
d = QDialog()
layout = QGridLayout(d)
layout.addWidget(QLabel("Trezor Options"), 0, 0)
layout.addWidget(QLabel("ID:"), 1, 0)
layout.addWidget(
QLabel(" %s" % self.wallet.get_client().get_device_id()), 1, 1)
def modify_label():
response = QInputDialog().getText(
None, "Set New Trezor Label",
"New Trezor Label: (upon submission confirm on Trezor)")
if not response[1]:
return
new_label = str(response[0])
twd.start("Please confirm label change on Trezor")
status = self.wallet.get_client().apply_settings(label=new_label)
twd.stop()
update_label()
current_label_label = QLabel()
update_label()
change_label_button = QPushButton("Modify")
change_label_button.clicked.connect(modify_label)
layout.addWidget(current_label_label, 3, 0)
layout.addWidget(change_label_button, 3, 1)
if d.exec_():
return True
else:
return False
def settings_dialog(self):
try:
device_id = self.get_client().get_device_id()
except BaseException as e:
self.window.show_message(str(e))
return
get_label = lambda: self.get_client().features.label
update_label = lambda: current_label_label.setText("Label: %s" % get_label())
d = QDialog()
layout = QGridLayout(d)
layout.addWidget(QLabel("Trezor Options"), 0, 0)
layout.addWidget(QLabel("ID:"), 1, 0)
layout.addWidget(QLabel(" %s" % device_id), 1, 1)
def modify_label():
response = QInputDialog().getText(
None, "Set New Trezor Label", "New Trezor Label: (upon submission confirm on Trezor)"
)
if not response[1]:
return
new_label = str(response[0])
self.handler.show_message("Please confirm label change on Trezor")
status = self.get_client().apply_settings(label=new_label)
self.handler.stop()
update_label()
current_label_label = QLabel()
update_label()
change_label_button = QPushButton("Modify")
change_label_button.clicked.connect(modify_label)
layout.addWidget(current_label_label, 3, 0)
layout.addWidget(change_label_button, 3, 1)
d.exec_()
def settings_dialog(self):
try:
device_id = self.get_client().get_device_id()
except BaseException as e:
self.window.show_message(str(e))
return
get_label = lambda: self.get_client().features.label
update_label = lambda: current_label_label.setText("Label: %s" %
get_label())
d = QDialog()
layout = QGridLayout(d)
layout.addWidget(QLabel("KeepKey Options"), 0, 0)
layout.addWidget(QLabel("ID:"), 1, 0)
layout.addWidget(QLabel(" %s" % device_id), 1, 1)
def modify_label():
response = QInputDialog().getText(
None, "Set New KeepKey Label",
"New KeepKey Label: (upon submission confirm on KeepKey)")
if not response[1]:
return
new_label = str(response[0])
self.handler.show_message("Please confirm label change on KeepKey")
status = self.get_client().apply_settings(label=new_label)
self.handler.stop()
update_label()
current_label_label = QLabel()
update_label()
change_label_button = QPushButton("Modify")
change_label_button.clicked.connect(modify_label)
layout.addWidget(current_label_label, 3, 0)
layout.addWidget(change_label_button, 3, 1)
d.exec_()
class UpdateNotification(QDialog):
def __init__(self, calibre_version, plugin_updates, parent=None):
QDialog.__init__(self, parent)
self.setAttribute(Qt.WA_QuitOnClose, False)
self.resize(400, 250)
self.l = QGridLayout()
self.setLayout(self.l)
self.logo = QLabel()
self.logo.setMaximumWidth(110)
self.logo.setPixmap(QPixmap(I('lt.png')).scaled(100, 100,
Qt.IgnoreAspectRatio, Qt.SmoothTransformation))
ver = calibre_version
if ver.endswith('.0'):
ver = ver[:-2]
self.label = QLabel(('<p>'+
_('New version <b>%(ver)s</b> of %(app)s is available for download. '
'See the <a href="http://calibre-ebook.com/whats-new'
'">new features</a>.'))%dict(
app=__appname__, ver=ver))
self.label.setOpenExternalLinks(True)
self.label.setWordWrap(True)
self.setWindowTitle(_('Update available!'))
self.setWindowIcon(QIcon(I('lt.png')))
self.l.addWidget(self.logo, 0, 0)
self.l.addWidget(self.label, 0, 1)
self.cb = QCheckBox(
_('Show this notification for future updates'), self)
self.l.addWidget(self.cb, 1, 0, 1, -1)
self.cb.setChecked(config.get('new_version_notification'))
self.cb.stateChanged.connect(self.show_future)
self.bb = QDialogButtonBox(self)
b = self.bb.addButton(_('&Get update'), self.bb.AcceptRole)
b.setDefault(True)
b.setIcon(QIcon(I('arrow-down.png')))
if plugin_updates > 0:
b = self.bb.addButton(_('Update &plugins'), self.bb.ActionRole)
b.setIcon(QIcon(I('plugins/plugin_updater.png')))
b.clicked.connect(self.get_plugins, type=Qt.QueuedConnection)
self.bb.addButton(self.bb.Cancel)
self.l.addWidget(self.bb, 2, 0, 1, -1)
self.bb.accepted.connect(self.accept)
self.bb.rejected.connect(self.reject)
dynamic.set('update to version %s'%calibre_version, False)
def get_plugins(self):
from calibre.gui2.dialogs.plugin_updater import (PluginUpdaterDialog,
FILTER_UPDATE_AVAILABLE)
d = PluginUpdaterDialog(self.parent(),
initial_filter=FILTER_UPDATE_AVAILABLE)
d.exec_()
def show_future(self, *args):
config.set('new_version_notification', bool(self.cb.isChecked()))
def accept(self):
open_url(QUrl(get_download_url()))
QDialog.accept(self)
class UpdateNotification(QDialog):
def __init__(self, calibre_version, plugin_updates, parent=None):
QDialog.__init__(self, parent)
self.setAttribute(Qt.WA_QuitOnClose, False)
self.resize(400, 250)
self.l = QGridLayout()
self.setLayout(self.l)
self.logo = QLabel()
self.logo.setMaximumWidth(110)
self.logo.setPixmap(
QPixmap(I('lt.png')).scaled(100, 100, Qt.IgnoreAspectRatio,
Qt.SmoothTransformation))
ver = calibre_version
if ver.endswith('.0'):
ver = ver[:-2]
self.label = QLabel(('<p>' + _(
'New version <b>%(ver)s</b> of %(app)s is available for download. '
'See the <a href="http://calibre-ebook.com/whats-new'
'">new features</a>.')) % dict(app=__appname__, ver=ver))
self.label.setOpenExternalLinks(True)
self.label.setWordWrap(True)
self.setWindowTitle(_('Update available!'))
self.setWindowIcon(QIcon(I('lt.png')))
self.l.addWidget(self.logo, 0, 0)
self.l.addWidget(self.label, 0, 1)
self.cb = QCheckBox(_('Show this notification for future updates'),
self)
self.l.addWidget(self.cb, 1, 0, 1, -1)
self.cb.setChecked(config.get('new_version_notification'))
self.cb.stateChanged.connect(self.show_future)
self.bb = QDialogButtonBox(self)
b = self.bb.addButton(_('&Get update'), self.bb.AcceptRole)
b.setDefault(True)
b.setIcon(QIcon(I('arrow-down.png')))
if plugin_updates > 0:
b = self.bb.addButton(_('Update &plugins'), self.bb.ActionRole)
b.setIcon(QIcon(I('plugins/plugin_updater.png')))
b.clicked.connect(self.get_plugins, type=Qt.QueuedConnection)
self.bb.addButton(self.bb.Cancel)
self.l.addWidget(self.bb, 2, 0, 1, -1)
self.bb.accepted.connect(self.accept)
self.bb.rejected.connect(self.reject)
dynamic.set('update to version %s' % calibre_version, False)
def get_plugins(self):
from calibre.gui2.dialogs.plugin_updater import (
PluginUpdaterDialog, FILTER_UPDATE_AVAILABLE)
d = PluginUpdaterDialog(self.parent(),
initial_filter=FILTER_UPDATE_AVAILABLE)
d.exec_()
def show_future(self, *args):
config.set('new_version_notification', bool(self.cb.isChecked()))
def accept(self):
open_url(QUrl(get_download_url()))
QDialog.accept(self)
class Widget(QWidget, ScreenWidget):
name = "network"
def __init__(self):
QWidget.__init__(self)
self.layout = QGridLayout(self)
self.networkConnector = pds.container.PNetworkManager(self)
self.layout.addWidget(self.networkConnector)
def shown(self):
self.networkConnector.startNetworkManager()
def execute(self):
self.networkConnector._proc.terminate()
ctx.mainScreen.disableBack()
return True
class Widget(QWidget, ScreenWidget):
name = "network"
def __init__(self):
QWidget.__init__(self)
self.layout = QGridLayout(self)
self.networkConnector = pds.container.PNetworkManager(self)
self.layout.addWidget(self.networkConnector)
def shown(self):
self.networkConnector.startNetworkManager()
def execute(self):
self.networkConnector._proc.terminate()
ctx.mainScreen.disableBack()
return True
def __init__(self, plugin):
DefaultConfigWidget.__init__(self, plugin)
c = plugin_prefs[STORE_NAME]
other_group_box = QGroupBox('Other options', self)
self.l.addWidget(other_group_box, self.l.rowCount(), 0, 1, 2)
other_group_box_layout = QGridLayout()
other_group_box.setLayout(other_group_box_layout)
max_downloads_label = QLabel('Maximum title/author search matches to download/evaluate (1 = fastest):', self)
max_downloads_label.setToolTip('More matches means higher chance of better\n'
'metadata (but not necessarily).\n')
other_group_box_layout.addWidget(max_downloads_label, 1, 0, 1, 1)
self.max_downloads_spin = QtGui.QSpinBox(self)
self.max_downloads_spin.setMinimum(1)
self.max_downloads_spin.setMaximum(100)
self.max_downloads_spin.setProperty('value', c.get(KEY_MAX_DOWNLOADS, DEFAULT_STORE_VALUES[KEY_MAX_DOWNLOADS]))
other_group_box_layout.addWidget(self.max_downloads_spin, 1, 1, 1, 1)
other_group_box_layout.setColumnStretch(2, 1)
def _createSponsorButton(self):
"""
Creates the Property Manager sponsor button, which contains
a QPushButton inside of a QGridLayout inside of a QFrame.
The sponsor logo image is not loaded here.
"""
# Sponsor button (inside a frame)
self.sponsor_frame = QFrame(self)
self.sponsor_frame.setFrameShape(QFrame.NoFrame)
self.sponsor_frame.setFrameShadow(QFrame.Plain)
SponsorFrameGrid = QGridLayout(self.sponsor_frame)
SponsorFrameGrid.setMargin(PM_SPONSOR_FRAME_MARGIN)
SponsorFrameGrid.setSpacing(PM_SPONSOR_FRAME_SPACING) # Has no effect.
self.sponsor_btn = QPushButton(self.sponsor_frame)
self.sponsor_btn.setAutoDefault(False)
self.sponsor_btn.setFlat(True)
self.connect(self.sponsor_btn,
SIGNAL("clicked()"),
self.open_sponsor_homepage)
SponsorFrameGrid.addWidget(self.sponsor_btn, 0, 0, 1, 1)
self.vBoxLayout.addWidget(self.sponsor_frame)
button_whatsthis_widget = self.sponsor_btn
#bruce 070615 bugfix -- put tooltip & whatsthis on self.sponsor_btn,
# not self.
# [self.sponsor_frame might be another possible place to put them.]
button_whatsthis_widget.setWhatsThis("""<b>Sponsor Button</b>
<p>When clicked, this sponsor logo will display a short
description about a NanoEngineer-1 sponsor. This can
be an official sponsor or credit given to a contributor
that has helped code part or all of this command.
A link is provided in the description to learn more
about this sponsor.</p>""")
button_whatsthis_widget.setToolTip("NanoEngineer-1 Sponsor Button")
return
def _createSponsorButton(self):
"""
Creates the Property Manager sponsor button, which contains
a QPushButton inside of a QGridLayout inside of a QFrame.
The sponsor logo image is not loaded here.
"""
# Sponsor button (inside a frame)
self.sponsor_frame = QFrame(self)
self.sponsor_frame.setFrameShape(QFrame.NoFrame)
self.sponsor_frame.setFrameShadow(QFrame.Plain)
SponsorFrameGrid = QGridLayout(self.sponsor_frame)
SponsorFrameGrid.setMargin(PM_SPONSOR_FRAME_MARGIN)
SponsorFrameGrid.setSpacing(PM_SPONSOR_FRAME_SPACING) # Has no effect.
self.sponsor_btn = QPushButton(self.sponsor_frame)
self.sponsor_btn.setAutoDefault(False)
self.sponsor_btn.setFlat(True)
self.connect(self.sponsor_btn, SIGNAL("clicked()"),
self.open_sponsor_homepage)
SponsorFrameGrid.addWidget(self.sponsor_btn, 0, 0, 1, 1)
self.vBoxLayout.addWidget(self.sponsor_frame)
button_whatsthis_widget = self.sponsor_btn
#bruce 070615 bugfix -- put tooltip & whatsthis on self.sponsor_btn,
# not self.
# [self.sponsor_frame might be another possible place to put them.]
button_whatsthis_widget.setWhatsThis("""<b>Sponsor Button</b>
<p>When clicked, this sponsor logo will display a short
description about a NanoEngineer-1 sponsor. This can
be an official sponsor or credit given to a contributor
that has helped code part or all of this command.
A link is provided in the description to learn more
about this sponsor.</p>""")
button_whatsthis_widget.setToolTip("NanoEngineer-1 Sponsor Button")
return
def __init__(self, movie):
self.movie = movie
QDialog.__init__(self, None)
self.setObjectName("movie_warning")
self.text_browser = QTextBrowser(self)
self.text_browser.setObjectName("movie_warning_textbrowser")
self.text_browser.setMinimumSize(400, 40)
self.setWindowTitle('Rewind your movie?')
self.text_browser.setPlainText( #bruce 080827 revised text
"You may want to rewind the movie now. The atoms move as the movie "
"progresses, and saving the part without rewinding will save the "
"current positions, which is sometimes useful, but will make the "
"movie invalid, because .dpb files only store deltas relative to "
"the initial atom positions, and don't store the initial positions "
"themselves." )
self.ok_button = QPushButton(self)
self.ok_button.setObjectName("ok_button")
self.ok_button.setText("Rewind movie")
self.cancel_button = QPushButton(self)
self.cancel_button.setObjectName("cancel_button")
self.cancel_button.setText("Exit command without rewinding") #bruce 080827 revised text
# Note: this is not, in fact, a cancel button --
# there is no option in the caller to prevent exiting the command.
# There is also no option to "forward to final position",
# though for a minimize movie, that might be most useful.
# [bruce 080827 comment]
layout = QGridLayout(self)
layout.addWidget(self.text_browser, 0, 0, 0, 1)
layout.addWidget(self.ok_button, 1, 0)
layout.addWidget(self.cancel_button, 1, 1)
self.connect(self.ok_button, SIGNAL("clicked()"), self.rewindMovie)
self.connect(self.cancel_button, SIGNAL("clicked()"), self.noThanks)
def __init__(self, movie):
self.movie = movie
QDialog.__init__(self, None)
self.setObjectName("movie_warning")
self.text_browser = QTextBrowser(self)
self.text_browser.setObjectName("movie_warning_textbrowser")
self.text_browser.setMinimumSize(400, 40)
self.setWindowTitle('Rewind your movie?')
self.text_browser.setPlainText( #bruce 080827 revised text
"You may want to rewind the movie now. The atoms move as the movie "
"progresses, and saving the part without rewinding will save the "
"current positions, which is sometimes useful, but will make the "
"movie invalid, because .dpb files only store deltas relative to "
"the initial atom positions, and don't store the initial positions "
"themselves.")
self.ok_button = QPushButton(self)
self.ok_button.setObjectName("ok_button")
self.ok_button.setText("Rewind movie")
self.cancel_button = QPushButton(self)
self.cancel_button.setObjectName("cancel_button")
self.cancel_button.setText(
"Exit command without rewinding") #bruce 080827 revised text
# Note: this is not, in fact, a cancel button --
# there is no option in the caller to prevent exiting the command.
# There is also no option to "forward to final position",
# though for a minimize movie, that might be most useful.
# [bruce 080827 comment]
layout = QGridLayout(self)
layout.addWidget(self.text_browser, 0, 0, 0, 1)
layout.addWidget(self.ok_button, 1, 0)
layout.addWidget(self.cancel_button, 1, 1)
self.connect(self.ok_button, SIGNAL("clicked()"), self.rewindMovie)
self.connect(self.cancel_button, SIGNAL("clicked()"), self.noThanks)
def __init__(self, movie):
self.movie = movie
QDialog.__init__(self, None)
self.setObjectName("movie_warning")
self.text_browser = QTextBrowser(self)
self.text_browser.setObjectName("movie_warning_textbrowser")
self.text_browser.setMinimumSize(400, 40)
self.setWindowTitle('Rewind your movie?')
self.text_browser.setPlainText(
"You may want to rewind the movie now. If you save the part without "
+
"rewinding the movie, the movie file will become invalid because it "
+
"depends upon the initial atom positions. The atoms move as the movie "
+
"progresses, and saving the part now will save the final positions, "
+ "which are incorrect for the movie you just watched.")
self.ok_button = QPushButton(self)
self.ok_button.setObjectName("ok_button")
self.ok_button.setText("Rewind movie")
self.cancel_button = QPushButton(self)
self.cancel_button.setObjectName("cancel_button")
self.cancel_button.setText("No thanks")
layout = QGridLayout(self)
layout.addWidget(self.text_browser, 0, 0, 0, 1)
layout.addWidget(self.ok_button, 1, 0)
layout.addWidget(self.cancel_button, 1, 1)
self.connect(self.ok_button, SIGNAL("clicked()"), self.rewindMovie)
self.connect(self.cancel_button, SIGNAL("clicked()"), self.noThanks)
def __init__(self, movie):
self.movie = movie
QDialog.__init__(self, None)
self.setObjectName("movie_warning")
self.text_browser = QTextBrowser(self)
self.text_browser.setObjectName("movie_warning_textbrowser")
self.text_browser.setMinimumSize(400, 40)
self.setWindowTitle('Rewind your movie?')
self.text_browser.setPlainText(
"You may want to rewind the movie now. If you save the part without " +
"rewinding the movie, the movie file will become invalid because it " +
"depends upon the initial atom positions. The atoms move as the movie " +
"progresses, and saving the part now will save the final positions, " +
"which are incorrect for the movie you just watched.")
self.ok_button = QPushButton(self)
self.ok_button.setObjectName("ok_button")
self.ok_button.setText("Rewind movie")
self.cancel_button = QPushButton(self)
self.cancel_button.setObjectName("cancel_button")
self.cancel_button.setText("No thanks")
layout = QGridLayout(self)
layout.addWidget(self.text_browser,0,0,0,1)
layout.addWidget(self.ok_button,1,0)
layout.addWidget(self.cancel_button,1,1)
self.connect(self.ok_button,SIGNAL("clicked()"),self.rewindMovie)
self.connect(self.cancel_button,SIGNAL("clicked()"),self.noThanks)
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 settings_dialog(self):
get_label = lambda: self.wallet.get_client().features.label
update_label = lambda: current_label_label.setText("Label: %s" %
get_label())
d = QDialog()
layout = QGridLayout(d)
layout.addWidget(QLabel("Trezor Options"), 0, 0)
layout.addWidget(QLabel("ID:"), 1, 0)
layout.addWidget(
QLabel(" %s" % self.wallet.get_client().get_device_id()), 1, 1)
def modify_label():
response = QInputDialog().getText(
None, "Set New Trezor Label",
"New Trezor Label: (upon submission confirm on Trezor)")
if not response[1]:
return
new_label = str(response[0])
twd.start("Please confirm label change on Trezor")
status = self.wallet.get_client().apply_settings(label=new_label)
twd.stop()
update_label()
current_label_label = QLabel()
update_label()
change_label_button = QPushButton("Modify")
change_label_button.clicked.connect(modify_label)
layout.addWidget(current_label_label, 3, 0)
layout.addWidget(change_label_button, 3, 1)
def remove_pin():
# twd.start("Please confirm pin removal on Trezor")
try:
status = self.wallet.get_client().change_pin(True)
print_error(status)
self.show_message(status)
except Exception, e:
give_error(e)
finally:
def __init__(self, parent, txt):
QDialog.__init__(self, parent)
l = QGridLayout()
self.setLayout(l)
self.setWindowTitle(_('Invalid ISBN'))
w = QLabel(_('Enter an ISBN'))
l.addWidget(w, 0, 0, 1, 2)
w = QLabel(_('ISBN:'))
l.addWidget(w, 1, 0, 1, 1)
self.line_edit = w = QLineEdit()
w.setText(txt)
w.selectAll()
w.textChanged.connect(self.checkText)
l.addWidget(w, 1, 1, 1, 1)
w = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
l.addWidget(w, 2, 0, 1, 2)
w.accepted.connect(self.accept)
w.rejected.connect(self.reject)
self.checkText(self.text())
sz = self.sizeHint()
sz.setWidth(sz.width() + 50)
self.resize(sz)
def __init__(self, parent, txt):
QDialog.__init__(self, parent)
l = QGridLayout()
self.setLayout(l)
self.setWindowTitle(_('Invalid ISBN'))
w = QLabel(_('Enter an ISBN'))
l.addWidget(w, 0, 0, 1, 2)
w = QLabel(_('ISBN:'))
l.addWidget(w, 1, 0, 1, 1)
self.line_edit = w = QLineEdit();
w.setText(txt)
w.selectAll()
w.textChanged.connect(self.checkText)
l.addWidget(w, 1, 1, 1, 1)
w = QDialogButtonBox(QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
l.addWidget(w, 2, 0, 1, 2)
w.accepted.connect(self.accept)
w.rejected.connect(self.reject)
self.checkText(self.text())
sz = self.sizeHint()
sz.setWidth(sz.width()+50)
self.resize(sz)
def settings_dialog(self):
get_label = lambda: self.wallet.get_client().features.label
update_label = lambda: current_label_label.setText("Label: %s" % get_label())
d = QDialog()
layout = QGridLayout(d)
layout.addWidget(QLabel("Trezor Options"),0,0)
layout.addWidget(QLabel("ID:"),1,0)
layout.addWidget(QLabel(" %s" % self.wallet.get_client().get_device_id()),1,1)
def modify_label():
response = QInputDialog().getText(None, "Set New Trezor Label", "New Trezor Label: (upon submission confirm on Trezor)")
if not response[1]:
return
new_label = str(response[0])
twd.start("Please confirm label change on Trezor")
status = self.wallet.get_client().apply_settings(label=new_label)
twd.stop()
update_label()
current_label_label = QLabel()
update_label()
change_label_button = QPushButton("Modify")
change_label_button.clicked.connect(modify_label)
layout.addWidget(current_label_label,3,0)
layout.addWidget(change_label_button,3,1)
def remove_pin():
# twd.start("Please confirm pin removal on Trezor")
try:
status = self.wallet.get_client().change_pin(True)
print_error(status)
self.show_message(status)
except Exception, e:
give_error(e)
finally:
def __init__(self, parent, main, maxSeg):
super(DlgSpecifyOrdering, self).__init__(parent, main)
self.maxSeg = maxSeg
self.setWindowTitle('Enter Ordering')
self.setWindowIcon(QIcon(self.main.iconfile))
buttonbox = QDialogButtonBox(QDialogButtonBox.Ok | \
QDialogButtonBox.Cancel)
self.connect(buttonbox, SIGNAL('accepted()'), self.accept)
self.connect(buttonbox, SIGNAL('rejected()'), self.reject)
layout = QGridLayout()
lbl = QLabel('Enter Ordering as a comma separated list of segment indices between 1 and %d:' % maxSeg)
self.editOrdering = QLineEdit()
h, w = relaxedSizeNChar(self, 50)
self.editOrdering.setMinimumSize(h, w)
self.editOrdering.setMaxLength(MAX_SEGMENTS)
editSegPanel = makeHorizFrame([self.editOrdering, 'stretch'])
layout.addWidget(lbl, 0, 0)
layout.addWidget(editSegPanel, 0, 1)
layout.addWidget(buttonbox, 1, 0)
self.setLayout(layout)
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()
def do_layout(self):
self.central_widget.clear()
self.labels = []
sto = QWidget.setTabOrder
self.central_widget.tabBar().setVisible(False)
tab0 = QWidget(self)
self.central_widget.addTab(tab0, _("&Metadata"))
l = QGridLayout()
tab0.setLayout(l)
# Basic metadata in col 0
tl = QGridLayout()
gb = QGroupBox(_('Basic metadata'), tab0)
l.addWidget(gb, 0, 0, 1, 1)
gb.setLayout(tl)
self.button_box_layout.insertWidget(1, self.fetch_metadata_button)
self.button_box_layout.insertWidget(2, self.config_metadata_button)
sto(self.button_box, self.fetch_metadata_button)
sto(self.fetch_metadata_button, self.config_metadata_button)
sto(self.config_metadata_button, self.title)
def create_row(row, widget, tab_to, button=None, icon=None, span=1):
ql = BuddyLabel(widget)
tl.addWidget(ql, row, 1, 1, 1)
tl.addWidget(widget, row, 2, 1, 1)
if button is not None:
tl.addWidget(button, row, 3, span, 1)
if icon is not None:
button.setIcon(QIcon(I(icon)))
if tab_to is not None:
if button is not None:
sto(widget, button)
sto(button, tab_to)
else:
sto(widget, tab_to)
tl.addWidget(self.swap_title_author_button, 0, 0, 2, 1)
tl.addWidget(self.manage_authors_button, 2, 0, 2, 1)
tl.addWidget(self.paste_isbn_button, 12, 0, 1, 1)
tl.addWidget(self.tags_editor_button, 6, 0, 1, 1)
create_row(0,
self.title,
self.title_sort,
button=self.deduce_title_sort_button,
span=2,
icon='auto_author_sort.png')
create_row(1, self.title_sort, self.authors)
create_row(2,
self.authors,
self.author_sort,
button=self.deduce_author_sort_button,
span=2,
icon='auto_author_sort.png')
create_row(3, self.author_sort, self.series)
create_row(4,
self.series,
self.series_index,
button=self.clear_series_button,
icon='trash.png')
create_row(5, self.series_index, self.tags)
create_row(6, self.tags, self.rating, button=self.clear_tags_button)
create_row(7,
self.rating,
self.pubdate,
button=self.clear_ratings_button)
create_row(8,
self.pubdate,
self.publisher,
button=self.pubdate.clear_button,
icon='trash.png')
create_row(9, self.publisher, self.languages)
create_row(10, self.languages, self.timestamp)
create_row(11,
self.timestamp,
self.identifiers,
button=self.timestamp.clear_button,
icon='trash.png')
create_row(12,
self.identifiers,
self.comments,
button=self.clear_identifiers_button,
icon='trash.png')
sto(self.clear_identifiers_button, self.swap_title_author_button)
sto(self.swap_title_author_button, self.manage_authors_button)
sto(self.manage_authors_button, self.tags_editor_button)
sto(self.tags_editor_button, self.paste_isbn_button)
tl.addItem(QSpacerItem(1, 1, QSizePolicy.Fixed, QSizePolicy.Expanding),
13, 1, 1, 1)
# Custom metadata in col 1
w = getattr(self, 'custom_metadata_widgets_parent', None)
if w is not None:
gb = QGroupBox(_('Custom metadata'), tab0)
gbl = QVBoxLayout()
gb.setLayout(gbl)
sr = QScrollArea(gb)
sr.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
sr.setWidgetResizable(True)
sr.setFrameStyle(QFrame.NoFrame)
sr.setWidget(w)
gbl.addWidget(sr)
l.addWidget(gb, 0, 1, 1, 1)
sp = QSizePolicy()
sp.setVerticalStretch(10)
sp.setHorizontalPolicy(QSizePolicy.Minimum)
sp.setVerticalPolicy(QSizePolicy.Expanding)
gb.setSizePolicy(sp)
self.set_custom_metadata_tab_order()
# comments span col 0 & 1
w = QGroupBox(_('Comments'), tab0)
sp = QSizePolicy()
sp.setVerticalStretch(10)
sp.setHorizontalPolicy(QSizePolicy.Expanding)
sp.setVerticalPolicy(QSizePolicy.Expanding)
w.setSizePolicy(sp)
lb = QHBoxLayout()
w.setLayout(lb)
lb.addWidget(self.comments)
l.addWidget(w, 1, 0, 1, 2)
# Cover & formats in col 3
gb = QGroupBox(_('Cover'), tab0)
lb = QGridLayout()
gb.setLayout(lb)
lb.addWidget(self.cover, 0, 0, 1, 3, alignment=Qt.AlignCenter)
sto(self.manage_authors_button, self.cover.buttons[0])
for i, b in enumerate(self.cover.buttons[:3]):
lb.addWidget(b, 1, i, 1, 1)
sto(b, self.cover.buttons[i + 1])
hl = QHBoxLayout()
for b in self.cover.buttons[3:]:
hl.addWidget(b)
sto(self.cover.buttons[-2], self.cover.buttons[-1])
lb.addLayout(hl, 2, 0, 1, 3)
l.addWidget(gb, 0, 2, 1, 1)
l.addWidget(self.formats_manager, 1, 2, 1, 1)
sto(self.cover.buttons[-1], self.formats_manager)
self.formats_manager.formats.setMaximumWidth(10000)
self.formats_manager.formats.setIconSize(QSize(32, 32))
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()
def __init__(self, window, plugin, device_id):
title = _("%s Settings") % plugin.device
super(SettingsDialog, self).__init__(window, title)
self.setMaximumWidth(540)
devmgr = plugin.device_manager()
handler = window.wallet.handler
thread = window.wallet.thread
# wallet can be None, needn't be window.wallet
wallet = devmgr.wallet_by_id(device_id)
hs_rows, hs_cols = (64, 128)
self.current_label=None
def invoke_client(method, *args, **kw_args):
unpair_after = kw_args.pop('unpair_after', False)
def task():
client = devmgr.client_by_id(device_id, handler)
if not client:
raise RuntimeError("Device not connected")
if method:
getattr(client, method)(*args, **kw_args)
if unpair_after:
devmgr.unpair_id(device_id)
return client.features
thread.add(task, on_success=update)
def update(features):
self.current_label = features.label
set_label_enabled()
bl_hash = features.bootloader_hash.encode('hex')
bl_hash = "\n".join([bl_hash[:32], bl_hash[32:]])
noyes = [_("No"), _("Yes")]
endis = [_("Enable Passphrases"), _("Disable Passphrases")]
disen = [_("Disabled"), _("Enabled")]
setchange = [_("Set a PIN"), _("Change PIN")]
version = "%d.%d.%d" % (features.major_version,
features.minor_version,
features.patch_version)
coins = ", ".join(coin.coin_name for coin in features.coins)
device_label.setText(features.label)
pin_set_label.setText(noyes[features.pin_protection])
passphrases_label.setText(disen[features.passphrase_protection])
bl_hash_label.setText(bl_hash)
label_edit.setText(features.label)
device_id_label.setText(features.device_id)
initialized_label.setText(noyes[features.initialized])
version_label.setText(version)
coins_label.setText(coins)
clear_pin_button.setVisible(features.pin_protection)
clear_pin_warning.setVisible(features.pin_protection)
pin_button.setText(setchange[features.pin_protection])
pin_msg.setVisible(not features.pin_protection)
passphrase_button.setText(endis[features.passphrase_protection])
language_label.setText(features.language)
def set_label_enabled():
label_apply.setEnabled(label_edit.text() != self.current_label)
def rename():
invoke_client('change_label', unicode(label_edit.text()))
def toggle_passphrase():
title = _("Confirm Toggle Passphrase Protection")
msg = _("This will cause your Electrum wallet to be unpaired "
"unless your passphrase was or will be empty.\n\n"
"This is because addresses will no "
"longer correspond to those used by your %s.\n\n"
"You will need to create a new Electrum wallet "
"with the install wizard so that they match.\n\n"
"Are you sure you want to proceed?") % plugin.device
if not self.question(msg, title=title):
return
invoke_client('toggle_passphrase', unpair_after=True)
def change_homescreen():
from PIL import Image # FIXME
dialog = QFileDialog(self, _("Choose Homescreen"))
filename = dialog.getOpenFileName()
if filename:
im = Image.open(str(filename))
if im.size != (hs_cols, hs_rows):
raise Exception('Image must be 64 x 128 pixels')
im = im.convert('1')
pix = im.load()
img = ''
for j in range(hs_rows):
for i in range(hs_cols):
img += '1' if pix[i, j] else '0'
img = ''.join(chr(int(img[i:i + 8], 2))
for i in range(0, len(img), 8))
invoke_client('change_homescreen', img)
def clear_homescreen():
invoke_client('change_homescreen', '\x00')
def set_pin():
invoke_client('set_pin', remove=False)
def clear_pin():
invoke_client('set_pin', remove=True)
def wipe_device():
if wallet and sum(wallet.get_balance()):
title = _("Confirm Device Wipe")
msg = _("Are you SURE you want to wipe the device?\n"
"Your wallet still has bitcoins in it!")
if not self.question(msg, title=title,
icon=QMessageBox.Critical):
return
invoke_client('wipe_device', unpair_after=True)
def slider_moved():
mins = timeout_slider.sliderPosition()
timeout_minutes.setText(_("%2d minutes") % mins)
def slider_released():
seconds = timeout_slider.sliderPosition() * 60
wallet.set_session_timeout(seconds)
# Information tab
info_tab = QWidget()
info_layout = QVBoxLayout(info_tab)
info_glayout = QGridLayout()
info_glayout.setColumnStretch(2, 1)
device_label = QLabel()
pin_set_label = QLabel()
passphrases_label = QLabel()
version_label = QLabel()
device_id_label = QLabel()
bl_hash_label = QLabel()
bl_hash_label.setWordWrap(True)
coins_label = QLabel()
coins_label.setWordWrap(True)
language_label = QLabel()
initialized_label = QLabel()
rows = [
(_("Device Label"), device_label),
(_("PIN set"), pin_set_label),
(_("Passphrases"), passphrases_label),
(_("Firmware Version"), version_label),
(_("Device ID"), device_id_label),
(_("Bootloader Hash"), bl_hash_label),
(_("Supported Coins"), coins_label),
(_("Language"), language_label),
(_("Initialized"), initialized_label),
]
for row_num, (label, widget) in enumerate(rows):
info_glayout.addWidget(QLabel(label), row_num, 0)
info_glayout.addWidget(widget, row_num, 1)
info_layout.addLayout(info_glayout)
# Settings tab
settings_tab = QWidget()
settings_layout = QVBoxLayout(settings_tab)
settings_glayout = QGridLayout()
# Settings tab - Label
label_msg = QLabel(_("Name this %s. If you have mutiple devices "
"their labels help distinguish them.")
% plugin.device)
label_msg.setWordWrap(True)
label_label = QLabel(_("Device Label"))
label_edit = QLineEdit()
label_edit.setMinimumWidth(150)
label_edit.setMaxLength(plugin.MAX_LABEL_LEN)
label_apply = QPushButton(_("Apply"))
label_apply.clicked.connect(rename)
label_edit.textChanged.connect(set_label_enabled)
settings_glayout.addWidget(label_label, 0, 0)
settings_glayout.addWidget(label_edit, 0, 1, 1, 2)
settings_glayout.addWidget(label_apply, 0, 3)
settings_glayout.addWidget(label_msg, 1, 1, 1, -1)
# Settings tab - PIN
pin_label = QLabel(_("PIN Protection"))
pin_button = QPushButton()
pin_button.clicked.connect(set_pin)
settings_glayout.addWidget(pin_label, 2, 0)
settings_glayout.addWidget(pin_button, 2, 1)
pin_msg = QLabel(_("PIN protection is strongly recommended. "
"A PIN is your only protection against someone "
"stealing your bitcoins if they obtain physical "
"access to your %s.") % plugin.device)
pin_msg.setWordWrap(True)
pin_msg.setStyleSheet("color: red")
settings_glayout.addWidget(pin_msg, 3, 1, 1, -1)
# Settings tab - Homescreen
if plugin.device != 'KeepKey': # Not yet supported by KK firmware
homescreen_layout = QHBoxLayout()
homescreen_label = QLabel(_("Homescreen"))
homescreen_change_button = QPushButton(_("Change..."))
homescreen_clear_button = QPushButton(_("Reset"))
homescreen_change_button.clicked.connect(change_homescreen)
homescreen_clear_button.clicked.connect(clear_homescreen)
homescreen_msg = QLabel(_("You can set the homescreen on your "
"device to personalize it. You must "
"choose a %d x %d monochrome black and "
"white image.") % (hs_rows, hs_cols))
homescreen_msg.setWordWrap(True)
settings_glayout.addWidget(homescreen_label, 4, 0)
settings_glayout.addWidget(homescreen_change_button, 4, 1)
settings_glayout.addWidget(homescreen_clear_button, 4, 2)
settings_glayout.addWidget(homescreen_msg, 5, 1, 1, -1)
# Settings tab - Session Timeout
if wallet:
timeout_label = QLabel(_("Session Timeout"))
timeout_minutes = QLabel()
timeout_slider = QSlider(Qt.Horizontal)
timeout_slider.setRange(1, 60)
timeout_slider.setSingleStep(1)
timeout_slider.setTickInterval(5)
timeout_slider.setTickPosition(QSlider.TicksBelow)
timeout_slider.setTracking(True)
timeout_msg = QLabel(
_("Clear the session after the specified period "
"of inactivity. Once a session has timed out, "
"your PIN and passphrase (if enabled) must be "
"re-entered to use the device."))
timeout_msg.setWordWrap(True)
timeout_slider.setSliderPosition(wallet.session_timeout // 60)
slider_moved()
timeout_slider.valueChanged.connect(slider_moved)
timeout_slider.sliderReleased.connect(slider_released)
settings_glayout.addWidget(timeout_label, 6, 0)
settings_glayout.addWidget(timeout_slider, 6, 1, 1, 3)
settings_glayout.addWidget(timeout_minutes, 6, 4)
settings_glayout.addWidget(timeout_msg, 7, 1, 1, -1)
settings_layout.addLayout(settings_glayout)
settings_layout.addStretch(1)
# Advanced tab
advanced_tab = QWidget()
advanced_layout = QVBoxLayout(advanced_tab)
advanced_glayout = QGridLayout()
# Advanced tab - clear PIN
clear_pin_button = QPushButton(_("Disable PIN"))
clear_pin_button.clicked.connect(clear_pin)
clear_pin_warning = QLabel(
_("If you disable your PIN, anyone with physical access to your "
"%s device can spend your bitcoins.") % plugin.device)
clear_pin_warning.setWordWrap(True)
clear_pin_warning.setStyleSheet("color: red")
advanced_glayout.addWidget(clear_pin_button, 0, 2)
advanced_glayout.addWidget(clear_pin_warning, 1, 0, 1, 5)
# Advanced tab - toggle passphrase protection
passphrase_button = QPushButton()
passphrase_button.clicked.connect(toggle_passphrase)
passphrase_msg = WWLabel(PASSPHRASE_HELP)
passphrase_warning = WWLabel(PASSPHRASE_NOT_PIN)
passphrase_warning.setStyleSheet("color: red")
advanced_glayout.addWidget(passphrase_button, 3, 2)
advanced_glayout.addWidget(passphrase_msg, 4, 0, 1, 5)
advanced_glayout.addWidget(passphrase_warning, 5, 0, 1, 5)
# Advanced tab - wipe device
wipe_device_button = QPushButton(_("Wipe Device"))
wipe_device_button.clicked.connect(wipe_device)
wipe_device_msg = QLabel(
_("Wipe the device, removing all data from it. The firmware "
"is left unchanged."))
wipe_device_msg.setWordWrap(True)
wipe_device_warning = QLabel(
_("Only wipe a device if you have the recovery seed written down "
"and the device wallet(s) are empty, otherwise the bitcoins "
"will be lost forever."))
wipe_device_warning.setWordWrap(True)
wipe_device_warning.setStyleSheet("color: red")
advanced_glayout.addWidget(wipe_device_button, 6, 2)
advanced_glayout.addWidget(wipe_device_msg, 7, 0, 1, 5)
advanced_glayout.addWidget(wipe_device_warning, 8, 0, 1, 5)
advanced_layout.addLayout(advanced_glayout)
advanced_layout.addStretch(1)
tabs = QTabWidget(self)
tabs.addTab(info_tab, _("Information"))
tabs.addTab(settings_tab, _("Settings"))
tabs.addTab(advanced_tab, _("Advanced"))
dialog_vbox = QVBoxLayout(self)
dialog_vbox.addWidget(tabs)
dialog_vbox.addLayout(Buttons(CloseButton(self)))
# Update information
invoke_client(None)
def __init__(self,
parent=None,
desc=None,
name=None,
modal=0,
fl=0,
env=None,
type="QDialog"):
if env is None:
import foundation.env as env # this is a little weird... probably it'll be ok, and logically it seems correct.
self.desc = desc
self.typ = type
if type == "QDialog":
QDialog.__init__(self, parent, name, modal, fl)
elif type == "QTextEdit":
QTextEdit.__init__(self, parent, name)
elif type == "QFrame":
QFrame.__init__(self, parent, name)
else:
print "don't know about type == %r" % (type, )
self.image1 = QPixmap()
self.image1.loadFromData(image1_data,
"PNG") # should be: title_icon ####
self.image3 = QPixmap()
self.image3.loadFromData(image3_data, "PNG")
self.image4 = QPixmap()
self.image4.loadFromData(image4_data, "PNG")
self.image5 = QPixmap()
self.image5.loadFromData(image5_data, "PNG")
self.image6 = QPixmap()
self.image6.loadFromData(image6_data, "PNG")
self.image7 = QPixmap()
self.image7.loadFromData(image7_data, "PNG")
self.image0 = QPixmap(image0_data) # should be: border_icon ####
self.image2 = QPixmap(image2_data) # should be: sponsor_pixmap ####
try:
####@@@@
title_icon_name = self.desc.options.get('title_icon')
border_icon_name = self.desc.options.get('border_icon')
if title_icon_name:
self.image1 = imagename_to_pixmap(
title_icon_name) ###@@@ pass icon_path
###@@@ import imagename_to_pixmap or use env function
# or let that func itself be an arg, or have an env arg for it
###e rename it icon_name_to_pixmap, or find_icon? (the latter only if it's ok if it returns an iconset)
###e use iconset instead?
if border_icon_name:
self.image0 = imagename_to_pixmap(border_icon_name)
except:
print_compact_traceback(
"bug in icon-setting code, using fallback icons: ")
pass
if not name:
self.setName("parameter_dialog_or_frame") ###
###k guess this will need: if type == 'QDialog'
self.setIcon(self.image0) # should be: border_icon ####
nanotube_dialogLayout = QVBoxLayout(self, 0, 0,
"nanotube_dialogLayout")
self.heading_frame = QFrame(self, "heading_frame")
self.heading_frame.setPaletteBackgroundColor(QColor(122, 122, 122))
self.heading_frame.setFrameShape(QFrame.NoFrame)
self.heading_frame.setFrameShadow(QFrame.Plain)
heading_frameLayout = QHBoxLayout(self.heading_frame, 0, 3,
"heading_frameLayout")
self.heading_pixmap = QLabel(self.heading_frame, "heading_pixmap")
self.heading_pixmap.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed, 0, 0,
self.heading_pixmap.sizePolicy().hasHeightForWidth()))
self.heading_pixmap.setPixmap(
self.image1) # should be: title_icon ####
self.heading_pixmap.setScaledContents(1)
heading_frameLayout.addWidget(self.heading_pixmap)
self.heading_label = QLabel(self.heading_frame, "heading_label")
self.heading_label.setPaletteForegroundColor(QColor(255, 255, 255))
heading_label_font = QFont(self.heading_label.font())
heading_label_font.setPointSize(12)
heading_label_font.setBold(1)
self.heading_label.setFont(heading_label_font)
heading_frameLayout.addWidget(self.heading_label)
nanotube_dialogLayout.addWidget(self.heading_frame)
self.body_frame = QFrame(self, "body_frame")
self.body_frame.setFrameShape(QFrame.StyledPanel)
self.body_frame.setFrameShadow(QFrame.Raised)
body_frameLayout = QVBoxLayout(self.body_frame, 3, 3,
"body_frameLayout")
self.sponsor_frame = QFrame(self.body_frame, "sponsor_frame")
self.sponsor_frame.setPaletteBackgroundColor(QColor(255, 255, 255))
self.sponsor_frame.setFrameShape(QFrame.StyledPanel)
self.sponsor_frame.setFrameShadow(QFrame.Raised)
sponsor_frameLayout = QHBoxLayout(self.sponsor_frame, 0, 0,
"sponsor_frameLayout")
self.sponsor_btn = QPushButton(self.sponsor_frame, "sponsor_btn")
self.sponsor_btn.setAutoDefault(0) #bruce 060703 bugfix
self.sponsor_btn.setSizePolicy(
QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred, 0, 0,
self.sponsor_btn.sizePolicy().hasHeightForWidth()))
self.sponsor_btn.setPaletteBackgroundColor(QColor(255, 255, 255))
self.sponsor_btn.setPixmap(
self.image2
) # should be: sponsor_pixmap #### [also we'll need to support >1 sponsor]
self.sponsor_btn.setFlat(1)
sponsor_frameLayout.addWidget(self.sponsor_btn)
body_frameLayout.addWidget(self.sponsor_frame)
layout59 = QHBoxLayout(None, 0, 6, "layout59")
left_spacer = QSpacerItem(20, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
layout59.addItem(left_spacer)
self.done_btn = QToolButton(self.body_frame, "done_btn")
self.done_btn.setIcon(QIcon(self.image3))
layout59.addWidget(self.done_btn)
self.abort_btn = QToolButton(self.body_frame, "abort_btn")
self.abort_btn.setIcon(QIcon(self.image4))
layout59.addWidget(self.abort_btn)
self.preview_btn = QToolButton(self.body_frame, "preview_btn")
self.preview_btn.setIcon(QIcon(self.image5))
layout59.addWidget(self.preview_btn)
self.whatsthis_btn = QToolButton(self.body_frame, "whatsthis_btn")
self.whatsthis_btn.setIcon(QIcon(self.image6))
layout59.addWidget(self.whatsthis_btn)
right_spacer = QSpacerItem(20, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
layout59.addItem(right_spacer)
body_frameLayout.addLayout(layout59)
self.groups = []
self.param_getters = {
} # map from param name to get-function (which gets current value out of its widget or controller)
for group_desc in self.desc.kids('group'):
# == start parameters_grpbox ### this will differ for Windows style
header_refs = [
] # keep python refcounted refs to all objects we make (at least the ones pyuic stored in self attrs)
self.parameters_grpbox = QGroupBox(self.body_frame,
"parameters_grpbox")
self.parameters_grpbox.setFrameShape(QGroupBox.StyledPanel)
self.parameters_grpbox.setFrameShadow(QGroupBox.Sunken)
self.parameters_grpbox.setMargin(0)
self.parameters_grpbox.setColumnLayout(0, Qt.Vertical)
self.parameters_grpbox.layout().setSpacing(1)
self.parameters_grpbox.layout().setMargin(4)
parameters_grpboxLayout = QVBoxLayout(
self.parameters_grpbox.layout())
parameters_grpboxLayout.setAlignment(Qt.AlignTop)
layout20 = QHBoxLayout(None, 0, 6, "layout20")
self.nt_parameters_grpbtn = QPushButton(self.parameters_grpbox,
"nt_parameters_grpbtn")
self.nt_parameters_grpbtn.setSizePolicy(
QSizePolicy(
QSizePolicy.Minimum, QSizePolicy.Fixed, 0, 0,
self.nt_parameters_grpbtn.sizePolicy().hasHeightForWidth())
)
self.nt_parameters_grpbtn.setMaximumSize(QSize(16, 16))
self.nt_parameters_grpbtn.setAutoDefault(0)
self.nt_parameters_grpbtn.setIcon(QIcon(
self.image7)) ### not always right, but doesn't matter
self.nt_parameters_grpbtn.setFlat(1)
layout20.addWidget(self.nt_parameters_grpbtn)
self.parameters_grpbox_label = QLabel(self.parameters_grpbox,
"parameters_grpbox_label")
self.parameters_grpbox_label.setSizePolicy(
QSizePolicy(
QSizePolicy.Preferred, QSizePolicy.Minimum, 0, 0,
self.parameters_grpbox_label.sizePolicy().
hasHeightForWidth()))
self.parameters_grpbox_label.setAlignment(QLabel.AlignVCenter)
layout20.addWidget(self.parameters_grpbox_label)
gbx_spacer1 = QSpacerItem(67, 16, QSizePolicy.Expanding,
QSizePolicy.Minimum)
layout20.addItem(gbx_spacer1)
parameters_grpboxLayout.addLayout(layout20)
nt_parameters_body_layout = QGridLayout(
None, 1, 1, 0, 6, "nt_parameters_body_layout"
) ### what is 6 -- is it related to number of items???
# is it 6 in all the ones we got, but that could be a designer error so i better look it up sometime.
# == start its kids
# will use from above: self.parameters_grpbox, nt_parameters_body_layout
nextrow = 0 # which row of the QGridLayout to start filling next (loop variable)
hidethese = [
] # set of objects to hide or show, when this group is closed or opened
for param in group_desc.kids('parameter'):
# param (a group subobj desc) is always a parameter, but we already plan to extend this beyond that,
# so we redundantly test for this here.
getter = None
paramname = None
# set these for use by uniform code at the end (e.g. for tooltips)
editfield = None
label = None
if param.isa('parameter'):
label = QLabel(self.parameters_grpbox, "members_label")
label.setAlignment(QLabel.AlignVCenter | QLabel.AlignRight)
nt_parameters_body_layout.addWidget(label, nextrow, 0)
hidethese.append(label)
thisrow = nextrow
nextrow += 1
#e following should be known in a place that knows the input language, not here
paramname = param.options.get('name') or (
param.args and param.args[0]) or "?"
paramlabel = param.options.get(
'label'
) or paramname ##e wrong, label "" or none ought to be possible
# QtGui.QApplication.translate(self.__class__.__name__, "xyz")
label.setText(
QtGui.QApplication.translate(self.__class__.__name__,
paramlabel))
if param.isa('parameter',
widget='combobox',
type=('str', None)):
self.members_combox = QComboBox(
0, self.parameters_grpbox,
"members_combox") ###k what's 0?
editfield = self.members_combox
#### it probably needs a handler class, and then that could do this setup
self.members_combox.clear()
default = param.options.get(
'default', None) # None is not equal to any string
thewidgetkid = param.kids(
'widget'
)[-1] # kluge; need to think what the desc method for this should be
for item in thewidgetkid.kids('item'):
itemval = item.args[0]
itemtext = itemval
self.members_combox.insertItem(
QtGui.QApplication.translate(
self.__class__.__name__,
itemtext)) #k __tr ok??
if itemval == default: #k or itemtext?
pass ##k i find no setItem in our py code, so not sure yet what to do for this.
nt_parameters_body_layout.addWidget(
self.members_combox, thisrow, 1)
hidethese.append(self.members_combox)
getter = (lambda combobox=self.members_combox: str(
combobox.currentText()))
##e due to __tr or non-str values, it might be better to use currentIndex and look it up in a table
# (though whether __tr is good here might depend on what it's used for)
elif param.isa('parameter',
widget=('lineedit', None),
type=('str', None)):
# this covers explicit str|lineedit, and 3 default cases str, lineedit, neither.
# (i.e. if you say parameter and nothing else, it's str lineedit by default.)
self.length_linedit = QLineEdit(self.parameters_grpbox,
"length_linedit")
editfield = self.length_linedit
nt_parameters_body_layout.addWidget(
self.length_linedit, thisrow, 1)
hidethese.append(self.length_linedit)
default = str(param.options.get('default', ""))
self.length_linedit.setText(
QtGui.QApplication.translate(self.__class__.__name__,
default)) # __tr ok?
getter = (lambda lineedit=self.length_linedit: str(
lineedit.text()))
elif param.isa('parameter',
widget=('lineedit', None),
type='float'):
self.length_linedit = QLineEdit(self.parameters_grpbox,
"length_linedit")
editfield = self.length_linedit
nt_parameters_body_layout.addWidget(
self.length_linedit, thisrow, 1)
hidethese.append(self.length_linedit)
controller = FloatLineeditController_Qt(
self, param, self.length_linedit)
header_refs.append(controller)
getter = controller.get_value
elif param.isa('parameter', widget = ('spinbox', None), type = 'int') or \
param.isa('parameter', widget = ('spinbox'), type = None):
self.chirality_N_spinbox = QSpinBox(
self.parameters_grpbox, "chirality_N_spinbox"
) # was chirality_m_spinbox, now chirality_N_spinbox
editfield = self.chirality_N_spinbox
### seems like Qt defaults for min and max are 0,100 -- way too small a range!
if param.options.has_key('min') or 1:
self.chirality_N_spinbox.setMinimum(
param.options.get('min', -999999999)) # was 0
if param.options.has_key('max') or 1:
self.chirality_N_spinbox.setMaximum(
param.options.get(
'max',
+999999999)) # wasn't in egcode, but needed
self.chirality_N_spinbox.setValue(
param.options.get('default', 0)) # was 5
##e note: i suspect this default 0 should come from something that knows this desc grammar.
suffix = param.options.get('suffix', '')
if suffix:
self.chirality_N_spinbox.setSuffix(
QtGui.QApplication.translate(
self.__class__.__name__, suffix))
else:
self.chirality_N_spinbox.setSuffix(
QString.null) # probably not needed
nt_parameters_body_layout.addWidget(
self.chirality_N_spinbox, thisrow, 1)
hidethese.append(self.chirality_N_spinbox)
getter = self.chirality_N_spinbox.value # note: it also has .text, which includes suffix
else:
print "didn't match:", param ###e improve this
# things done the same way for all kinds of param-editing widgets
if 1: #bruce 060703 moved this down here, as bugfix
# set tooltip (same one for editfield and label)
tooltip = param.options.get('tooltip', '')
###e do it for more kinds of params; share the code somehow; do it in controller, or setup-aid?
###k QToolTip appropriateness; tooltip option might be entirely untested
if tooltip and label:
QToolTip.add(
label,
QtGui.QApplication.translate(
self.__class__.__name__, tooltip))
if tooltip and editfield:
QToolTip.add(
editfield,
QtGui.QApplication.translate(
self.__class__.__name__, tooltip)
) ##k ok?? review once not all params have same-row labels.
if getter and paramname and paramname != '?':
self.param_getters[paramname] = getter
### also bind these params to actions...
continue # next param
header_refs.extend([
self.parameters_grpbox, self.nt_parameters_grpbtn,
self.parameters_grpbox_label
])
# now create the logic/control object for the group
group = CollapsibleGroupController_Qt(self, group_desc,
header_refs, hidethese,
self.nt_parameters_grpbtn)
### maybe ask env for the class to use for this?
self.groups.append(
group
) ### needed?? only for scanning the params, AFAIK -- oh, and to maintain a python refcount.
# from languageChange:
if 1: # i don't know if these are needed:
self.parameters_grpbox.setTitle(QString.null)
self.nt_parameters_grpbtn.setText(QString.null)
self.parameters_grpbox_label.setText(
QtGui.QApplication.translate(
self.__class__.__name__,
group_desc.args[0])) # was "Nanotube Parameters"
##e note that it's questionable in the syntax design for this property of a group (overall group label)
# to be in that position (desc arg 0).
# == end its kids
parameters_grpboxLayout.addLayout(nt_parameters_body_layout)
body_frameLayout.addWidget(self.parameters_grpbox)
# == end parameters groupbox
continue # next group
nanotube_dialogLayout.addWidget(self.body_frame)
spacer14 = QSpacerItem(20, 20, QSizePolicy.Minimum,
QSizePolicy.Expanding)
nanotube_dialogLayout.addItem(spacer14)
layout42 = QHBoxLayout(None, 4, 6, "layout42")
btm_spacer = QSpacerItem(59, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
layout42.addItem(btm_spacer)
self.cancel_btn = QPushButton(self, "cancel_btn")
self.cancel_btn.setAutoDefault(0) #bruce 060703 bugfix
layout42.addWidget(self.cancel_btn)
self.ok_btn = QPushButton(self, "ok_btn")
self.ok_btn.setAutoDefault(0) #bruce 060703 bugfix
layout42.addWidget(self.ok_btn)
nanotube_dialogLayout.addLayout(layout42)
self.languageChange()
self.resize(
QSize(246, 618).expandedTo(self.minimumSizeHint())
) ### this size will need to be adjusted (guess -- it's only place overall size is set)
qt4todo('self.clearWState(Qt.WState_Polished)')
## self.connect(self.nt_parameters_grpbtn,SIGNAL("clicked()"),self.toggle_nt_parameters_grpbtn) ####
# new:
for button, methodname in (
(self.sponsor_btn,
'do_sponsor_btn'), #e generalize to more than one sponsor button
(self.done_btn, 'do_done_btn'),
(self.abort_btn, 'do_abort_btn'),
(self.preview_btn, 'do_preview_btn'),
(self.whatsthis_btn, 'do_whatsthis_btn'),
(self.cancel_btn, 'do_cancel_btn'),
(self.ok_btn, 'do_ok_btn')):
if hasattr(self, methodname):
self.connect(button, SIGNAL("clicked()"),
getattr(self, methodname))
return
def __init__(self, win=None):
import string
QDialog.__init__(self, win)
self.setWindowTitle('Manually edit sim parameters')
layout = QGridLayout(self)
layout.setMargin(1)
layout.setSpacing(-1)
layout.setObjectName("SimParameterDialog")
for i in range(len(_sim_param_table)):
attr, paramtype = _sim_param_table[i]
current = sim_param_values[attr]
currentStr = str(current)
label = QLabel(attr + ' (' + paramtype + ')', self)
layout.addWidget(label, i, 0)
if paramtype == BOOLEAN:
label = QLabel(currentStr, self)
layout.addWidget(label, i, 1)
def falseFunc(attr=attr, label=label):
sim_param_values[attr] = False
label.setText('False')
def trueFunc(attr=attr, label=label):
sim_param_values[attr] = True
label.setText('True')
btn = QPushButton(self)
btn.setText('True')
layout.addWidget(btn, i, 2)
self.connect(btn, SIGNAL("clicked()"), trueFunc)
btn = QPushButton(self)
btn.setText('False')
layout.addWidget(btn, i, 3)
self.connect(btn, SIGNAL("clicked()"), falseFunc)
else:
label = QLabel(self)
label.setText(currentStr)
layout.addWidget(label, i, 1)
linedit = QLineEdit(self)
linedit.setText(currentStr)
layout.addWidget(linedit, i, 2)
def change(attr=attr,
linedit=linedit,
paramtype=paramtype,
label=label):
txt = str(linedit.text())
label.setText(txt)
if paramtype == STRING:
sim_param_values[attr] = txt
elif paramtype == INT:
if txt.startswith('0x') or txt.startswith('0X'):
n = string.atoi(txt[2:], 16)
else:
n = string.atoi(txt)
sim_param_values[attr] = n
elif paramtype == FLOAT:
sim_param_values[attr] = string.atof(txt)
btn = QPushButton(self)
btn.setText('OK')
layout.addWidget(btn, i, 3)
self.connect(btn, SIGNAL("clicked()"), change)
btn = QPushButton(self)
btn.setText('Done')
layout.addWidget(btn, len(_sim_param_table), 0, len(_sim_param_table),
4)
def done(self=self):
global sim_params_set
sim_params_set = True
#import pprint
#pprint.pprint(sim_param_values)
self.close()
self.connect(btn, SIGNAL("clicked()"), done)
def populate_metadata_page(layout, db, book_id, bulk=False, two_column=False, parent=None):
def widget_factory(typ, key):
if bulk:
w = bulk_widgets[typ](db, key, parent)
else:
w = widgets[typ](db, key, parent)
if book_id is not None:
w.initialize(book_id)
return w
fm = db.field_metadata
# Get list of all non-composite custom fields. We must make widgets for these
fields = fm.custom_field_keys(include_composites=False)
cols_to_display = fields
cols_to_display.sort(key=partial(field_sort_key, fm=fm))
# This will contain the fields in the order to display them
cols = []
# The fields named here must be first in the widget list
tweak_cols = tweaks['metadata_edit_custom_column_order']
comments_in_tweak = 0
for key in (tweak_cols or ()):
# Add the key if it really exists in the database
if key in cols_to_display:
cols.append(key)
if fm[key]['datatype'] == 'comments':
comments_in_tweak += 1
# Add all the remaining fields
comments_not_in_tweak = 0
for key in cols_to_display:
if key not in cols:
cols.append(key)
if fm[key]['datatype'] == 'comments':
comments_not_in_tweak += 1
count = len(cols)
layout_rows_for_comments = 9
if two_column:
turnover_point = ((count-comments_not_in_tweak+1) +
comments_in_tweak*(layout_rows_for_comments-1))/2
else:
# Avoid problems with multi-line widgets
turnover_point = count + 1000
ans = []
column = row = base_row = max_row = 0
for key in cols:
if not fm[key]['is_editable']:
continue # this almost never happens
dt = fm[key]['datatype']
if dt == 'composite' or (bulk and dt == 'comments'):
continue
w = widget_factory(dt, fm[key]['colnum'])
ans.append(w)
if two_column and dt == 'comments':
# Here for compatibility with old layout. Comments always started
# in the left column
comments_in_tweak -= 1
# no special processing if the comment field was named in the tweak
if comments_in_tweak < 0 and comments_not_in_tweak > 0:
# Force a turnover, adding comments widgets below max_row.
# Save the row to return to if we turn over again
column = 0
row = max_row
base_row = row
turnover_point = row + (comments_not_in_tweak * layout_rows_for_comments)/2
comments_not_in_tweak = 0
l = QGridLayout()
if dt == 'comments':
layout.addLayout(l, row, column, layout_rows_for_comments, 1)
layout.setColumnStretch(column, 100)
row += layout_rows_for_comments
else:
layout.addLayout(l, row, column, 1, 1)
layout.setColumnStretch(column, 100)
row += 1
for c in range(0, len(w.widgets), 2):
if dt != 'comments':
w.widgets[c].setWordWrap(True)
w.widgets[c].setBuddy(w.widgets[c+1])
l.addWidget(w.widgets[c], c, 0)
l.addWidget(w.widgets[c+1], c, 1)
l.setColumnStretch(1, 10000)
else:
l.addWidget(w.widgets[0], 0, 0, 1, 2)
l.addItem(QSpacerItem(0, 0, vPolicy=QSizePolicy.Expanding), c, 0, 1, 1)
max_row = max(max_row, row)
if row >= turnover_point:
column = 1
turnover_point = count + 1000
row = base_row
items = []
if len(ans) > 0:
items.append(QSpacerItem(10, 10, QSizePolicy.Minimum,
QSizePolicy.Expanding))
layout.addItem(items[-1], layout.rowCount(), 0, 1, 1)
layout.setRowStretch(layout.rowCount()-1, 100)
return ans, items
def do_layout(self):
self.central_widget.clear()
self.labels = []
sto = QWidget.setTabOrder
self.central_widget.tabBar().setVisible(False)
tab0 = QWidget(self)
self.central_widget.addTab(tab0, _("&Metadata"))
l = QGridLayout()
tab0.setLayout(l)
# Basic metadata in col 0
tl = QGridLayout()
gb = QGroupBox(_('Basic metadata'), tab0)
l.addWidget(gb, 0, 0, 1, 1)
gb.setLayout(tl)
self.button_box_layout.insertWidget(1, self.fetch_metadata_button)
self.button_box_layout.insertWidget(2, self.config_metadata_button)
sto(self.button_box, self.fetch_metadata_button)
sto(self.fetch_metadata_button, self.config_metadata_button)
sto(self.config_metadata_button, self.title)
def create_row(row, widget, tab_to, button=None, icon=None, span=1):
ql = BuddyLabel(widget)
tl.addWidget(ql, row, 1, 1, 1)
tl.addWidget(widget, row, 2, 1, 1)
if button is not None:
tl.addWidget(button, row, 3, span, 1)
if icon is not None:
button.setIcon(QIcon(I(icon)))
if tab_to is not None:
if button is not None:
sto(widget, button)
sto(button, tab_to)
else:
sto(widget, tab_to)
tl.addWidget(self.swap_title_author_button, 0, 0, 2, 1)
tl.addWidget(self.manage_authors_button, 2, 0, 2, 1)
tl.addWidget(self.paste_isbn_button, 12, 0, 1, 1)
tl.addWidget(self.tags_editor_button, 6, 0, 1, 1)
create_row(0, self.title, self.title_sort,
button=self.deduce_title_sort_button, span=2,
icon='auto_author_sort.png')
create_row(1, self.title_sort, self.authors)
create_row(2, self.authors, self.author_sort,
button=self.deduce_author_sort_button,
span=2, icon='auto_author_sort.png')
create_row(3, self.author_sort, self.series)
create_row(4, self.series, self.series_index,
button=self.clear_series_button, icon='trash.png')
create_row(5, self.series_index, self.tags)
create_row(6, self.tags, self.rating, button=self.clear_tags_button)
create_row(7, self.rating, self.pubdate, button=self.clear_ratings_button)
create_row(8, self.pubdate, self.publisher,
button=self.pubdate.clear_button, icon='trash.png')
create_row(9, self.publisher, self.languages)
create_row(10, self.languages, self.timestamp)
create_row(11, self.timestamp, self.identifiers,
button=self.timestamp.clear_button, icon='trash.png')
create_row(12, self.identifiers, self.comments,
button=self.clear_identifiers_button, icon='trash.png')
sto(self.clear_identifiers_button, self.swap_title_author_button)
sto(self.swap_title_author_button, self.manage_authors_button)
sto(self.manage_authors_button, self.tags_editor_button)
sto(self.tags_editor_button, self.paste_isbn_button)
tl.addItem(QSpacerItem(1, 1, QSizePolicy.Fixed, QSizePolicy.Expanding),
13, 1, 1 ,1)
# Custom metadata in col 1
w = getattr(self, 'custom_metadata_widgets_parent', None)
if w is not None:
gb = QGroupBox(_('Custom metadata'), tab0)
gbl = QVBoxLayout()
gb.setLayout(gbl)
sr = QScrollArea(gb)
sr.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
sr.setWidgetResizable(True)
sr.setFrameStyle(QFrame.NoFrame)
sr.setWidget(w)
gbl.addWidget(sr)
l.addWidget(gb, 0, 1, 1, 1)
sp = QSizePolicy()
sp.setVerticalStretch(10)
sp.setHorizontalPolicy(QSizePolicy.Minimum)
sp.setVerticalPolicy(QSizePolicy.Expanding)
gb.setSizePolicy(sp)
self.set_custom_metadata_tab_order()
# comments span col 0 & 1
w = QGroupBox(_('Comments'), tab0)
sp = QSizePolicy()
sp.setVerticalStretch(10)
sp.setHorizontalPolicy(QSizePolicy.Expanding)
sp.setVerticalPolicy(QSizePolicy.Expanding)
w.setSizePolicy(sp)
lb = QHBoxLayout()
w.setLayout(lb)
lb.addWidget(self.comments)
l.addWidget(w, 1, 0, 1, 2)
# Cover & formats in col 3
gb = QGroupBox(_('Cover'), tab0)
lb = QGridLayout()
gb.setLayout(lb)
lb.addWidget(self.cover, 0, 0, 1, 3, alignment=Qt.AlignCenter)
sto(self.manage_authors_button, self.cover.buttons[0])
for i, b in enumerate(self.cover.buttons[:3]):
lb.addWidget(b, 1, i, 1, 1)
sto(b, self.cover.buttons[i+1])
hl = QHBoxLayout()
for b in self.cover.buttons[3:]:
hl.addWidget(b)
sto(self.cover.buttons[-2], self.cover.buttons[-1])
lb.addLayout(hl, 2, 0, 1, 3)
l.addWidget(gb, 0, 2, 1, 1)
l.addWidget(self.formats_manager, 1, 2, 1, 1)
sto(self.cover.buttons[-1], self.formats_manager)
self.formats_manager.formats.setMaximumWidth(10000)
self.formats_manager.formats.setIconSize(QSize(32, 32))
def do_layout(self):
self.central_widget.clear()
self.tabs = []
self.labels = []
sto = QWidget.setTabOrder
self.on_drag_enter.connect(self.handle_drag_enter)
self.tabs.append(DragTrackingWidget(self, self.on_drag_enter))
self.central_widget.addTab(self.tabs[0], _("&Metadata"))
self.tabs[0].l = QGridLayout()
self.tabs[0].setLayout(self.tabs[0].l)
self.tabs.append(QWidget(self))
self.central_widget.addTab(self.tabs[1], _("&Cover and formats"))
self.tabs[1].l = QGridLayout()
self.tabs[1].setLayout(self.tabs[1].l)
# accept drop events so we can automatically switch to the second tab to
# drop covers and formats
self.tabs[0].setAcceptDrops(True)
# Tab 0
tab0 = self.tabs[0]
tl = QGridLayout()
gb = QGroupBox(_('&Basic metadata'), self.tabs[0])
self.tabs[0].l.addWidget(gb, 0, 0, 1, 1)
gb.setLayout(tl)
self.button_box_layout.insertWidget(1, self.fetch_metadata_button)
self.button_box_layout.insertWidget(2, self.config_metadata_button)
sto(self.button_box, self.fetch_metadata_button)
sto(self.fetch_metadata_button, self.config_metadata_button)
sto(self.config_metadata_button, self.title)
def create_row(row, widget, tab_to, button=None, icon=None, span=1):
ql = BuddyLabel(widget)
tl.addWidget(ql, row, 1, 1, 1)
tl.addWidget(widget, row, 2, 1, 1)
if button is not None:
tl.addWidget(button, row, 3, span, 1)
if icon is not None:
button.setIcon(QIcon(I(icon)))
if tab_to is not None:
if button is not None:
sto(widget, button)
sto(button, tab_to)
else:
sto(widget, tab_to)
tl.addWidget(self.swap_title_author_button, 0, 0, 2, 1)
tl.addWidget(self.manage_authors_button, 2, 0, 1, 1)
tl.addWidget(self.paste_isbn_button, 12, 0, 1, 1)
tl.addWidget(self.tags_editor_button, 6, 0, 1, 1)
create_row(0, self.title, self.title_sort,
button=self.deduce_title_sort_button, span=2,
icon='auto_author_sort.png')
create_row(1, self.title_sort, self.authors)
create_row(2, self.authors, self.author_sort,
button=self.deduce_author_sort_button,
span=2, icon='auto_author_sort.png')
create_row(3, self.author_sort, self.series)
create_row(4, self.series, self.series_index,
button=self.clear_series_button, icon='trash.png')
create_row(5, self.series_index, self.tags)
create_row(6, self.tags, self.rating, button=self.clear_tags_button)
create_row(7, self.rating, self.pubdate, button=self.clear_ratings_button)
create_row(8, self.pubdate, self.publisher,
button=self.pubdate.clear_button, icon='trash.png')
create_row(9, self.publisher, self.languages)
create_row(10, self.languages, self.timestamp)
create_row(11, self.timestamp, self.identifiers,
button=self.timestamp.clear_button, icon='trash.png')
create_row(12, self.identifiers, self.comments,
button=self.clear_identifiers_button, icon='trash.png')
sto(self.clear_identifiers_button, self.swap_title_author_button)
sto(self.swap_title_author_button, self.manage_authors_button)
sto(self.manage_authors_button, self.tags_editor_button)
sto(self.tags_editor_button, self.paste_isbn_button)
tl.addItem(QSpacerItem(1, 1, QSizePolicy.Fixed, QSizePolicy.Expanding),
13, 1, 1 ,1)
w = getattr(self, 'custom_metadata_widgets_parent', None)
if w is not None:
gb = QGroupBox(_('C&ustom metadata'), tab0)
gbl = QVBoxLayout()
gb.setLayout(gbl)
sr = QScrollArea(tab0)
sr.setWidgetResizable(True)
sr.setFrameStyle(QFrame.NoFrame)
sr.setWidget(w)
gbl.addWidget(sr)
self.tabs[0].l.addWidget(gb, 0, 1, 1, 1)
sto(self.identifiers, gb)
w = QGroupBox(_('&Comments'), tab0)
sp = QSizePolicy()
sp.setVerticalStretch(10)
sp.setHorizontalPolicy(QSizePolicy.Expanding)
sp.setVerticalPolicy(QSizePolicy.Expanding)
w.setSizePolicy(sp)
l = QHBoxLayout()
w.setLayout(l)
l.addWidget(self.comments)
tab0.l.addWidget(w, 1, 0, 1, 2)
# Tab 1
tab1 = self.tabs[1]
wsp = QWidget(tab1)
wgl = QVBoxLayout()
wsp.setLayout(wgl)
# right-hand side of splitter
gb = QGroupBox(_('Change cover'), tab1)
l = QGridLayout()
gb.setLayout(l)
for i, b in enumerate(self.cover.buttons[:3]):
l.addWidget(b, 0, i, 1, 1)
sto(b, self.cover.buttons[i+1])
hl = QHBoxLayout()
for b in self.cover.buttons[3:]:
hl.addWidget(b)
sto(self.cover.buttons[-2], self.cover.buttons[-1])
l.addLayout(hl, 1, 0, 1, 3)
wgl.addWidget(gb)
wgl.addItem(QSpacerItem(10, 10, QSizePolicy.Expanding,
QSizePolicy.Expanding))
wgl.addItem(QSpacerItem(10, 10, QSizePolicy.Expanding,
QSizePolicy.Expanding))
wgl.addWidget(self.formats_manager)
self.splitter = QSplitter(Qt.Horizontal, tab1)
tab1.l.addWidget(self.splitter)
self.splitter.addWidget(self.cover)
self.splitter.addWidget(wsp)
self.formats_manager.formats.setMaximumWidth(10000)
self.formats_manager.formats.setIconSize(QSize(64, 64))
def __init__(self, gui, existing_names, editing=None):
QDialog.__init__(self, gui)
self.gui = gui
self.existing_names = existing_names
if editing:
self.setWindowTitle(_('Edit virtual library'))
else:
self.setWindowTitle(_('Create virtual library'))
self.setWindowIcon(QIcon(I('lt.png')))
gl = QGridLayout()
self.setLayout(gl)
self.la1 = la1 = QLabel(_('Virtual library &name:'))
gl.addWidget(la1, 0, 0)
self.vl_name = QComboBox()
self.vl_name.setEditable(True)
self.vl_name.lineEdit().setMaxLength(MAX_VIRTUAL_LIBRARY_NAME_LENGTH)
la1.setBuddy(self.vl_name)
gl.addWidget(self.vl_name, 0, 1)
self.editing = editing
self.saved_searches_label = QLabel('')
self.saved_searches_label.setTextInteractionFlags(
Qt.TextSelectableByMouse)
gl.addWidget(self.saved_searches_label, 2, 0, 1, 2)
self.la2 = la2 = QLabel(_('&Search expression:'))
gl.addWidget(la2, 1, 0)
self.vl_text = QLineEdit()
self.vl_text.textChanged.connect(self.search_text_changed)
la2.setBuddy(self.vl_text)
gl.addWidget(self.vl_text, 1, 1)
self.vl_text.setText(_build_full_search_string(self.gui))
self.sl = sl = QLabel(
'<p>' + _('Create a virtual library based on: ') +
('<a href="author.{0}">{0}</a>, '
'<a href="tag.{1}">{1}</a>, '
'<a href="publisher.{2}">{2}</a>, '
'<a href="series.{3}">{3}</a>, '
'<a href="search.{4}">{4}</a>.').format(_('Authors'), _(
'Tags'), _('Publishers'), _('Series'), _('Saved Searches')))
sl.setWordWrap(True)
sl.setTextInteractionFlags(Qt.LinksAccessibleByMouse)
sl.linkActivated.connect(self.link_activated)
gl.addWidget(sl, 3, 0, 1, 2)
gl.setRowStretch(3, 10)
self.hl = hl = QLabel(
_('''
<h2>Virtual Libraries</h2>
<p>Using <i>virtual libraries</i> you can restrict calibre to only show
you books that match a search. When a virtual library is in effect, calibre
behaves as though the library contains only the matched books. The Tag Browser
display only the tags/authors/series/etc. that belong to the matched books and any searches
you do will only search within the books in the virtual library. This
is a good way to partition your large library into smaller and easier to work with subsets.</p>
<p>For example you can use a Virtual Library to only show you books with the Tag <i>"Unread"</i>
or only books by <i>"My Favorite Author"</i> or only books in a particular series.</p>
<p>More information and examples are available in the
<a href="http://manual.calibre-ebook.com/virtual_libraries.html">User Manual</a>.</p>
'''))
hl.setWordWrap(True)
hl.setOpenExternalLinks(True)
hl.setFrameStyle(hl.StyledPanel)
gl.addWidget(hl, 0, 3, 4, 1)
bb = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
gl.addWidget(bb, 4, 0, 1, 0)
if editing:
db = self.gui.current_db
virt_libs = db.prefs.get('virtual_libraries', {})
for dex, vl in enumerate(sorted(virt_libs.keys(), key=sort_key)):
self.vl_name.addItem(vl, virt_libs.get(vl, ''))
if vl == editing:
self.vl_name.setCurrentIndex(dex)
self.original_index = dex
self.original_search = virt_libs.get(editing, '')
self.vl_text.setText(self.original_search)
self.new_name = editing
self.vl_name.currentIndexChanged[int].connect(
self.name_index_changed)
self.vl_name.lineEdit().textEdited.connect(self.name_text_edited)
self.resize(self.sizeHint() + QSize(150, 25))
def __init__(self, main):
self.main = main
##########################################################################
##### Display the conversion values based on the Coinbase API
self.lastPriceFetch = 0
self.lblHeader = QRichLabel(tr("""<b>Tracking buy and sell prices on
Coinbase every 60 seconds</b>"""), doWrap=False)
self.lblLastTime = QRichLabel('', doWrap=False)
self.lblSellLabel = QRichLabel(tr('Coinbase <b>Sell</b> Price (USD):'), doWrap=False)
self.lblBuyLabel = QRichLabel(tr('Coinbase <b>Buy</b> Price (USD):'), doWrap=False)
self.lblSellPrice = QRichLabel('<Not Available>')
self.lblBuyPrice = QRichLabel('<Not Available>')
self.lastSellStr = ''
self.lastBuyStr = ''
self.btnUpdate = QPushButton(tr('Check Now'))
self.main.connect(self.btnUpdate, SIGNAL('clicked()'), self.checkUpdatePrice)
##########################################################################
##### A calculator for converting prices between USD and BTC
lblCalcTitle = QRichLabel(tr("""Convert between USD and BTC using
Coinbase sell price"""), hAlign=Qt.AlignHCenter, doWrap=False)
self.edtEnterUSD = QLineEdit()
self.edtEnterBTC = QLineEdit()
self.lblEnterUSD1 = QRichLabel('$')
self.lblEnterUSD2 = QRichLabel('USD')
self.lblEnterBTC = QRichLabel('BTC')
btnClear = QPushButton('Clear')
self.main.connect(self.edtEnterUSD, SIGNAL('textEdited(QString)'), self.updateCalcBTC)
self.main.connect(self.edtEnterBTC, SIGNAL('textEdited(QString)'), self.updateCalcUSD)
def clearCalc():
self.edtEnterUSD.setText('')
self.edtEnterBTC.setText('')
self.main.connect(btnClear, SIGNAL('clicked()'), clearCalc)
frmCalcMid = makeHorizFrame( [self.lblEnterUSD1,
self.edtEnterUSD,
self.lblEnterUSD2,
'Stretch',
self.edtEnterBTC,
self.lblEnterBTC])
frmCalcClear = makeHorizFrame(['Stretch', btnClear, 'Stretch'])
frmCalc = makeVertFrame([lblCalcTitle, frmCalcMid, frmCalcClear], STYLE_PLAIN)
##########################################################################
##### A table showing you the total balance of each wallet in USD and BTC
lblWltTableTitle = QRichLabel(tr("Wallet balances converted to USD"),
doWrap=False, hAlign=Qt.AlignHCenter)
numWallets = len(self.main.walletMap)
self.wltTable = QTableWidget(self.main)
self.wltTable.setRowCount(numWallets)
self.wltTable.setColumnCount(4)
self.wltTable.horizontalHeader().setStretchLastSection(True)
self.wltTable.setMinimumWidth(600)
##########################################################################
##### Setup the main layout for the tab
mainLayout = QGridLayout()
i=0
mainLayout.addWidget(self.lblHeader, i,0, 1,3)
i+=1
mainLayout.addItem(QSpacerItem(15,15), i,0)
mainLayout.addWidget(self.lblSellLabel, i,1)
mainLayout.addWidget(self.lblSellPrice, i,2)
i+=1
mainLayout.addItem(QSpacerItem(15,15), i,0)
mainLayout.addWidget(self.lblBuyLabel, i,1)
mainLayout.addWidget(self.lblBuyPrice, i,2)
i+=1
mainLayout.addWidget(self.lblLastTime, i,0, 1,2)
mainLayout.addWidget(self.btnUpdate, i,2)
i+=1
mainLayout.addItem(QSpacerItem(20,20), i,0)
i+=1
mainLayout.addWidget(frmCalc, i,0, 1,3)
i+=1
mainLayout.addItem(QSpacerItem(30,30), i,0)
i+=1
mainLayout.addWidget(lblWltTableTitle, i,0, 1,3)
i+=1
mainLayout.addWidget(self.wltTable, i,0, 1,3)
mainLayout.setColumnStretch(0,0)
mainLayout.setColumnStretch(1,1)
mainLayout.setColumnStretch(2,1)
tabWidget = QWidget()
tabWidget.setLayout(mainLayout)
frmH = makeHorizFrame(['Stretch', tabWidget, 'Stretch'])
frm = makeVertFrame(['Space(20)', frmH, 'Stretch'])
# Now set the scrollarea widget to the layout
self.tabToDisplay = QScrollArea()
self.tabToDisplay.setWidgetResizable(True)
self.tabToDisplay.setWidget(frm)
class PM_GroupBox( QGroupBox ):
"""
The PM_GroupBox widget provides a group box container with a
collapse/expand button and a title button.
PM group boxes can be nested by supplying an existing PM_GroupBox as the
parentWidget of a new PM_GroupBox (as an argument to its constructor).
If the parentWidget is a PM_GroupBox, no title button will be created
for the new group box.
@cvar setAsDefault: Determines whether to reset the value of all
widgets in the group box when the user clicks
the "Restore Defaults" button. If set to False,
no widgets will be reset regardless thier own
I{setAsDefault} value.
@type setAsDefault: bool
@cvar labelWidget: The Qt label widget of this group box.
@type labelWidget: U{B{QLabel}<http://doc.trolltech.com/4/qlabel.html>}
@cvar expanded: Expanded flag.
@type expanded: bool
@cvar _title: The group box title.
@type _title: str
@cvar _widgetList: List of widgets in the group box
(except the title button).
@type _widgetList: list
@cvar _rowCount: Number of rows in the group box.
@type _rowCount: int
@cvar _groupBoxCount: Number of group boxes in this group box.
@type _groupBoxCount: int
@cvar _lastGroupBox: The last group box in this group box (i.e. the
most recent PM group box added).
@type _lastGroupBox: PM_GroupBox
"""
setAsDefault = True
labelWidget = None
expanded = True
_title = ""
_widgetList = []
_rowCount = 0
_groupBoxCount = 0
_lastGroupBox = None
titleButtonRequested = True
def __init__(self,
parentWidget,
title = '',
connectTitleButton = True,
setAsDefault = True
):
"""
Appends a PM_GroupBox widget to I{parentWidget}, a L{PM_Dialog} or a
L{PM_GroupBox}.
If I{parentWidget} is a L{PM_Dialog}, the group box will have a title
button at the top for collapsing and expanding the group box. If
I{parentWidget} is a PM_GroupBox, the title will simply be a text
label at the top of the group box.
@param parentWidget: The parent dialog or group box containing this
widget.
@type parentWidget: L{PM_Dialog} or L{PM_GroupBox}
@param title: The title (button) text. If empty, no title is added.
@type title: str
@param connectTitleButton: If True, this class will automatically
connect the title button of the groupbox to send signal
to expand or collapse the groupbox. Otherwise, the caller
has to connect this signal by itself. See:
B{Ui_MovePropertyManager.addGroupBoxes} and
B{MovePropertyManager.connect_or_disconnect_signals} for
examples where the client connects this slot.
@type connectTitleButton: bool
@param setAsDefault: If False, no widgets in this group box will have
thier default values restored when the B{Restore
Defaults} button is clicked, regardless thier own
I{setAsDefault} value.
@type setAsDefault: bool
@see: U{B{QGroupBox}<http://doc.trolltech.com/4/qgroupbox.html>}
"""
QGroupBox.__init__(self)
self.parentWidget = parentWidget
# Calling addWidget() here is important. If done at the end,
# the title button does not get assigned its palette for some
# unknown reason. Mark 2007-05-20.
# Add self to PropMgr's vBoxLayout
if parentWidget:
parentWidget._groupBoxCount += 1
parentWidget.vBoxLayout.addWidget(self)
parentWidget._widgetList.append(self)
_groupBoxCount = 0
self._widgetList = []
self._title = title
self.setAsDefault = setAsDefault
self.setAutoFillBackground(True)
self.setStyleSheet(self._getStyleSheet())
# Create vertical box layout which will contain two widgets:
# - the group box title button (or title) on row 0.
# - the container widget for all PM widgets on row 1.
self._vBoxLayout = QVBoxLayout(self)
self._vBoxLayout.setMargin(0)
self._vBoxLayout.setSpacing(0)
# _containerWidget contains all PM widgets in this group box.
# Its sole purpose is to easily support the collapsing and
# expanding of a group box by calling this widget's hide()
# and show() methods.
self._containerWidget = QWidget()
self._vBoxLayout.insertWidget(0, self._containerWidget)
# Create vertical box layout
self.vBoxLayout = QVBoxLayout(self._containerWidget)
self.vBoxLayout.setMargin(PM_GROUPBOX_VBOXLAYOUT_MARGIN)
self.vBoxLayout.setSpacing(PM_GROUPBOX_VBOXLAYOUT_SPACING)
# Create grid layout
self.gridLayout = QGridLayout()
self.gridLayout.setMargin(PM_GRIDLAYOUT_MARGIN)
self.gridLayout.setSpacing(PM_GRIDLAYOUT_SPACING)
# Insert grid layout in its own vBoxLayout
self.vBoxLayout.addLayout(self.gridLayout)
# Add title button (or just a title if the parent is not a PM_Dialog).
if not parentWidget or isinstance(parentWidget, PM_GroupBox):
self.setTitle(title)
else: # Parent is a PM_Dialog, so add a title button.
if not self.titleButtonRequested:
self.setTitle(title)
else:
self.titleButton = self._getTitleButton(self, title)
self._vBoxLayout.insertWidget(0, self.titleButton)
if connectTitleButton:
self.connect( self.titleButton,
SIGNAL("clicked()"),
self.toggleExpandCollapse)
self._insertMacSpacer()
# Fixes the height of the group box. Very important. Mark 2007-05-29
self.setSizePolicy(
QSizePolicy(QSizePolicy.Policy(QSizePolicy.Preferred),
QSizePolicy.Policy(QSizePolicy.Fixed)))
self._addBottomSpacer()
return
def _insertMacSpacer(self, spacerHeight = 6):
"""
This addresses a Qt 4.3.5 layout bug on Mac OS X in which the
title button will overlap with and cover the first widget in
the group box. This workaround inserts a I{spacerHeight} tall
spacer between the group box's title button and container widget.
"""
if sys.platform != "darwin":
return
self._macVerticalSpacer = QSpacerItem(10, spacerHeight,
QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)
self._vBoxLayout.insertItem(1, self._macVerticalSpacer)
return
def _addBottomSpacer(self):
"""
Add a vertical spacer below this group box.
Method: Assume this is going to be the last group box in the PM, so set
its spacer's vertical sizePolicy to MinimumExpanding. We then set the
vertical sizePolicy of the last group box's spacer to Fixed and set its
height to PM_GROUPBOX_SPACING.
"""
# Spacers are only added to groupboxes in the PropMgr, not
# nested groupboxes.
## from PM.PM_Dialog import PM_Dialog
## if not isinstance(self.parentWidget, PM_Dialog):
if not self.parentWidget or isinstance(self.parentWidget, PM_GroupBox):
#bruce 071103 revised test to remove import cycle; I assume that
# self.parentWidget is either a PM_GroupBox or a PM_Dialog, since
# comments about similar code in __init__ imply that.
#
# A cleaner fix would involve asking self.parentWidget whether to
# do this, with instances of PM_GroupBox and PM_Dialog giving
# different answers, and making them both inherit an API class
# which documents the method or attr with which we ask them that
# question; the API class would be inherited by any object to
# which PM_GroupBox's such as self can be added.
#
# Or, an even cleaner fix would just call a method in
# self.parentWidget to do what this code does now (implemented
# differently in PM_GroupBox and PM_Dialog).
self.verticalSpacer = None
return
if self.parentWidget._lastGroupBox:
# _lastGroupBox is no longer the last one. <self> will be the
# _lastGroupBox, so we must change the verticalSpacer height
# and sizePolicy of _lastGroupBox to be a fixed
# spacer between it and <self>.
defaultHeight = PM_GROUPBOX_SPACING
self.parentWidget._lastGroupBox.verticalSpacer.changeSize(
10, defaultHeight,
QSizePolicy.Fixed,
QSizePolicy.Fixed)
self.parentWidget._lastGroupBox.verticalSpacer.defaultHeight = \
defaultHeight
# Add a 1 pixel high, MinimumExpanding VSpacer below this group box.
# This keeps all group boxes in the PM layout squeezed together as
# group boxes are expanded, collapsed, hidden and shown again.
defaultHeight = 1
self.verticalSpacer = QSpacerItem(10, defaultHeight,
QSizePolicy.Fixed,
QSizePolicy.MinimumExpanding)
self.verticalSpacer.defaultHeight = defaultHeight
self.parentWidget.vBoxLayout.addItem(self.verticalSpacer)
# This groupbox is now the last one in the PropMgr.
self.parentWidget._lastGroupBox = self
return
def restoreDefault (self):
"""
Restores the default values for all widgets in this group box.
"""
for widget in self._widgetList:
if debug_flags.atom_debug:
print "PM_GroupBox.restoreDefault(): widget =", \
widget.objectName()
widget.restoreDefault()
return
def getTitle(self):
"""
Returns the group box title.
@return: The group box title.
@rtype: str
"""
return self._title
def setTitle(self, title):
"""
Sets the groupbox title to <title>.
@param title: The group box title.
@type title: str
@attention: This overrides QGroupBox's setTitle() method.
"""
if not title:
return
# Create QLabel widget.
if not self.labelWidget:
self.labelWidget = QLabel()
self.vBoxLayout.insertWidget(0, self.labelWidget)
labelAlignment = PM_LABEL_LEFT_ALIGNMENT
self.labelWidget.setAlignment(labelAlignment)
self._title = title
self.labelWidget.setText(title)
return
def getPmWidgetPlacementParameters(self, pmWidget):
"""
Returns all the layout parameters needed to place
a PM_Widget in the group box grid layout.
@param pmWidget: The PM widget.
@type pmWidget: PM_Widget
"""
row = self._rowCount
#PM_CheckBox doesn't have a label. So do the following to decide the
#placement of the checkbox. (can be placed either in column 0 or 1 ,
#This also needs to be implemented for PM_RadioButton, but at present
#the following code doesn't support PM_RadioButton.
if isinstance(pmWidget, PM_CheckBox):
spanWidth = pmWidget.spanWidth
if not spanWidth:
# Set the widget's row and column parameters.
widgetRow = row
widgetColumn = pmWidget.widgetColumn
widgetSpanCols = 1
widgetAlignment = PM_LABEL_LEFT_ALIGNMENT
rowIncrement = 1
#set a virtual label
labelRow = row
labelSpanCols = 1
labelAlignment = PM_LABEL_RIGHT_ALIGNMENT
if widgetColumn == 0:
labelColumn = 1
elif widgetColumn == 1:
labelColumn = 0
else:
# Set the widget's row and column parameters.
widgetRow = row
widgetColumn = pmWidget.widgetColumn
widgetSpanCols = 2
widgetAlignment = PM_LABEL_LEFT_ALIGNMENT
rowIncrement = 1
#no label
labelRow = 0
labelColumn = 0
labelSpanCols = 0
labelAlignment = PM_LABEL_RIGHT_ALIGNMENT
return widgetRow, \
widgetColumn, \
widgetSpanCols, \
widgetAlignment, \
rowIncrement, \
labelRow, \
labelColumn, \
labelSpanCols, \
labelAlignment
label = pmWidget.label
labelColumn = pmWidget.labelColumn
spanWidth = pmWidget.spanWidth
if not spanWidth:
# This widget and its label are on the same row
labelRow = row
labelSpanCols = 1
labelAlignment = PM_LABEL_RIGHT_ALIGNMENT
# Set the widget's row and column parameters.
widgetRow = row
widgetColumn = 1
widgetSpanCols = 1
widgetAlignment = PM_LABEL_LEFT_ALIGNMENT
rowIncrement = 1
if labelColumn == 1:
widgetColumn = 0
labelAlignment = PM_LABEL_LEFT_ALIGNMENT
widgetAlignment = PM_LABEL_RIGHT_ALIGNMENT
else:
# This widget spans the full width of the groupbox
if label:
# The label and widget are on separate rows.
# Set the label's row, column and alignment.
labelRow = row
labelColumn = 0
labelSpanCols = 2
# Set this widget's row and column parameters.
widgetRow = row + 1 # Widget is below the label.
widgetColumn = 0
widgetSpanCols = 2
rowIncrement = 2
else: # No label. Just the widget.
labelRow = 0
labelColumn = 0
labelSpanCols = 0
# Set the widget's row and column parameters.
widgetRow = row
widgetColumn = 0
widgetSpanCols = 2
rowIncrement = 1
labelAlignment = PM_LABEL_LEFT_ALIGNMENT
widgetAlignment = PM_LABEL_LEFT_ALIGNMENT
return widgetRow, \
widgetColumn, \
widgetSpanCols, \
widgetAlignment, \
rowIncrement, \
labelRow, \
labelColumn, \
labelSpanCols, \
labelAlignment
def addPmWidget(self, pmWidget):
"""
Add a PM widget and its label to this group box.
@param pmWidget: The PM widget to add.
@type pmWidget: PM_Widget
"""
# Get all the widget and label layout parameters.
widgetRow, \
widgetColumn, \
widgetSpanCols, \
widgetAlignment, \
rowIncrement, \
labelRow, \
labelColumn, \
labelSpanCols, \
labelAlignment = \
self.getPmWidgetPlacementParameters(pmWidget)
if pmWidget.labelWidget:
#Create Label as a pixmap (instead of text) if a valid icon path
#is provided
labelPath = str(pmWidget.label)
if labelPath and labelPath.startswith("ui/"): #bruce 080325 revised
labelPixmap = getpixmap(labelPath)
if not labelPixmap.isNull():
pmWidget.labelWidget.setPixmap(labelPixmap)
pmWidget.labelWidget.setText('')
self.gridLayout.addWidget( pmWidget.labelWidget,
labelRow,
labelColumn,
1,
labelSpanCols,
labelAlignment )
# The following is a workaround for a Qt bug. If addWidth()'s
# <alignment> argument is not supplied, the widget spans the full
# column width of the grid cell containing it. If <alignment>
# is supplied, this desired behavior is lost and there is no
# value that can be supplied to maintain the behavior (0 doesn't
# work). The workaround is to call addWidget() without the <alignment>
# argument. Mark 2007-07-27.
if widgetAlignment == PM_LABEL_LEFT_ALIGNMENT:
self.gridLayout.addWidget( pmWidget,
widgetRow,
widgetColumn,
1,
widgetSpanCols)
# aligment = 0 doesn't work.
else:
self.gridLayout.addWidget( pmWidget,
widgetRow,
widgetColumn,
1,
widgetSpanCols,
widgetAlignment
)
self._widgetList.append(pmWidget)
self._rowCount += rowIncrement
return
def getRowCount(self):
"""
Return the row count of gridlayout of L{PM_Groupbox}
@return: The row count of L{self.gridlayout}
@rtype: int
"""
return self._rowCount
def incrementRowCount(self, increment = 1):
"""
Increment the row count of the gridlayout of L{PM_groupBox}
@param increment: The incremental value
@type increment: int
"""
self._rowCount += increment
return
def addQtWidget(self, qtWidget, column = 0, spanWidth = False):
"""
Add a Qt widget to this group box.
@param qtWidget: The Qt widget to add.
@type qtWidget: QWidget
@warning: this method has not been tested yet.
"""
# Set the widget's row and column parameters.
widgetRow = self._rowCount
widgetColumn = column
if spanWidth:
widgetSpanCols = 2
else:
widgetSpanCols = 1
self.gridLayout.addWidget( qtWidget,
widgetRow,
widgetColumn,
1,
widgetSpanCols )
self._rowCount += 1
return
def collapse(self):
"""
Collapse this group box i.e. hide all its contents and change the look
and feel of the groupbox button.
"""
self.vBoxLayout.setMargin(0)
self.vBoxLayout.setSpacing(0)
self.gridLayout.setMargin(0)
self.gridLayout.setSpacing(0)
# The styleSheet contains the expand/collapse.
styleSheet = self._getTitleButtonStyleSheet(showExpanded = False)
self.titleButton.setStyleSheet(styleSheet)
self._containerWidget.hide()
self.expanded = False
return
def expand(self):
"""
Expand this group box i.e. show all its contents and change the look
and feel of the groupbox button.
"""
self.vBoxLayout.setMargin(PM_GROUPBOX_VBOXLAYOUT_MARGIN)
self.vBoxLayout.setSpacing(PM_GROUPBOX_VBOXLAYOUT_SPACING)
self.gridLayout.setMargin(PM_GROUPBOX_GRIDLAYOUT_MARGIN)
self.gridLayout.setSpacing(PM_GROUPBOX_GRIDLAYOUT_SPACING)
# The styleSheet contains the expand/collapse.
styleSheet = self._getTitleButtonStyleSheet(showExpanded = True)
self.titleButton.setStyleSheet(styleSheet)
self._containerWidget.show()
self.expanded = True
return
def hide(self):
"""
Hides the group box .
@see: L{show}
"""
QWidget.hide(self)
if self.labelWidget:
self.labelWidget.hide()
# Change the spacer height to zero to "hide" it unless
# self is the last GroupBox in the Property Manager.
if self.parentWidget._lastGroupBox is self:
return
if self.verticalSpacer:
self.verticalSpacer.changeSize(10, 0)
return
def show(self):
"""
Unhides the group box.
@see: L{hide}
"""
QWidget.show(self)
if self.labelWidget:
self.labelWidget.show()
if self.parentWidget._lastGroupBox is self:
return
if self.verticalSpacer:
self.verticalSpacer.changeSize(10,
self.verticalSpacer.defaultHeight)
return
# Title Button Methods #####################################
def _getTitleButton(self,
parentWidget = None,
title = '',
showExpanded = True ):
"""
Return the group box title push button. The push button is customized
such that it appears as a title bar at the top of the group box.
If the user clicks on this 'title bar' it sends a signal to open or
close the group box.
@param parentWidget: The parent dialog or group box containing this
widget.
@type parentWidget: PM_Dialog or PM_GroupBox
@param title: The button title.
@type title: str
@param showExpanded: dDetermines whether the expand or collapse image is
displayed on the title button.
@type showExpanded: bool
@see: L{_getTitleButtonStyleSheet()}
@Note: Including a title button should only be legal if the parentWidget
is a PM_Dialog.
"""
button = QPushButton(title, parentWidget)
button.setFlat(False)
button.setAutoFillBackground(True)
button.setStyleSheet(self._getTitleButtonStyleSheet(showExpanded))
return button
def _getTitleButtonStyleSheet(self, showExpanded = True):
"""
Returns the style sheet for a group box title button (or checkbox).
@param showExpanded: Determines whether to include an expand or
collapse icon.
@type showExpanded: bool
@return: The title button style sheet.
@rtype: str
"""
# Need to move border color and text color to top
# (make global constants).
if showExpanded:
styleSheet = \
"QPushButton {"\
"border-style: outset; "\
"border-width: 2px; "\
"border-color: #%s; "\
"border-radius: 2px; "\
"background-color: #%s; "\
"font: bold 12px 'Arial'; "\
"color: #%s; "\
"min-width: 10em; "\
"background-image: url(%s); "\
"background-position: right; "\
"background-repeat: no-repeat; "\
"text-align: left; "\
"}" % (QColor_to_Hex(pmGrpBoxButtonBorderColor),
QColor_to_Hex(pmGrpBoxButtonColor),
QColor_to_Hex(pmGrpBoxButtonTextColor),
pmGrpBoxExpandedIconPath
)
else:
# Collapsed.
styleSheet = \
"QPushButton {"\
"border-style: outset; "\
"border-width: 2px; "\
"border-color: #%s; "\
"border-radius: 2px; "\
"background-color: #%s; "\
"font: bold 12px 'Arial'; "\
"color: #%s; "\
"min-width: 10em; "\
"background-image: url(%s); "\
"background-position: right; "\
"background-repeat: no-repeat; "\
"text-align: left; "\
"}" % (QColor_to_Hex(pmGrpBoxButtonBorderColor),
QColor_to_Hex(pmGrpBoxButtonColor),
QColor_to_Hex(pmGrpBoxButtonTextColor),
pmGrpBoxCollapsedIconPath
)
return styleSheet
def toggleExpandCollapse(self):
"""
Slot method for the title button to expand/collapse the group box.
"""
if self._widgetList:
if self.expanded:
self.collapse()
else: # Expand groupbox by showing all widgets in groupbox.
self.expand()
else:
print "Clicking on the group box button has no effect "\
"since it has no widgets."
return
# GroupBox stylesheet methods. ##############################
def _getStyleSheet(self):
"""
Return the style sheet for the groupbox. This sets the following
properties only:
- border style
- border width
- border color
- border radius (on corners)
- background color
@return: The group box style sheet.
@rtype: str
"""
styleSheet = \
"QGroupBox {"\
"border-style: solid; "\
"border-width: 1px; "\
"border-color: #%s; "\
"border-radius: 0px; "\
"background-color: #%s; "\
"min-width: 10em; "\
"}" % ( QColor_to_Hex(pmGrpBoxBorderColor),
QColor_to_Hex(pmGrpBoxColor)
)
return styleSheet
def __init__(self, parent, main, isUnknownOrder=False):
super(DlgEnterSegment, self).__init__(parent, main)
self.setWindowTitle('Enter Segment')
self.setWindowIcon(QIcon(self.main.iconfile))
buttonbox = QDialogButtonBox(QDialogButtonBox.Ok | \
QDialogButtonBox.Cancel)
self.connect(buttonbox, SIGNAL('accepted()'), self.accept)
self.connect(buttonbox, SIGNAL('rejected()'), self.reject)
layout = QGridLayout()
lbl = QLabel('Segment Text:')
self.editSegment = QLineEdit()
h, w = relaxedSizeNChar(self, 50)
self.editSegment.setMinimumSize(h, w)
self.editSegment.setMaxLength(MAX_SEGMENT_LENGTH)
editSegPanel = makeHorizFrame([self.editSegment, 'stretch'])
layout.addWidget(lbl, 0, 0)
layout.addWidget(editSegPanel, 0, 1)
minSelectorLabel = QLabel('Min Length: ')
maxSelectorLabel = QLabel('Max Length: ')
self.minSelector = QComboBox()
self.maxSelector = QComboBox()
if isUnknownOrder:
self.minSelector.setFont(GETFONT('Var', 10, bold=True))
self.maxSelector.setFont(GETFONT('Var', 10, bold=True))
for i in range(1,MAX_UNKNOWN_SEGMENT_LENGTH):
self.minSelector.addItem(str(i))
self.maxSelector.addItem(str(i))
# default to 1 to 4
self.minSelector.setCurrentIndex(0)
self.maxSelector.setCurrentIndex(0)
# fix the inversion of min and max when user sets min
def updateMaxSelector():
minLen = int(str(self.minSelector.currentText()))
maxLen = int(str(self.maxSelector.currentText()))
if minLen > maxLen:
self.maxSelector.setCurrentIndex(minLen - 1)
# fix the inversion of min and max when user sets max
def updateMinSelector():
minLen = int(str(self.minSelector.currentText()))
maxLen = int(str(self.maxSelector.currentText()))
if minLen > maxLen:
self.minSelector.setCurrentIndex(maxLen - 1)
main.connect(self.minSelector, SIGNAL('activated(int)'), \
updateMaxSelector)
main.connect(self.maxSelector, SIGNAL('activated(int)'), \
updateMinSelector)
layout.addWidget(minSelectorLabel, 1, 0)
minSelectorPanel = makeHorizFrame([self.minSelector,'stretch'])
layout.addWidget(minSelectorPanel, 1, 1)
layout.addWidget(maxSelectorLabel, 2, 0)
maxSelectorPanel = makeHorizFrame([self.maxSelector,'stretch'])
layout.addWidget(maxSelectorPanel, 2, 1)
layout.addWidget(buttonbox, 3, 0)
else:
layout.addWidget(buttonbox, 1, 0)
self.setLayout(layout)
def __init__(self, parent = None, desc = None, name = None, modal = 0, fl = 0, env = None, type = "QDialog"):
if env is None:
import foundation.env as env # this is a little weird... probably it'll be ok, and logically it seems correct.
self.desc = desc
self.typ = type
if type == "QDialog":
QDialog.__init__(self,parent,name,modal,fl)
elif type == "QTextEdit":
QTextEdit.__init__(self, parent, name)
elif type == "QFrame":
QFrame.__init__(self,parent,name)
else:
print "don't know about type == %r" % (type,)
self.image1 = QPixmap()
self.image1.loadFromData(image1_data,"PNG") # should be: title_icon ####
self.image3 = QPixmap()
self.image3.loadFromData(image3_data,"PNG")
self.image4 = QPixmap()
self.image4.loadFromData(image4_data,"PNG")
self.image5 = QPixmap()
self.image5.loadFromData(image5_data,"PNG")
self.image6 = QPixmap()
self.image6.loadFromData(image6_data,"PNG")
self.image7 = QPixmap()
self.image7.loadFromData(image7_data,"PNG")
self.image0 = QPixmap(image0_data) # should be: border_icon ####
self.image2 = QPixmap(image2_data) # should be: sponsor_pixmap ####
try:
####@@@@
title_icon_name = self.desc.options.get('title_icon')
border_icon_name = self.desc.options.get('border_icon')
if title_icon_name:
self.image1 = imagename_to_pixmap(title_icon_name) ###@@@ pass icon_path
###@@@ import imagename_to_pixmap or use env function
# or let that func itself be an arg, or have an env arg for it
###e rename it icon_name_to_pixmap, or find_icon? (the latter only if it's ok if it returns an iconset)
###e use iconset instead?
if border_icon_name:
self.image0 = imagename_to_pixmap(border_icon_name)
except:
print_compact_traceback("bug in icon-setting code, using fallback icons: ")
pass
if not name:
self.setName("parameter_dialog_or_frame") ###
###k guess this will need: if type == 'QDialog'
self.setIcon(self.image0) # should be: border_icon ####
nanotube_dialogLayout = QVBoxLayout(self,0,0,"nanotube_dialogLayout")
self.heading_frame = QFrame(self,"heading_frame")
self.heading_frame.setPaletteBackgroundColor(QColor(122,122,122))
self.heading_frame.setFrameShape(QFrame.NoFrame)
self.heading_frame.setFrameShadow(QFrame.Plain)
heading_frameLayout = QHBoxLayout(self.heading_frame,0,3,"heading_frameLayout")
self.heading_pixmap = QLabel(self.heading_frame,"heading_pixmap")
self.heading_pixmap.setSizePolicy(QSizePolicy(QSizePolicy.Fixed,QSizePolicy.Fixed,0,0,self.heading_pixmap.sizePolicy().hasHeightForWidth()))
self.heading_pixmap.setPixmap(self.image1) # should be: title_icon ####
self.heading_pixmap.setScaledContents(1)
heading_frameLayout.addWidget(self.heading_pixmap)
self.heading_label = QLabel(self.heading_frame,"heading_label")
self.heading_label.setPaletteForegroundColor(QColor(255,255,255))
heading_label_font = QFont(self.heading_label.font())
heading_label_font.setPointSize(12)
heading_label_font.setBold(1)
self.heading_label.setFont(heading_label_font)
heading_frameLayout.addWidget(self.heading_label)
nanotube_dialogLayout.addWidget(self.heading_frame)
self.body_frame = QFrame(self,"body_frame")
self.body_frame.setFrameShape(QFrame.StyledPanel)
self.body_frame.setFrameShadow(QFrame.Raised)
body_frameLayout = QVBoxLayout(self.body_frame,3,3,"body_frameLayout")
self.sponsor_frame = QFrame(self.body_frame,"sponsor_frame")
self.sponsor_frame.setPaletteBackgroundColor(QColor(255,255,255))
self.sponsor_frame.setFrameShape(QFrame.StyledPanel)
self.sponsor_frame.setFrameShadow(QFrame.Raised)
sponsor_frameLayout = QHBoxLayout(self.sponsor_frame,0,0,"sponsor_frameLayout")
self.sponsor_btn = QPushButton(self.sponsor_frame,"sponsor_btn")
self.sponsor_btn.setAutoDefault(0) #bruce 060703 bugfix
self.sponsor_btn.setSizePolicy(QSizePolicy(QSizePolicy.Preferred,QSizePolicy.Preferred,0,0,self.sponsor_btn.sizePolicy().hasHeightForWidth()))
self.sponsor_btn.setPaletteBackgroundColor(QColor(255,255,255))
self.sponsor_btn.setPixmap(self.image2) # should be: sponsor_pixmap #### [also we'll need to support >1 sponsor]
self.sponsor_btn.setFlat(1)
sponsor_frameLayout.addWidget(self.sponsor_btn)
body_frameLayout.addWidget(self.sponsor_frame)
layout59 = QHBoxLayout(None,0,6,"layout59")
left_spacer = QSpacerItem(20,20,QSizePolicy.Expanding,QSizePolicy.Minimum)
layout59.addItem(left_spacer)
self.done_btn = QToolButton(self.body_frame,"done_btn")
self.done_btn.setIcon(QIcon(self.image3))
layout59.addWidget(self.done_btn)
self.abort_btn = QToolButton(self.body_frame,"abort_btn")
self.abort_btn.setIcon(QIcon(self.image4))
layout59.addWidget(self.abort_btn)
self.preview_btn = QToolButton(self.body_frame,"preview_btn")
self.preview_btn.setIcon(QIcon(self.image5))
layout59.addWidget(self.preview_btn)
self.whatsthis_btn = QToolButton(self.body_frame,"whatsthis_btn")
self.whatsthis_btn.setIcon(QIcon(self.image6))
layout59.addWidget(self.whatsthis_btn)
right_spacer = QSpacerItem(20,20,QSizePolicy.Expanding,QSizePolicy.Minimum)
layout59.addItem(right_spacer)
body_frameLayout.addLayout(layout59)
self.groups = []
self.param_getters = {} # map from param name to get-function (which gets current value out of its widget or controller)
for group_desc in self.desc.kids('group'):
# == start parameters_grpbox ### this will differ for Windows style
header_refs = [] # keep python refcounted refs to all objects we make (at least the ones pyuic stored in self attrs)
self.parameters_grpbox = QGroupBox(self.body_frame,"parameters_grpbox")
self.parameters_grpbox.setFrameShape(QGroupBox.StyledPanel)
self.parameters_grpbox.setFrameShadow(QGroupBox.Sunken)
self.parameters_grpbox.setMargin(0)
self.parameters_grpbox.setColumnLayout(0,Qt.Vertical)
self.parameters_grpbox.layout().setSpacing(1)
self.parameters_grpbox.layout().setMargin(4)
parameters_grpboxLayout = QVBoxLayout(self.parameters_grpbox.layout())
parameters_grpboxLayout.setAlignment(Qt.AlignTop)
layout20 = QHBoxLayout(None,0,6,"layout20")
self.nt_parameters_grpbtn = QPushButton(self.parameters_grpbox,"nt_parameters_grpbtn")
self.nt_parameters_grpbtn.setSizePolicy(QSizePolicy(QSizePolicy.Minimum,QSizePolicy.Fixed,0,0,self.nt_parameters_grpbtn.sizePolicy().hasHeightForWidth()))
self.nt_parameters_grpbtn.setMaximumSize(QSize(16,16))
self.nt_parameters_grpbtn.setAutoDefault(0)
self.nt_parameters_grpbtn.setIcon(QIcon(self.image7)) ### not always right, but doesn't matter
self.nt_parameters_grpbtn.setFlat(1)
layout20.addWidget(self.nt_parameters_grpbtn)
self.parameters_grpbox_label = QLabel(self.parameters_grpbox,"parameters_grpbox_label")
self.parameters_grpbox_label.setSizePolicy(QSizePolicy(QSizePolicy.Preferred,QSizePolicy.Minimum,0,0,self.parameters_grpbox_label.sizePolicy().hasHeightForWidth()))
self.parameters_grpbox_label.setAlignment(QLabel.AlignVCenter)
layout20.addWidget(self.parameters_grpbox_label)
gbx_spacer1 = QSpacerItem(67,16,QSizePolicy.Expanding,QSizePolicy.Minimum)
layout20.addItem(gbx_spacer1)
parameters_grpboxLayout.addLayout(layout20)
nt_parameters_body_layout = QGridLayout(None,1,1,0,6,"nt_parameters_body_layout") ### what is 6 -- is it related to number of items???
# is it 6 in all the ones we got, but that could be a designer error so i better look it up sometime.
# == start its kids
# will use from above: self.parameters_grpbox, nt_parameters_body_layout
nextrow = 0 # which row of the QGridLayout to start filling next (loop variable)
hidethese = [] # set of objects to hide or show, when this group is closed or opened
for param in group_desc.kids('parameter'):
# param (a group subobj desc) is always a parameter, but we already plan to extend this beyond that,
# so we redundantly test for this here.
getter = None
paramname = None
# set these for use by uniform code at the end (e.g. for tooltips)
editfield = None
label = None
if param.isa('parameter'):
label = QLabel(self.parameters_grpbox,"members_label")
label.setAlignment(QLabel.AlignVCenter | QLabel.AlignRight)
nt_parameters_body_layout.addWidget(label,nextrow,0)
hidethese.append(label)
thisrow = nextrow
nextrow += 1
#e following should be known in a place that knows the input language, not here
paramname = param.options.get('name') or (param.args and param.args[0]) or "?"
paramlabel = param.options.get('label') or paramname ##e wrong, label "" or none ought to be possible
# QtGui.QApplication.translate(self.__class__.__name__, "xyz")
label.setText(QtGui.QApplication.translate(self.__class__.__name__, paramlabel))
if param.isa('parameter', widget = 'combobox', type = ('str',None)):
self.members_combox = QComboBox(0,self.parameters_grpbox,"members_combox") ###k what's 0?
editfield = self.members_combox
#### it probably needs a handler class, and then that could do this setup
self.members_combox.clear()
default = param.options.get('default', None) # None is not equal to any string
thewidgetkid = param.kids('widget')[-1] # kluge; need to think what the desc method for this should be
for item in thewidgetkid.kids('item'):
itemval = item.args[0]
itemtext = itemval
self.members_combox.insertItem(QtGui.QApplication.translate(self.__class__.__name__, itemtext)) #k __tr ok??
if itemval == default: #k or itemtext?
pass ##k i find no setItem in our py code, so not sure yet what to do for this.
nt_parameters_body_layout.addWidget(self.members_combox,thisrow,1)
hidethese.append(self.members_combox)
getter = (lambda combobox = self.members_combox: str(combobox.currentText()))
##e due to __tr or non-str values, it might be better to use currentIndex and look it up in a table
# (though whether __tr is good here might depend on what it's used for)
elif param.isa('parameter', widget = ('lineedit', None), type = ('str',None)):
# this covers explicit str|lineedit, and 3 default cases str, lineedit, neither.
# (i.e. if you say parameter and nothing else, it's str lineedit by default.)
self.length_linedit = QLineEdit(self.parameters_grpbox,"length_linedit")
editfield = self.length_linedit
nt_parameters_body_layout.addWidget(self.length_linedit,thisrow,1)
hidethese.append(self.length_linedit)
default = str(param.options.get('default', ""))
self.length_linedit.setText(QtGui.QApplication.translate(self.__class__.__name__, default)) # __tr ok?
getter = (lambda lineedit = self.length_linedit: str(lineedit.text()))
elif param.isa('parameter', widget = ('lineedit', None), type = 'float'):
self.length_linedit = QLineEdit(self.parameters_grpbox,"length_linedit")
editfield = self.length_linedit
nt_parameters_body_layout.addWidget(self.length_linedit,thisrow,1)
hidethese.append(self.length_linedit)
controller = FloatLineeditController_Qt(self, param, self.length_linedit)
header_refs.append(controller)
getter = controller.get_value
elif param.isa('parameter', widget = ('spinbox', None), type = 'int') or \
param.isa('parameter', widget = ('spinbox'), type = None):
self.chirality_N_spinbox = QSpinBox(self.parameters_grpbox,"chirality_N_spinbox") # was chirality_m_spinbox, now chirality_N_spinbox
editfield = self.chirality_N_spinbox
### seems like Qt defaults for min and max are 0,100 -- way too small a range!
if param.options.has_key('min') or 1:
self.chirality_N_spinbox.setMinimum(param.options.get('min', -999999999)) # was 0
if param.options.has_key('max') or 1:
self.chirality_N_spinbox.setMaximum(param.options.get('max', +999999999)) # wasn't in egcode, but needed
self.chirality_N_spinbox.setValue(param.options.get('default', 0)) # was 5
##e note: i suspect this default 0 should come from something that knows this desc grammar.
suffix = param.options.get('suffix', '')
if suffix:
self.chirality_N_spinbox.setSuffix(QtGui.QApplication.translate(self.__class__.__name__, suffix))
else:
self.chirality_N_spinbox.setSuffix(QString.null) # probably not needed
nt_parameters_body_layout.addWidget(self.chirality_N_spinbox,thisrow,1)
hidethese.append(self.chirality_N_spinbox)
getter = self.chirality_N_spinbox.value # note: it also has .text, which includes suffix
else:
print "didn't match:",param ###e improve this
# things done the same way for all kinds of param-editing widgets
if 1: #bruce 060703 moved this down here, as bugfix
# set tooltip (same one for editfield and label)
tooltip = param.options.get('tooltip', '')
###e do it for more kinds of params; share the code somehow; do it in controller, or setup-aid?
###k QToolTip appropriateness; tooltip option might be entirely untested
if tooltip and label:
QToolTip.add(label, QtGui.QApplication.translate(self.__class__.__name__, tooltip))
if tooltip and editfield:
QToolTip.add(editfield, QtGui.QApplication.translate(self.__class__.__name__, tooltip)) ##k ok?? review once not all params have same-row labels.
if getter and paramname and paramname != '?':
self.param_getters[paramname] = getter
### also bind these params to actions...
continue # next param
header_refs.extend( [self.parameters_grpbox, self.nt_parameters_grpbtn, self.parameters_grpbox_label] )
# now create the logic/control object for the group
group = CollapsibleGroupController_Qt(self, group_desc, header_refs, hidethese, self.nt_parameters_grpbtn)
### maybe ask env for the class to use for this?
self.groups.append(group) ### needed?? only for scanning the params, AFAIK -- oh, and to maintain a python refcount.
# from languageChange:
if 1: # i don't know if these are needed:
self.parameters_grpbox.setTitle(QString.null)
self.nt_parameters_grpbtn.setText(QString.null)
self.parameters_grpbox_label.setText(QtGui.QApplication.translate(self.__class__.__name__, group_desc.args[0])) # was "Nanotube Parameters"
##e note that it's questionable in the syntax design for this property of a group (overall group label)
# to be in that position (desc arg 0).
# == end its kids
parameters_grpboxLayout.addLayout(nt_parameters_body_layout)
body_frameLayout.addWidget(self.parameters_grpbox)
# == end parameters groupbox
continue # next group
nanotube_dialogLayout.addWidget(self.body_frame)
spacer14 = QSpacerItem(20,20,QSizePolicy.Minimum,QSizePolicy.Expanding)
nanotube_dialogLayout.addItem(spacer14)
layout42 = QHBoxLayout(None,4,6,"layout42")
btm_spacer = QSpacerItem(59,20,QSizePolicy.Expanding,QSizePolicy.Minimum)
layout42.addItem(btm_spacer)
self.cancel_btn = QPushButton(self,"cancel_btn")
self.cancel_btn.setAutoDefault(0) #bruce 060703 bugfix
layout42.addWidget(self.cancel_btn)
self.ok_btn = QPushButton(self,"ok_btn")
self.ok_btn.setAutoDefault(0) #bruce 060703 bugfix
layout42.addWidget(self.ok_btn)
nanotube_dialogLayout.addLayout(layout42)
self.languageChange()
self.resize(QSize(246,618).expandedTo(self.minimumSizeHint())) ### this size will need to be adjusted (guess -- it's only place overall size is set)
qt4todo('self.clearWState(Qt.WState_Polished)')
## self.connect(self.nt_parameters_grpbtn,SIGNAL("clicked()"),self.toggle_nt_parameters_grpbtn) ####
# new:
for button, methodname in ((self.sponsor_btn, 'do_sponsor_btn'), #e generalize to more than one sponsor button
(self.done_btn, 'do_done_btn'),
(self.abort_btn, 'do_abort_btn'),
(self.preview_btn, 'do_preview_btn'),
(self.whatsthis_btn, 'do_whatsthis_btn'),
(self.cancel_btn, 'do_cancel_btn'),
(self.ok_btn, 'do_ok_btn')):
if hasattr(self, methodname):
self.connect(button, SIGNAL("clicked()"), getattr(self, methodname))
return
def __init__(self, gui, existing_names, editing=None):
QDialog.__init__(self, gui)
self.gui = gui
self.existing_names = existing_names
if editing:
self.setWindowTitle(_('Edit virtual library'))
else:
self.setWindowTitle(_('Create virtual library'))
self.setWindowIcon(QIcon(I('lt.png')))
gl = QGridLayout()
self.setLayout(gl)
self.la1 = la1 = QLabel(_('Virtual library &name:'))
gl.addWidget(la1, 0, 0)
self.vl_name = QComboBox()
self.vl_name.setEditable(True)
self.vl_name.lineEdit().setMaxLength(MAX_VIRTUAL_LIBRARY_NAME_LENGTH)
la1.setBuddy(self.vl_name)
gl.addWidget(self.vl_name, 0, 1)
self.editing = editing
self.saved_searches_label = QLabel('')
self.saved_searches_label.setTextInteractionFlags(Qt.TextSelectableByMouse)
gl.addWidget(self.saved_searches_label, 2, 0, 1, 2)
self.la2 = la2 = QLabel(_('&Search expression:'))
gl.addWidget(la2, 1, 0)
self.vl_text = QLineEdit()
self.vl_text.textChanged.connect(self.search_text_changed)
la2.setBuddy(self.vl_text)
gl.addWidget(self.vl_text, 1, 1)
self.vl_text.setText(_build_full_search_string(self.gui))
self.sl = sl = QLabel('<p>'+_('Create a virtual library based on: ')+
('<a href="author.{0}">{0}</a>, '
'<a href="tag.{1}">{1}</a>, '
'<a href="publisher.{2}">{2}</a>, '
'<a href="series.{3}">{3}</a>, '
'<a href="search.{4}">{4}</a>.').format(_('Authors'), _('Tags'),
_('Publishers'), _('Series'), _('Saved Searches')))
sl.setWordWrap(True)
sl.setTextInteractionFlags(Qt.LinksAccessibleByMouse)
sl.linkActivated.connect(self.link_activated)
gl.addWidget(sl, 3, 0, 1, 2)
gl.setRowStretch(3,10)
self.hl = hl = QLabel(_('''
<h2>Virtual Libraries</h2>
<p>Using <i>virtual libraries</i> you can restrict calibre to only show
you books that match a search. When a virtual library is in effect, calibre
behaves as though the library contains only the matched books. The Tag Browser
display only the tags/authors/series/etc. that belong to the matched books and any searches
you do will only search within the books in the virtual library. This
is a good way to partition your large library into smaller and easier to work with subsets.</p>
<p>For example you can use a Virtual Library to only show you books with the Tag <i>"Unread"</i>
or only books by <i>"My Favorite Author"</i> or only books in a particular series.</p>
<p>More information and examples are available in the
<a href="http://manual.calibre-ebook.com/virtual_libraries.html">User Manual</a>.</p>
'''))
hl.setWordWrap(True)
hl.setOpenExternalLinks(True)
hl.setFrameStyle(hl.StyledPanel)
gl.addWidget(hl, 0, 3, 4, 1)
bb = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
gl.addWidget(bb, 4, 0, 1, 0)
if editing:
db = self.gui.current_db
virt_libs = db.prefs.get('virtual_libraries', {})
for dex,vl in enumerate(sorted(virt_libs.keys(), key=sort_key)):
self.vl_name.addItem(vl, virt_libs.get(vl, ''))
if vl == editing:
self.vl_name.setCurrentIndex(dex)
self.original_index = dex
self.original_search = virt_libs.get(editing, '')
self.vl_text.setText(self.original_search)
self.new_name = editing
self.vl_name.currentIndexChanged[int].connect(self.name_index_changed)
self.vl_name.lineEdit().textEdited.connect(self.name_text_edited)
self.resize(self.sizeHint()+QSize(150, 25))
class ConfigWidget(QWidget):
def __init__(self):
QWidget.__init__(self)
self.l = QGridLayout()
self.setLayout(self.l)
self.newFormatCheckboxLabel = QLabel('Generate new format data (SQLite3)')
self.l.addWidget(self.newFormatCheckboxLabel, 0, 0, 1, 1)
self.newFormatCheckbox = QCheckBox(self)
self.l.addWidget(self.newFormatCheckbox, 0, 1, 1, 1)
self.newFormatCheckbox.setChecked(prefs['newFormat'])
# ARTTBD Maybe should be a native directory picker? Works for now..
self.cacheDirLabel = QLabel("Caching directory (optional, useful if re-running for a given book)")
self.l.addWidget(self.cacheDirLabel, 1, 0, 1, 1)
self.cacheDirEdit = QLineEdit(self)
self.l.addWidget(self.cacheDirEdit, 1, 1, 1, 1)
self.cacheDirEdit.setText(prefs['cacheDir'])
self.autoExpandAliasesLabel = QLabel('Auto-generate aliases from character names')
self.l.addWidget(self.autoExpandAliasesLabel, 2, 0, 1, 1)
self.autoExpandAliasesCheckbox = QCheckBox(self)
self.l.addWidget(self.autoExpandAliasesCheckbox, 2, 1, 1, 1)
self.autoExpandAliasesCheckbox.setChecked(prefs['autoExpandAliases'])
self.logfileLabel = QLabel('Log file (optional)')
self.l.addWidget(self.logfileLabel, 3, 0, 1, 1)
self.logfileEdit = QLineEdit(self)
self.l.addWidget(self.logfileEdit, 3, 1, 1, 1)
self.logfileEdit.setText(prefs['logfile'])
def save_settings(self):
prefs['newFormat'] = self.newFormatCheckbox.isChecked()
prefs['cacheDir'] = unicode(self.cacheDirEdit.text())
prefs['autoExpandAliases'] = self.autoExpandAliasesCheckbox.isChecked()
prefs['logfile'] = unicode(self.logfileEdit.text())
class AddEmptyBookDialog(QDialog):
def __init__(self, parent, db, author, series=None):
QDialog.__init__(self, parent)
self.db = db
self.setWindowTitle(_('How many empty books?'))
self._layout = QGridLayout(self)
self.setLayout(self._layout)
self.qty_label = QLabel(_('How many empty books should be added?'))
self._layout.addWidget(self.qty_label, 0, 0, 1, 2)
self.qty_spinbox = QSpinBox(self)
self.qty_spinbox.setRange(1, 10000)
self.qty_spinbox.setValue(1)
self._layout.addWidget(self.qty_spinbox, 1, 0, 1, 2)
self.author_label = QLabel(_('Set the author of the new books to:'))
self._layout.addWidget(self.author_label, 2, 0, 1, 2)
self.authors_combo = EditWithComplete(self)
self.authors_combo.setSizeAdjustPolicy(
self.authors_combo.AdjustToMinimumContentsLengthWithIcon)
self.authors_combo.setEditable(True)
self._layout.addWidget(self.authors_combo, 3, 0, 1, 1)
self.initialize_authors(db, author)
self.clear_button = QToolButton(self)
self.clear_button.setIcon(QIcon(I('trash.png')))
self.clear_button.setToolTip(_('Reset author to Unknown'))
self.clear_button.clicked.connect(self.reset_author)
self._layout.addWidget(self.clear_button, 3, 1, 1, 1)
self.series_label = QLabel(_('Set the series of the new books to:'))
self._layout.addWidget(self.series_label, 4, 0, 1, 2)
self.series_combo = EditWithComplete(self)
self.authors_combo.setSizeAdjustPolicy(
self.authors_combo.AdjustToMinimumContentsLengthWithIcon)
self.series_combo.setEditable(True)
self._layout.addWidget(self.series_combo, 5, 0, 1, 1)
self.initialize_series(db, series)
self.sclear_button = QToolButton(self)
self.sclear_button.setIcon(QIcon(I('trash.png')))
self.sclear_button.setToolTip(_('Reset series'))
self.sclear_button.clicked.connect(self.reset_series)
self._layout.addWidget(self.sclear_button, 5, 1, 1, 1)
self.create_epub = c = QCheckBox(
_('Create an empty EPUB file as well'))
c.setChecked(gprefs.get('create_empty_epub_file', False))
c.setToolTip(
_('Also create an empty EPUB file that you can subsequently edit'))
self._layout.addWidget(c, 6, 0, 1, -1)
button_box = self.bb = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
button_box.accepted.connect(self.accept)
button_box.rejected.connect(self.reject)
self._layout.addWidget(button_box, 7, 0, 1, -1)
self.resize(self.sizeHint())
def accept(self):
oval = gprefs.get('create_empty_epub_file', False)
if self.create_epub.isChecked() != oval:
gprefs['create_empty_epub_file'] = self.create_epub.isChecked()
return QDialog.accept(self)
def reset_author(self, *args):
self.authors_combo.setEditText(_('Unknown'))
def reset_series(self):
self.series_combo.setEditText('')
def initialize_authors(self, db, author):
au = author
if not au:
au = _('Unknown')
self.authors_combo.show_initial_value(au.replace('|', ','))
self.authors_combo.set_separator('&')
self.authors_combo.set_space_before_sep(True)
self.authors_combo.set_add_separator(
tweaks['authors_completer_append_separator'])
self.authors_combo.update_items_cache(db.all_author_names())
def initialize_series(self, db, series):
self.series_combo.show_initial_value(series or '')
self.series_combo.update_items_cache(db.all_series_names())
self.series_combo.set_separator(None)
@property
def qty_to_add(self):
return self.qty_spinbox.value()
@property
def selected_authors(self):
return string_to_authors(unicode(self.authors_combo.text()))
@property
def selected_series(self):
return unicode(self.series_combo.text())
class ConfigWidget(QWidget):
def __init__(self, plugin_action, prefs):
QWidget.__init__(self)
self.plugin_action = plugin_action
self.prefs = prefs
self.layout = QGridLayout()
self.setLayout(self.layout)
accounts = self.prefs[self.prefs.ACCOUNTS]
# Copy any data necessary into the prefs object
# The primary account, as configured in the GUI above
account = accounts.get('0', {})
self.labelUrlBase = QLabel(_('URL'))
self.layout.addWidget(self.labelUrlBase, 0, 0)
self.urlbase = QLabel()
if prefs[prefs.URLBASE] is not None:
self.urlbase.setText(prefs[prefs.URLBASE])
self.layout.addWidget(self.urlbase, 0, 1)
self.labelUrlBase.setBuddy(self.urlbase)
self.labelUserName = QLabel(_('Username'))
self.layout.addWidget(self.labelUserName, 1, 0)
self.username = QLineEdit(self)
if account.get(prefs.USERNAME) is not None:
self.username.setText(account[prefs.USERNAME])
self.layout.addWidget(self.username, 1, 1)
self.labelUserName.setBuddy(self.username)
self.labelPassword = QLabel(_('Password'))
self.layout.addWidget(self.labelPassword, 2, 0)
self.password = QLineEdit(self)
if account.get(prefs.OBFUSCATED_PASSWORD) is not None:
decrypted = prefs.decrypt_password(
account[prefs.OBFUSCATED_PASSWORD])
self.password.setText(decrypted)
self.layout.addWidget(self.password, 2, 1)
self.labelPassword.setBuddy(self.password)
def save_settings(self):
# TODO proper obfuscating somewhere, maybe even in 'migrate'
accounts = self.prefs[self.prefs.ACCOUNTS]
# Copy any data necessary into the prefs object
# The primary account, as configured in the GUI above
account_id = '0'
account = accounts.get(account_id, {})
account[self.prefs.ACCOUNT_ID] = account_id
account[self.prefs.USERNAME] = '%s' % self.username.text()
decrypted = '%s' % self.password.text()
# account['Lala'] = decrypted
account[self.prefs.
OBFUSCATED_PASSWORD] = '%s' % self.prefs.encrypt_password(
decrypted)
account[self.prefs.ENABLED] = True
accounts[account_id] = account
# Now the secondary account :-)
account_id = '1'
account = accounts.get(account_id, {})
account[self.prefs.ACCOUNT_ID] = account_id
if account.get(self.prefs.USERNAME) is None:
account[self.prefs.USERNAME] = ''
decrypted = ''
# account['Lala'] = decrypted
account[self.prefs.
OBFUSCATED_PASSWORD] = '%s' % self.prefs.encrypt_password(
decrypted)
account[self.prefs.ENABLED] = False
accounts[account_id] = account
# Now, put the hash back to the main prefs
self.prefs[self.prefs.ACCOUNTS] = accounts
# And save it...
self.prefs.save()
class ConfigWidget(QWidget):
def __init__(self, plugin_action, prefs):
QWidget.__init__(self)
self.plugin_action = plugin_action
self.prefs = prefs
self.layout = QGridLayout()
self.setLayout(self.layout)
accounts = self.prefs[self.prefs.ACCOUNTS]
# Copy any data necessary into the prefs object
# The primary account, as configured in the GUI above
account = accounts.get('0', {})
self.labelUrlBase = QLabel(_('URL'))
self.layout.addWidget(self.labelUrlBase, 0, 0)
self.urlbase = QLabel()
if prefs[prefs.URLBASE] is not None:
self.urlbase.setText(prefs[prefs.URLBASE])
self.layout.addWidget(self.urlbase, 0, 1)
self.labelUrlBase.setBuddy(self.urlbase)
self.labelUserName = QLabel(_('Username'))
self.layout.addWidget(self.labelUserName, 1, 0)
self.username = QLineEdit(self)
if account.get(prefs.USERNAME) is not None:
self.username.setText(account[prefs.USERNAME])
self.layout.addWidget(self.username, 1, 1)
self.labelUserName.setBuddy(self.username)
self.labelPassword = QLabel(_('Password'))
self.layout.addWidget(self.labelPassword, 2, 0)
self.password = QLineEdit(self)
if account.get(prefs.OBFUSCATED_PASSWORD) is not None:
decrypted = prefs.decrypt_password(account[prefs.OBFUSCATED_PASSWORD])
self.password.setText(decrypted)
self.layout.addWidget(self.password, 2, 1)
self.labelPassword.setBuddy(self.password)
def save_settings(self):
# TODO proper obfuscating somewhere, maybe even in 'migrate'
accounts = self.prefs[self.prefs.ACCOUNTS]
# Copy any data necessary into the prefs object
# The primary account, as configured in the GUI above
account_id = '0'
account = accounts.get(account_id, {})
account[self.prefs.ACCOUNT_ID] = account_id
account[self.prefs.USERNAME] = '%s' % self.username.text()
decrypted = '%s' % self.password.text()
# account['Lala'] = decrypted
account[self.prefs.OBFUSCATED_PASSWORD] = '%s' % self.prefs.encrypt_password(decrypted)
account[self.prefs.ENABLED] = True
accounts[account_id] = account
# Now the secondary account :-)
account_id = '1'
account = accounts.get(account_id, {})
account[self.prefs.ACCOUNT_ID] = account_id
if account.get(self.prefs.USERNAME) is None:
account[self.prefs.USERNAME] = ''
decrypted = ''
# account['Lala'] = decrypted
account[self.prefs.OBFUSCATED_PASSWORD] = '%s' % self.prefs.encrypt_password(decrypted)
account[self.prefs.ENABLED] = False
accounts[account_id] = account
# Now, put the hash back to the main prefs
self.prefs[self.prefs.ACCOUNTS] = accounts
# And save it...
self.prefs.save()
def __init__(self, window, plugin, device_id):
title = _("%s Settings") % plugin.device
super(SettingsDialog, self).__init__(window, title)
self.setMaximumWidth(540)
devmgr = plugin.device_manager()
config = devmgr.config
keystore = window.wallet.get_keystore()
handler = keystore.handler
thread = keystore.thread
# wallet can be None, needn't be window.wallet
wallet = devmgr.wallet_by_id(device_id)
hs_rows, hs_cols = (64, 128)
def invoke_client(method, *args, **kw_args):
unpair_after = kw_args.pop('unpair_after', False)
def task():
client = devmgr.client_by_id(device_id, handler)
if not client:
raise RuntimeError("Device not connected")
if method:
getattr(client, method)(*args, **kw_args)
if unpair_after:
devmgr.unpair_id(device_id)
return client.features
thread.add(task, on_success=update)
def update(features):
self.features = features
set_label_enabled()
bl_hash = features.bootloader_hash.encode('hex')
bl_hash = "\n".join([bl_hash[:32], bl_hash[32:]])
noyes = [_("No"), _("Yes")]
endis = [_("Enable Passphrases"), _("Disable Passphrases")]
disen = [_("Disabled"), _("Enabled")]
setchange = [_("Set a PIN"), _("Change PIN")]
version = "%d.%d.%d" % (features.major_version,
features.minor_version,
features.patch_version)
coins = ", ".join(coin.coin_name for coin in features.coins)
device_label.setText(features.label)
pin_set_label.setText(noyes[features.pin_protection])
passphrases_label.setText(disen[features.passphrase_protection])
bl_hash_label.setText(bl_hash)
label_edit.setText(features.label)
device_id_label.setText(features.device_id)
initialized_label.setText(noyes[features.initialized])
version_label.setText(version)
coins_label.setText(coins)
clear_pin_button.setVisible(features.pin_protection)
clear_pin_warning.setVisible(features.pin_protection)
pin_button.setText(setchange[features.pin_protection])
pin_msg.setVisible(not features.pin_protection)
passphrase_button.setText(endis[features.passphrase_protection])
language_label.setText(features.language)
def set_label_enabled():
label_apply.setEnabled(label_edit.text() != self.features.label)
def rename():
invoke_client('change_label', unicode(label_edit.text()))
def toggle_passphrase():
title = _("Confirm Toggle Passphrase Protection")
currently_enabled = self.features.passphrase_protection
if currently_enabled:
msg = _("After disabling passphrases, you can only pair this "
"Electrum wallet if it had an empty passphrase. "
"If its passphrase was not empty, you will need to "
"create a new wallet with the install wizard. You "
"can use this wallet again at any time by re-enabling "
"passphrases and entering its passphrase.")
else:
msg = _("Your current Electrum wallet can only be used with "
"an empty passphrase. You must create a separate "
"wallet with the install wizard for other passphrases "
"as each one generates a new set of addresses.")
msg += "\n\n" + _("Are you sure you want to proceed?")
if not self.question(msg, title=title):
return
invoke_client('toggle_passphrase', unpair_after=currently_enabled)
def change_homescreen():
from PIL import Image # FIXME
dialog = QFileDialog(self, _("Choose Homescreen"))
filename = dialog.getOpenFileName()
if filename:
im = Image.open(str(filename))
if im.size != (hs_cols, hs_rows):
raise Exception('Image must be 64 x 128 pixels')
im = im.convert('1')
pix = im.load()
img = ''
for j in range(hs_rows):
for i in range(hs_cols):
img += '1' if pix[i, j] else '0'
img = ''.join(
chr(int(img[i:i + 8], 2)) for i in range(0, len(img), 8))
invoke_client('change_homescreen', img)
def clear_homescreen():
invoke_client('change_homescreen', '\x00')
def set_pin():
invoke_client('set_pin', remove=False)
def clear_pin():
invoke_client('set_pin', remove=True)
def wipe_device():
if wallet and sum(wallet.get_balance()):
title = _("Confirm Device Wipe")
msg = _("Are you SURE you want to wipe the device?\n"
"Your wallet still has bitcoins in it!")
if not self.question(
msg, title=title, icon=QMessageBox.Critical):
return
invoke_client('wipe_device', unpair_after=True)
def slider_moved():
mins = timeout_slider.sliderPosition()
timeout_minutes.setText(_("%2d minutes") % mins)
def slider_released():
config.set_session_timeout(timeout_slider.sliderPosition() * 60)
# Information tab
info_tab = QWidget()
info_layout = QVBoxLayout(info_tab)
info_glayout = QGridLayout()
info_glayout.setColumnStretch(2, 1)
device_label = QLabel()
pin_set_label = QLabel()
passphrases_label = QLabel()
version_label = QLabel()
device_id_label = QLabel()
bl_hash_label = QLabel()
bl_hash_label.setWordWrap(True)
coins_label = QLabel()
coins_label.setWordWrap(True)
language_label = QLabel()
initialized_label = QLabel()
rows = [
(_("Device Label"), device_label),
(_("PIN set"), pin_set_label),
(_("Passphrases"), passphrases_label),
(_("Firmware Version"), version_label),
(_("Device ID"), device_id_label),
(_("Bootloader Hash"), bl_hash_label),
(_("Supported Coins"), coins_label),
(_("Language"), language_label),
(_("Initialized"), initialized_label),
]
for row_num, (label, widget) in enumerate(rows):
info_glayout.addWidget(QLabel(label), row_num, 0)
info_glayout.addWidget(widget, row_num, 1)
info_layout.addLayout(info_glayout)
# Settings tab
settings_tab = QWidget()
settings_layout = QVBoxLayout(settings_tab)
settings_glayout = QGridLayout()
# Settings tab - Label
label_msg = QLabel(
_("Name this %s. If you have mutiple devices "
"their labels help distinguish them.") % plugin.device)
label_msg.setWordWrap(True)
label_label = QLabel(_("Device Label"))
label_edit = QLineEdit()
label_edit.setMinimumWidth(150)
label_edit.setMaxLength(plugin.MAX_LABEL_LEN)
label_apply = QPushButton(_("Apply"))
label_apply.clicked.connect(rename)
label_edit.textChanged.connect(set_label_enabled)
settings_glayout.addWidget(label_label, 0, 0)
settings_glayout.addWidget(label_edit, 0, 1, 1, 2)
settings_glayout.addWidget(label_apply, 0, 3)
settings_glayout.addWidget(label_msg, 1, 1, 1, -1)
# Settings tab - PIN
pin_label = QLabel(_("PIN Protection"))
pin_button = QPushButton()
pin_button.clicked.connect(set_pin)
settings_glayout.addWidget(pin_label, 2, 0)
settings_glayout.addWidget(pin_button, 2, 1)
pin_msg = QLabel(
_("PIN protection is strongly recommended. "
"A PIN is your only protection against someone "
"stealing your bitcoins if they obtain physical "
"access to your %s.") % plugin.device)
pin_msg.setWordWrap(True)
pin_msg.setStyleSheet("color: red")
settings_glayout.addWidget(pin_msg, 3, 1, 1, -1)
# Settings tab - Homescreen
if plugin.device != 'KeepKey': # Not yet supported by KK firmware
homescreen_layout = QHBoxLayout()
homescreen_label = QLabel(_("Homescreen"))
homescreen_change_button = QPushButton(_("Change..."))
homescreen_clear_button = QPushButton(_("Reset"))
homescreen_change_button.clicked.connect(change_homescreen)
homescreen_clear_button.clicked.connect(clear_homescreen)
homescreen_msg = QLabel(
_("You can set the homescreen on your "
"device to personalize it. You must "
"choose a %d x %d monochrome black and "
"white image.") % (hs_rows, hs_cols))
homescreen_msg.setWordWrap(True)
settings_glayout.addWidget(homescreen_label, 4, 0)
settings_glayout.addWidget(homescreen_change_button, 4, 1)
settings_glayout.addWidget(homescreen_clear_button, 4, 2)
settings_glayout.addWidget(homescreen_msg, 5, 1, 1, -1)
# Settings tab - Session Timeout
timeout_label = QLabel(_("Session Timeout"))
timeout_minutes = QLabel()
timeout_slider = QSlider(Qt.Horizontal)
timeout_slider.setRange(1, 60)
timeout_slider.setSingleStep(1)
timeout_slider.setTickInterval(5)
timeout_slider.setTickPosition(QSlider.TicksBelow)
timeout_slider.setTracking(True)
timeout_msg = QLabel(
_("Clear the session after the specified period "
"of inactivity. Once a session has timed out, "
"your PIN and passphrase (if enabled) must be "
"re-entered to use the device."))
timeout_msg.setWordWrap(True)
timeout_slider.setSliderPosition(config.get_session_timeout() // 60)
slider_moved()
timeout_slider.valueChanged.connect(slider_moved)
timeout_slider.sliderReleased.connect(slider_released)
settings_glayout.addWidget(timeout_label, 6, 0)
settings_glayout.addWidget(timeout_slider, 6, 1, 1, 3)
settings_glayout.addWidget(timeout_minutes, 6, 4)
settings_glayout.addWidget(timeout_msg, 7, 1, 1, -1)
settings_layout.addLayout(settings_glayout)
settings_layout.addStretch(1)
# Advanced tab
advanced_tab = QWidget()
advanced_layout = QVBoxLayout(advanced_tab)
advanced_glayout = QGridLayout()
# Advanced tab - clear PIN
clear_pin_button = QPushButton(_("Disable PIN"))
clear_pin_button.clicked.connect(clear_pin)
clear_pin_warning = QLabel(
_("If you disable your PIN, anyone with physical access to your "
"%s device can spend your bitcoins.") % plugin.device)
clear_pin_warning.setWordWrap(True)
clear_pin_warning.setStyleSheet("color: red")
advanced_glayout.addWidget(clear_pin_button, 0, 2)
advanced_glayout.addWidget(clear_pin_warning, 1, 0, 1, 5)
# Advanced tab - toggle passphrase protection
passphrase_button = QPushButton()
passphrase_button.clicked.connect(toggle_passphrase)
passphrase_msg = WWLabel(PASSPHRASE_HELP)
passphrase_warning = WWLabel(PASSPHRASE_NOT_PIN)
passphrase_warning.setStyleSheet("color: red")
advanced_glayout.addWidget(passphrase_button, 3, 2)
advanced_glayout.addWidget(passphrase_msg, 4, 0, 1, 5)
advanced_glayout.addWidget(passphrase_warning, 5, 0, 1, 5)
# Advanced tab - wipe device
wipe_device_button = QPushButton(_("Wipe Device"))
wipe_device_button.clicked.connect(wipe_device)
wipe_device_msg = QLabel(
_("Wipe the device, removing all data from it. The firmware "
"is left unchanged."))
wipe_device_msg.setWordWrap(True)
wipe_device_warning = QLabel(
_("Only wipe a device if you have the recovery seed written down "
"and the device wallet(s) are empty, otherwise the bitcoins "
"will be lost forever."))
wipe_device_warning.setWordWrap(True)
wipe_device_warning.setStyleSheet("color: red")
advanced_glayout.addWidget(wipe_device_button, 6, 2)
advanced_glayout.addWidget(wipe_device_msg, 7, 0, 1, 5)
advanced_glayout.addWidget(wipe_device_warning, 8, 0, 1, 5)
advanced_layout.addLayout(advanced_glayout)
advanced_layout.addStretch(1)
tabs = QTabWidget(self)
tabs.addTab(info_tab, _("Information"))
tabs.addTab(settings_tab, _("Settings"))
tabs.addTab(advanced_tab, _("Advanced"))
dialog_vbox = QVBoxLayout(self)
dialog_vbox.addWidget(tabs)
dialog_vbox.addLayout(Buttons(CloseButton(self)))
# Update information
invoke_client(None)
class AnnotationsAppearance(SizePersistedDialog):
'''
Dialog for managing CSS rules, including Preview window
'''
if isosx:
FONT = QFont('Monaco', 12)
elif iswindows:
FONT = QFont('Lucida Console', 9)
elif islinux:
FONT = QFont('Monospace', 9)
FONT.setStyleHint(QFont.TypeWriter)
def __init__(self, parent, icon, prefs):
self.opts = parent.opts
self.parent = parent
self.prefs = prefs
self.icon = icon
super(AnnotationsAppearance, self).__init__(parent, 'appearance_dialog')
self.setWindowTitle('Annotations appearance')
self.setWindowIcon(icon)
self.l = QVBoxLayout(self)
self.setLayout(self.l)
# Add a label for description
#self.description_label = QLabel("Descriptive text here")
#self.l.addWidget(self.description_label)
# Add a group box, vertical layout for preview window
self.preview_gb = QGroupBox(self)
self.preview_gb.setTitle("Preview")
self.preview_vl = QVBoxLayout(self.preview_gb)
self.l.addWidget(self.preview_gb)
self.wv = QWebView()
self.wv.setHtml('<p></p>')
self.wv.setMinimumHeight(100)
self.wv.setMaximumHeight(16777215)
self.wv.setGeometry(0, 0, 200, 100)
self.wv.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.preview_vl.addWidget(self.wv)
# Create a group box, horizontal layout for the table
self.css_table_gb = QGroupBox(self)
self.css_table_gb.setTitle("Annotation elements")
self.elements_hl = QHBoxLayout(self.css_table_gb)
self.l.addWidget(self.css_table_gb)
# Add the group box to the main layout
self.elements_table = AnnotationElementsTable(self, 'annotation_elements_tw')
self.elements_hl.addWidget(self.elements_table)
self.elements_table.initialize()
# Options
self.options_gb = QGroupBox(self)
self.options_gb.setTitle("Options")
self.options_gl = QGridLayout(self.options_gb)
self.l.addWidget(self.options_gb)
current_row = 0
# <hr/> separator
# addWidget(widget, row, col, rowspan, colspan)
self.hr_checkbox = QCheckBox('Add horizontal rule between annotations')
self.hr_checkbox.stateChanged.connect(self.hr_checkbox_changed)
self.hr_checkbox.setCheckState(
prefs.get('appearance_hr_checkbox', False))
self.options_gl.addWidget(self.hr_checkbox, current_row, 0, 1, 4)
current_row += 1
# Timestamp
self.timestamp_fmt_label = QLabel("Timestamp format:")
self.options_gl.addWidget(self.timestamp_fmt_label, current_row, 0)
self.timestamp_fmt_le = QLineEdit(
prefs.get('appearance_timestamp_format', default_timestamp),
parent=self)
self.timestamp_fmt_le.textEdited.connect(self.timestamp_fmt_changed)
self.timestamp_fmt_le.setFont(self.FONT)
self.timestamp_fmt_le.setObjectName('timestamp_fmt_le')
self.timestamp_fmt_le.setToolTip('Format string for timestamp')
self.timestamp_fmt_le.setMaximumWidth(16777215)
self.timestamp_fmt_le.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
self.options_gl.addWidget(self.timestamp_fmt_le, current_row, 1)
self.timestamp_fmt_reset_tb = QToolButton(self)
self.timestamp_fmt_reset_tb.setToolTip("Reset to default")
self.timestamp_fmt_reset_tb.setIcon(QIcon(I('trash.png')))
self.timestamp_fmt_reset_tb.clicked.connect(self.reset_timestamp_to_default)
self.options_gl.addWidget(self.timestamp_fmt_reset_tb, current_row, 2)
self.timestamp_fmt_help_tb = QToolButton(self)
self.timestamp_fmt_help_tb.setToolTip("Format string reference")
self.timestamp_fmt_help_tb.setIcon(QIcon(I('help.png')))
self.timestamp_fmt_help_tb.clicked.connect(self.show_help)
self.options_gl.addWidget(self.timestamp_fmt_help_tb, current_row, 3)
# Button box
bb = QDialogButtonBox(QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
self.l.addWidget(bb)
# Spacer
self.spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
self.l.addItem(self.spacerItem)
# Sizing
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(sizePolicy)
self.resize_dialog()
def hr_checkbox_changed(self, state):
self.prefs.set('appearance_hr_checkbox', state)
self.prefs.commit()
self.elements_table.preview_css()
def reset_timestamp_to_default(self):
from calibre_plugins.marvin_manager.appearance import default_timestamp
self.timestamp_fmt_le.setText(default_timestamp)
self.timestamp_fmt_changed()
def show_help(self):
'''
Display strftime help file
'''
from calibre.gui2 import open_url
path = os.path.join(self.parent.resources_path, 'help/timestamp_formats.html')
open_url(QUrl.fromLocalFile(path))
def sizeHint(self):
return QtCore.QSize(600, 200)
def timestamp_fmt_changed(self):
self.prefs.set('appearance_timestamp_format', str(self.timestamp_fmt_le.text()))
self.prefs.commit()
self.elements_table.preview_css()
class PM_DockWidget(QDockWidget):
"""
PM_DockWidget class provides a dockable widget that can either be docked
inside a PropertyManager OR can be docked in the MainWindow depending
on the <parentWidget> . see DnaSequenceEditor.py for an example.
The dockWidget has its own layout and containerwidget which makes it easy
to add various children widgets similar to how its done in PM_GroupBox
"""
def __init__(self, parentWidget, title = "", showWidget = True):
"""
Constructor for PM_dockWidget
@param showWidget: If true, this class will show the widget
immediately in the __init__ method itself. This is the default behavior
and subclasses may pass appropriate value to this flag
@type showWidget: bool
"""
self.labelWidget = None
self._title = ""
self._widgetList = []
self._rowCount = 0
QDockWidget.__init__(self, parentWidget)
self.parentWidget = parentWidget
self._title = title
self.label = ''
self.labelColumn = 0
self.spanWidth = True
self.labelWidget = None
if self.label: # Create this widget's QLabel.
self.labelWidget = QLabel()
self.labelWidget.setText(self.label)
self.setEnabled(True)
self.setFloating(False)
self.setVisible(showWidget)
self.setWindowTitle(self._title)
self.setAutoFillBackground(True)
self.setPalette(getPalette( None,
QPalette.Window,
pmGrpBoxColor))
self.parentWidget.addDockWidget(Qt.BottomDockWidgetArea, self)
#Define layout
self._containerWidget = QWidget()
self.setWidget(self._containerWidget)
# Create vertical box layout
self.vBoxLayout = QVBoxLayout(self._containerWidget)
self.vBoxLayout.setMargin(1)
self.vBoxLayout.setSpacing(0)
# Create grid layout
self.gridLayout = QGridLayout()
self.gridLayout.setMargin(1)
self.gridLayout.setSpacing(1)
# Insert grid layout in its own vBoxLayout
self.vBoxLayout.addLayout(self.gridLayout)
#self.parentWidget.addPmWidget(self)
self._loadWidgets()
try:
self._addWhatsThisText()
except:
print_compact_traceback("Error loading whatsthis text for this " \
"property manager dock widget.")
try:
self._addToolTipText()
except:
print_compact_traceback("Error loading tool tip text for this " \
"property manager dock widget.")
def _loadWidgets(self):
"""
Subclasses should override this method. Default implementation does
nothing.
@see: DnaSequenceEditor._loadWidgets
"""
pass
def _addWhatsThisText(self):
"""
Add 'What's This' help text for self and child widgets.
Subclasses should override this method.
"""
pass
def _addToolTipText(self):
"""
Add 'Tool tip' help text for self and child widgets.
Subclasses should override this method.
"""
pass
def getPmWidgetPlacementParameters(self, pmWidget):
"""
NOTE: This method is duplicated from PM_GroupBox
Returns all the layout parameters needed to place
a PM_Widget in the group box grid layout.
@param pmWidget: The PM widget.
@type pmWidget: PM_Widget
"""
row = self._rowCount
#PM_CheckBox doesn't have a label. So do the following to decide the
#placement of the checkbox. (can be placed either in column 0 or 1 ,
#This also needs to be implemented for PM_RadioButton, but at present
#the following code doesn't support PM_RadioButton.
if isinstance(pmWidget, PM_CheckBox):
# Set the widget's row and column parameters.
widgetRow = row
widgetColumn = pmWidget.widgetColumn
widgetSpanCols = 1
widgetAlignment = PM_LABEL_LEFT_ALIGNMENT
rowIncrement = 1
#set a virtual label
labelRow = row
labelSpanCols = 1
labelAlignment = PM_LABEL_RIGHT_ALIGNMENT
if widgetColumn == 0:
labelColumn = 1
elif widgetColumn == 1:
labelColumn = 0
return (widgetRow,
widgetColumn,
widgetSpanCols,
widgetAlignment,
rowIncrement,
labelRow,
labelColumn,
labelSpanCols,
labelAlignment)
label = pmWidget.label
labelColumn = pmWidget.labelColumn
spanWidth = pmWidget.spanWidth
if not spanWidth:
# This widget and its label are on the same row
labelRow = row
labelSpanCols = 1
labelAlignment = PM_LABEL_RIGHT_ALIGNMENT
# Set the widget's row and column parameters.
widgetRow = row
widgetColumn = 1
widgetSpanCols = 1
widgetAlignment = PM_LABEL_LEFT_ALIGNMENT
rowIncrement = 1
if labelColumn == 1:
widgetColumn = 0
labelAlignment = PM_LABEL_LEFT_ALIGNMENT
widgetAlignment = PM_LABEL_RIGHT_ALIGNMENT
else:
# This widget spans the full width of the groupbox
if label:
# The label and widget are on separate rows.
# Set the label's row, column and alignment.
labelRow = row
labelColumn = 0
labelSpanCols = 2
# Set this widget's row and column parameters.
widgetRow = row + 1 # Widget is below the label.
widgetColumn = 0
widgetSpanCols = 2
rowIncrement = 2
else: # No label. Just the widget.
labelRow = 0
labelColumn = 0
labelSpanCols = 0
# Set the widget's row and column parameters.
widgetRow = row
widgetColumn = 0
widgetSpanCols = 2
rowIncrement = 1
labelAlignment = PM_LABEL_LEFT_ALIGNMENT
widgetAlignment = PM_LABEL_LEFT_ALIGNMENT
return (widgetRow,
widgetColumn,
widgetSpanCols,
widgetAlignment,
rowIncrement,
labelRow,
labelColumn,
labelSpanCols,
labelAlignment)
def addPmWidget(self, pmWidget):
"""
Add a PM widget and its label to this group box.
@param pmWidget: The PM widget to add.
@type pmWidget: PM_Widget
"""
# Get all the widget and label layout parameters.
widgetRow, \
widgetColumn, \
widgetSpanCols, \
widgetAlignment, \
rowIncrement, \
labelRow, \
labelColumn, \
labelSpanCols, \
labelAlignment = self.getPmWidgetPlacementParameters(pmWidget)
if pmWidget.labelWidget:
#Create Label as a pixmap (instead of text) if a valid icon path
#is provided
labelPath = str(pmWidget.label)
if labelPath and labelPath.startswith("ui/"): #bruce 080325 revised
labelPixmap = getpixmap(labelPath)
if not labelPixmap.isNull():
pmWidget.labelWidget.setPixmap(labelPixmap)
pmWidget.labelWidget.setText('')
self.gridLayout.addWidget( pmWidget.labelWidget,
labelRow,
labelColumn,
1,
labelSpanCols,
labelAlignment )
# The following is a workaround for a Qt bug. If addWidth()'s
# <alignment> argument is not supplied, the widget spans the full
# column width of the grid cell containing it. If <alignment>
# is supplied, this desired behavior is lost and there is no
# value that can be supplied to maintain the behavior (0 doesn't
# work). The workaround is to call addWidget() without the <alignment>
# argument. Mark 2007-07-27.
if widgetAlignment == PM_LABEL_LEFT_ALIGNMENT:
self.gridLayout.addWidget( pmWidget,
widgetRow,
widgetColumn,
1,
widgetSpanCols)
# aligment = 0 doesn't work.
else:
self.gridLayout.addWidget( pmWidget,
widgetRow,
widgetColumn,
1,
widgetSpanCols,
widgetAlignment)
self._rowCount += rowIncrement
def __init__(self, window, plugin):
self.plugin = plugin
self.window = window # The main electrum window
title = _("%s Settings") % plugin.device
super(SettingsDialog, self).__init__(window, title)
self.setMaximumWidth(540)
hs_rows, hs_cols = (64, 128)
def get_client(lookup=DeviceMgr.PAIRED):
return self.plugin.get_client(wallet, lookup)
def update():
features = get_client(DeviceMgr.PAIRED).features
self.features = features
# The above was for outer scopes. Now the real logic.
set_label_enabled()
bl_hash = features.bootloader_hash.encode('hex')
bl_hash = "\n".join([bl_hash[:32], bl_hash[32:]])
noyes = [_("No"), _("Yes")]
endis = [_("Enable Passphrases"), _("Disable Passphrases")]
setchange = [_("Set a PIN"), _("Change PIN")]
version = "%d.%d.%d" % (features.major_version,
features.minor_version,
features.patch_version)
coins = ", ".join(coin.coin_name for coin in features.coins)
device_label.setText(features.label)
pin_set_label.setText(noyes[features.pin_protection])
bl_hash_label.setText(bl_hash)
label_edit.setText(features.label)
device_id_label.setText(features.device_id)
initialized_label.setText(noyes[features.initialized])
version_label.setText(version)
coins_label.setText(coins)
clear_pin_button.setVisible(features.pin_protection)
clear_pin_warning.setVisible(features.pin_protection)
pin_button.setText(setchange[features.pin_protection])
pin_msg.setVisible(not features.pin_protection)
passphrase_button.setText(endis[features.passphrase_protection])
language_label.setText(features.language)
def set_label_enabled():
label_apply.setEnabled(label_edit.text() != self.features.label)
def rename():
get_client().change_label(unicode(label_edit.text()))
update()
def toggle_passphrase():
title = _("Confirm Toggle Passphrase Protection")
msg = _("This will cause your Electrum wallet to be unpaired "
"unless your passphrase was or will be empty.\n\n"
"This is because addresses will no "
"longer correspond to those used by your %s.\n\n"
"You will need to create a new Electrum wallet "
"with the install wizard so that they match.\n\n"
"Are you sure you want to proceed?") % plugin.device
if not self.question(msg, title=title):
return
get_client().toggle_passphrase()
self.device_manager().close_wallet(wallet) # Unpair
update()
def change_homescreen():
dialog = QFileDialog(self, _("Choose Homescreen"))
filename = dialog.getOpenFileName()
if filename:
im = Image.open(str(filename))
if im.size != (hs_cols, hs_rows):
raise Exception('Image must be 64 x 128 pixels')
im = im.convert('1')
pix = im.load()
img = ''
for j in range(hs_rows):
for i in range(hs_cols):
img += '1' if pix[i, j] else '0'
img = ''.join(chr(int(img[i:i + 8], 2))
for i in range(0, len(img), 8))
get_client().change_homescreen(img)
def clear_homescreen():
get_client().change_homescreen('\x00')
def set_pin(remove=False):
get_client().set_pin(remove=remove)
update()
def clear_pin():
set_pin(remove=True)
def wipe_device():
# FIXME: cannot yet wipe a device that is only plugged in
if sum(wallet.get_balance()):
title = _("Confirm Device Wipe")
msg = _("Are you SURE you want to wipe the device?\n"
"Your wallet still has bitcoins in it!")
if not self.question(msg, title=title,
icon=QMessageBox.Critical):
return
# Note: we use PRESENT so that a user who has forgotten
# their PIN is not prevented from wiping their device
get_client(DeviceMgr.PRESENT).wipe_device()
self.device_manager().close_wallet(wallet)
update()
def slider_moved():
mins = timeout_slider.sliderPosition()
timeout_minutes.setText(_("%2d minutes") % mins)
wallet = window.wallet
handler = wallet.handler
device = plugin.device
dialog_vbox = QVBoxLayout(self)
# Information tab
info_tab = QWidget()
info_layout = QVBoxLayout(info_tab)
info_glayout = QGridLayout()
info_glayout.setColumnStretch(2, 1)
device_label = QLabel()
pin_set_label = QLabel()
version_label = QLabel()
device_id_label = QLabel()
bl_hash_label = QLabel()
bl_hash_label.setWordWrap(True)
coins_label = QLabel()
coins_label.setWordWrap(True)
language_label = QLabel()
initialized_label = QLabel()
rows = [
(_("Device Label"), device_label),
(_("PIN set"), pin_set_label),
(_("Firmware Version"), version_label),
(_("Serial Number"), device_id_label),
(_("Bootloader Hash"), bl_hash_label),
(_("Supported Coins"), coins_label),
(_("Language"), language_label),
(_("Initialized"), initialized_label),
]
for row_num, (label, widget) in enumerate(rows):
info_glayout.addWidget(QLabel(label), row_num, 0)
info_glayout.addWidget(widget, row_num, 1)
info_layout.addLayout(info_glayout)
# Settings tab
settings_tab = QWidget()
settings_layout = QVBoxLayout(settings_tab)
settings_glayout = QGridLayout()
#settings_glayout.setColumnStretch(3, 1)
# Settings tab - Label
label_msg = QLabel(_("Name this %s. If you have mutiple devices "
"their labels help distinguish them.")
% plugin.device)
label_msg.setWordWrap(True)
label_label = QLabel(_("Device Label"))
label_edit = QLineEdit()
label_edit.setMinimumWidth(150)
label_edit.setMaxLength(self.plugin.MAX_LABEL_LEN)
label_apply = QPushButton(_("Apply"))
label_apply.clicked.connect(rename)
label_edit.textChanged.connect(set_label_enabled)
settings_glayout.addWidget(label_label, 0, 0)
settings_glayout.addWidget(label_edit, 0, 1, 1, 2)
settings_glayout.addWidget(label_apply, 0, 3)
settings_glayout.addWidget(label_msg, 1, 1, 1, -1)
# Settings tab - PIN
pin_label = QLabel(_("PIN Protection"))
pin_button = QPushButton()
pin_button.clicked.connect(set_pin)
settings_glayout.addWidget(pin_label, 2, 0)
settings_glayout.addWidget(pin_button, 2, 1)
pin_msg = QLabel(_("PIN protection is strongly recommended. "
"A PIN is your only protection against someone "
"stealing your bitcoins if they obtain physical "
"access to your %s.") % plugin.device)
pin_msg.setWordWrap(True)
pin_msg.setStyleSheet("color: red")
settings_glayout.addWidget(pin_msg, 3, 1, 1, -1)
settings_layout.addLayout(settings_glayout)
# Settings tab - Homescreen
homescreen_layout = QHBoxLayout()
homescreen_label = QLabel(_("Homescreen"))
homescreen_change_button = QPushButton(_("Change..."))
homescreen_clear_button = QPushButton(_("Reset"))
homescreen_change_button.clicked.connect(change_homescreen)
homescreen_clear_button.clicked.connect(clear_homescreen)
homescreen_msg = QLabel(_("You can set the homescreen on your device "
"to personalize it. You must choose a "
"%d x %d monochrome black and white image.")
% (hs_rows, hs_cols))
homescreen_msg.setWordWrap(True)
settings_glayout.addWidget(homescreen_label, 4, 0)
settings_glayout.addWidget(homescreen_change_button, 4, 1)
settings_glayout.addWidget(homescreen_clear_button, 4, 2)
settings_glayout.addWidget(homescreen_msg, 5, 1, 1, -1)
# Settings tab - Session Timeout
timeout_label = QLabel(_("Session Timeout"))
timeout_minutes = QLabel()
timeout_slider = self.slider = QSlider(Qt.Horizontal)
timeout_slider.setRange(1, 60)
timeout_slider.setSingleStep(1)
timeout_slider.setSliderPosition(wallet.session_timeout // 60)
timeout_slider.setTickInterval(5)
timeout_slider.setTickPosition(QSlider.TicksBelow)
timeout_slider.setTracking(True)
timeout_slider.valueChanged.connect(slider_moved)
timeout_msg = QLabel(_("Clear the session after the specified period "
"of inactivity. Once a session has timed out, "
"your PIN and passphrase (if enabled) must be "
"re-entered to use the device."))
timeout_msg.setWordWrap(True)
settings_glayout.addWidget(timeout_label, 6, 0)
settings_glayout.addWidget(timeout_slider, 6, 1, 1, 3)
settings_glayout.addWidget(timeout_minutes, 6, 4)
settings_glayout.addWidget(timeout_msg, 7, 1, 1, -1)
# Advanced tab
advanced_tab = QWidget()
advanced_layout = QVBoxLayout(advanced_tab)
advanced_glayout = QGridLayout()
# Advanced tab - clear PIN
clear_pin_button = QPushButton(_("Disable PIN"))
clear_pin_button.clicked.connect(clear_pin)
clear_pin_warning = QLabel(_("If you disable your PIN, anyone with "
"physical access to your %s device can "
"spend your bitcoins.") % plugin.device)
clear_pin_warning.setWordWrap(True)
clear_pin_warning.setStyleSheet("color: red")
advanced_glayout.addWidget(clear_pin_button, 0, 2)
advanced_glayout.addWidget(clear_pin_warning, 1, 0, 1, 5)
# Advanced tab - toggle passphrase protection
passphrase_button = QPushButton()
passphrase_button.clicked.connect(toggle_passphrase)
passphrase_msg = QLabel(
_("Passphrases allow you to access new wallets, each "
"hidden behind a particular case-sensitive passphrase. You "
"need to create a separate Electrum wallet for each passphrase "
"you use as they each generate different addresses. Changing "
"your passphrase does not lose other wallets, each is still "
"accessible behind its own passphrase."))
passphrase_msg.setWordWrap(True)
passphrase_warning = QLabel(
_("If you forget a passphrase you will be unable to access any "
"bitcoins in the wallet behind it. A passphrase is not a PIN. "
"Only change this if you are sure you understand it."))
passphrase_warning.setWordWrap(True)
passphrase_warning.setStyleSheet("color: red")
advanced_glayout.addWidget(passphrase_button, 3, 2)
advanced_glayout.addWidget(passphrase_msg, 4, 0, 1, 5)
advanced_glayout.addWidget(passphrase_warning, 5, 0, 1, 5)
# Advanced tab - wipe device
wipe_device_button = QPushButton(_("Wipe Device"))
wipe_device_button.clicked.connect(wipe_device)
wipe_device_msg = QLabel(
_("Wipe the device, removing all data from it. The firmware "
"is left unchanged."))
wipe_device_msg.setWordWrap(True)
wipe_device_warning = QLabel(
_("Only wipe a device if you have the recovery seed written down "
"and the device wallet(s) are empty, otherwise the bitcoins "
"will be lost forever."))
wipe_device_warning.setWordWrap(True)
wipe_device_warning.setStyleSheet("color: red")
advanced_glayout.addWidget(wipe_device_button, 6, 2)
advanced_glayout.addWidget(wipe_device_msg, 7, 0, 1, 5)
advanced_glayout.addWidget(wipe_device_warning, 8, 0, 1, 5)
advanced_layout.addLayout(advanced_glayout)
advanced_layout.addStretch(1)
tabs = QTabWidget(self)
tabs.addTab(info_tab, _("Information"))
tabs.addTab(settings_tab, _("Settings"))
tabs.addTab(advanced_tab, _("Advanced"))
# Update information and then connect change slots
update()
slider_moved()
dialog_vbox.addWidget(tabs)
dialog_vbox.addLayout(Buttons(CloseButton(self)))
def populate_metadata_page(layout, db, book_id, bulk=False, two_column=False, parent=None):
def widget_factory(typ, key):
if bulk:
w = bulk_widgets[typ](db, key, parent)
else:
w = widgets[typ](db, key, parent)
if book_id is not None:
w.initialize(book_id)
return w
fm = db.field_metadata
# Get list of all non-composite custom fields. We must make widgets for these
fields = fm.custom_field_keys(include_composites=False)
cols_to_display = fields
cols_to_display.sort(key=partial(field_sort_key, fm=fm))
# This will contain the fields in the order to display them
cols = []
# The fields named here must be first in the widget list
tweak_cols = tweaks['metadata_edit_custom_column_order']
comments_in_tweak = 0
for key in (tweak_cols or ()):
# Add the key if it really exists in the database
if key in cols_to_display:
cols.append(key)
if fm[key]['datatype'] == 'comments':
comments_in_tweak += 1
# Add all the remaining fields
comments_not_in_tweak = 0
for key in cols_to_display:
if key not in cols:
cols.append(key)
if fm[key]['datatype'] == 'comments':
comments_not_in_tweak += 1
count = len(cols)
layout_rows_for_comments = 9
if two_column:
turnover_point = ((count-comments_not_in_tweak+1) +
comments_in_tweak*(layout_rows_for_comments-1))/2
else:
# Avoid problems with multi-line widgets
turnover_point = count + 1000
ans = []
column = row = base_row = max_row = 0
for key in cols:
if not fm[key]['is_editable']:
continue # this almost never happens
dt = fm[key]['datatype']
if dt == 'composite' or (bulk and dt == 'comments'):
continue
w = widget_factory(dt, fm[key]['colnum'])
ans.append(w)
if two_column and dt == 'comments':
# Here for compatibility with old layout. Comments always started
# in the left column
comments_in_tweak -= 1
# no special processing if the comment field was named in the tweak
if comments_in_tweak < 0 and comments_not_in_tweak > 0:
# Force a turnover, adding comments widgets below max_row.
# Save the row to return to if we turn over again
column = 0
row = max_row
base_row = row
turnover_point = row + (comments_not_in_tweak * layout_rows_for_comments)/2
comments_not_in_tweak = 0
l = QGridLayout()
if dt == 'comments':
layout.addLayout(l, row, column, layout_rows_for_comments, 1)
layout.setColumnStretch(column, 100)
row += layout_rows_for_comments
else:
layout.addLayout(l, row, column, 1, 1)
layout.setColumnStretch(column, 100)
row += 1
for c in range(0, len(w.widgets), 2):
if dt != 'comments':
w.widgets[c].setWordWrap(True)
w.widgets[c].setBuddy(w.widgets[c+1])
l.addWidget(w.widgets[c], c, 0)
l.addWidget(w.widgets[c+1], c, 1)
l.setColumnStretch(1, 10000)
else:
l.addWidget(w.widgets[0], 0, 0, 1, 2)
l.addItem(QSpacerItem(0, 0, vPolicy=QSizePolicy.Expanding), c, 0, 1, 1)
max_row = max(max_row, row)
if row >= turnover_point:
column = 1
turnover_point = count + 1000
row = base_row
items = []
if len(ans) > 0:
items.append(QSpacerItem(10, 10, QSizePolicy.Minimum,
QSizePolicy.Expanding))
layout.addItem(items[-1], layout.rowCount(), 0, 1, 1)
layout.setRowStretch(layout.rowCount()-1, 100)
return ans, items
def do_layout(self):
self.central_widget.clear()
self.tabs = []
self.labels = []
sto = QWidget.setTabOrder
self.on_drag_enter.connect(self.handle_drag_enter)
self.tabs.append(DragTrackingWidget(self, self.on_drag_enter))
self.central_widget.addTab(self.tabs[0], _("&Metadata"))
self.tabs[0].l = QGridLayout()
self.tabs[0].setLayout(self.tabs[0].l)
self.tabs.append(QWidget(self))
self.central_widget.addTab(self.tabs[1], _("&Cover and formats"))
self.tabs[1].l = QGridLayout()
self.tabs[1].setLayout(self.tabs[1].l)
# accept drop events so we can automatically switch to the second tab to
# drop covers and formats
self.tabs[0].setAcceptDrops(True)
# Tab 0
tab0 = self.tabs[0]
tl = QGridLayout()
gb = QGroupBox(_('&Basic metadata'), self.tabs[0])
self.tabs[0].l.addWidget(gb, 0, 0, 1, 1)
gb.setLayout(tl)
self.button_box_layout.insertWidget(1, self.fetch_metadata_button)
self.button_box_layout.insertWidget(2, self.config_metadata_button)
sto(self.button_box, self.fetch_metadata_button)
sto(self.fetch_metadata_button, self.config_metadata_button)
sto(self.config_metadata_button, self.title)
def create_row(row, widget, tab_to, button=None, icon=None, span=1):
ql = BuddyLabel(widget)
tl.addWidget(ql, row, 1, 1, 1)
tl.addWidget(widget, row, 2, 1, 1)
if button is not None:
tl.addWidget(button, row, 3, span, 1)
if icon is not None:
button.setIcon(QIcon(I(icon)))
if tab_to is not None:
if button is not None:
sto(widget, button)
sto(button, tab_to)
else:
sto(widget, tab_to)
tl.addWidget(self.swap_title_author_button, 0, 0, 2, 1)
tl.addWidget(self.manage_authors_button, 2, 0, 1, 1)
tl.addWidget(self.paste_isbn_button, 12, 0, 1, 1)
tl.addWidget(self.tags_editor_button, 6, 0, 1, 1)
create_row(0,
self.title,
self.title_sort,
button=self.deduce_title_sort_button,
span=2,
icon='auto_author_sort.png')
create_row(1, self.title_sort, self.authors)
create_row(2,
self.authors,
self.author_sort,
button=self.deduce_author_sort_button,
span=2,
icon='auto_author_sort.png')
create_row(3, self.author_sort, self.series)
create_row(4,
self.series,
self.series_index,
button=self.clear_series_button,
icon='trash.png')
create_row(5, self.series_index, self.tags)
create_row(6, self.tags, self.rating, button=self.clear_tags_button)
create_row(7,
self.rating,
self.pubdate,
button=self.clear_ratings_button)
create_row(8,
self.pubdate,
self.publisher,
button=self.pubdate.clear_button,
icon='trash.png')
create_row(9, self.publisher, self.languages)
create_row(10, self.languages, self.timestamp)
create_row(11,
self.timestamp,
self.identifiers,
button=self.timestamp.clear_button,
icon='trash.png')
create_row(12,
self.identifiers,
self.comments,
button=self.clear_identifiers_button,
icon='trash.png')
sto(self.clear_identifiers_button, self.swap_title_author_button)
sto(self.swap_title_author_button, self.manage_authors_button)
sto(self.manage_authors_button, self.tags_editor_button)
sto(self.tags_editor_button, self.paste_isbn_button)
tl.addItem(QSpacerItem(1, 1, QSizePolicy.Fixed, QSizePolicy.Expanding),
13, 1, 1, 1)
w = getattr(self, 'custom_metadata_widgets_parent', None)
if w is not None:
gb = QGroupBox(_('C&ustom metadata'), tab0)
gbl = QVBoxLayout()
gb.setLayout(gbl)
sr = QScrollArea(tab0)
sr.setWidgetResizable(True)
sr.setFrameStyle(QFrame.NoFrame)
sr.setWidget(w)
gbl.addWidget(sr)
self.tabs[0].l.addWidget(gb, 0, 1, 1, 1)
sto(self.identifiers, gb)
w = QGroupBox(_('&Comments'), tab0)
sp = QSizePolicy()
sp.setVerticalStretch(10)
sp.setHorizontalPolicy(QSizePolicy.Expanding)
sp.setVerticalPolicy(QSizePolicy.Expanding)
w.setSizePolicy(sp)
l = QHBoxLayout()
w.setLayout(l)
l.addWidget(self.comments)
tab0.l.addWidget(w, 1, 0, 1, 2)
# Tab 1
tab1 = self.tabs[1]
wsp = QWidget(tab1)
wgl = QVBoxLayout()
wsp.setLayout(wgl)
# right-hand side of splitter
gb = QGroupBox(_('Change cover'), tab1)
l = QGridLayout()
gb.setLayout(l)
for i, b in enumerate(self.cover.buttons[:3]):
l.addWidget(b, 0, i, 1, 1)
sto(b, self.cover.buttons[i + 1])
hl = QHBoxLayout()
for b in self.cover.buttons[3:]:
hl.addWidget(b)
sto(self.cover.buttons[-2], self.cover.buttons[-1])
l.addLayout(hl, 1, 0, 1, 3)
wgl.addWidget(gb)
wgl.addItem(
QSpacerItem(10, 10, QSizePolicy.Expanding, QSizePolicy.Expanding))
wgl.addItem(
QSpacerItem(10, 10, QSizePolicy.Expanding, QSizePolicy.Expanding))
wgl.addWidget(self.formats_manager)
self.splitter = QSplitter(Qt.Horizontal, tab1)
tab1.l.addWidget(self.splitter)
self.splitter.addWidget(self.cover)
self.splitter.addWidget(wsp)
self.formats_manager.formats.setMaximumWidth(10000)
self.formats_manager.formats.setIconSize(QSize(64, 64))
