def _initialize_file_type_settings(self, layout):
'''Initialize file creation/sending type settings'''
separator_b = QFrame()
separator_b.setFrameStyle(QFrame.HLine)
separator_b.setFrameShadow(QFrame.Sunken)
layout.addWidget(separator_b)
book_types_to_create = QGroupBox()
book_types_to_create.setTitle('Book types to create files for:')
book_types_to_create.setLayout(QHBoxLayout(book_types_to_create))
self._settings['mobi'] = QCheckBox('MOBI')
self._settings['mobi'].setChecked('mobi' in __prefs__['formats'])
book_types_to_create.layout().addWidget(self._settings['mobi'])
self._settings['azw3'] = QCheckBox('AZW3')
self._settings['azw3'].setChecked('azw3' in __prefs__['formats'])
book_types_to_create.layout().addWidget(self._settings['azw3'])
layout.addWidget(book_types_to_create)
file_preference_layout = QGroupBox()
file_preference_layout.setTitle('If device has both (mobi and azw3) formats, prefer:')
file_preference_layout.setLayout(QHBoxLayout(file_preference_layout))
file_preference_group = QButtonGroup()
self._settings['file_preference_mobi'] = QRadioButton('MOBI')
self._settings['file_preference_mobi'].setChecked(__prefs__['file_preference'] == 'mobi')
file_preference_group.addButton(self._settings['file_preference_mobi'])
file_preference_layout.layout().addWidget(self._settings['file_preference_mobi'])
self._settings['file_preference_azw3'] = QRadioButton('AZW3')
self._settings['file_preference_azw3'].setChecked(__prefs__['file_preference'] == 'azw3')
file_preference_group.addButton(self._settings['file_preference_azw3'])
file_preference_layout.layout().addWidget(self._settings['file_preference_azw3'])
layout.addWidget(file_preference_layout)
class Comments(Base):
def setup_ui(self, parent):
self._box = QGroupBox(parent)
self._box.setTitle('&'+self.col_metadata['name'])
self._layout = QVBoxLayout()
self._tb = CommentsEditor(self._box, toolbar_prefs_name=u'metadata-comments-editor-widget-hidden-toolbars')
self._tb.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
# self._tb.setTabChangesFocus(True)
self._layout.addWidget(self._tb)
self._box.setLayout(self._layout)
self.widgets = [self._box]
def setter(self, val):
if not val or not val.strip():
val = ''
else:
val = comments_to_html(val)
self._tb.html = val
self._tb.wyswyg_dirtied()
def getter(self):
val = unicode(self._tb.html).strip()
if not val:
val = None
return val
@dynamic_property
def tab(self):
def fget(self):
return self._tb.tab
def fset(self, val):
self._tb.tab = val
return property(fget=fget, fset=fset)
def _intialize_file_settings(self, layout):
'''Initialize file creation/sending settings'''
separator_a = QFrame()
separator_a.setFrameStyle(QFrame.HLine)
separator_a.setFrameShadow(QFrame.Sunken)
layout.addWidget(separator_a)
files_to_create = QGroupBox()
files_to_create.setTitle('Files to create/send')
files_to_create.setLayout(QGridLayout(files_to_create))
self._settings['create_send_xray'] = QCheckBox('X-Ray')
self._settings['create_send_xray'].setChecked(__prefs__['create_send_xray'])
files_to_create.layout().addWidget(self._settings['create_send_xray'], 0, 0)
self._settings['create_send_author_profile'] = QCheckBox('Author Profile')
self._settings['create_send_author_profile'].setChecked(__prefs__['create_send_author_profile'])
files_to_create.layout().addWidget(self._settings['create_send_author_profile'], 1, 0)
self._settings['create_send_start_actions'] = QCheckBox('Start Actions')
self._settings['create_send_start_actions'].setChecked(__prefs__['create_send_start_actions'])
files_to_create.layout().addWidget(self._settings['create_send_start_actions'], 0, 1)
self._settings['create_send_end_actions'] = QCheckBox('End Actions')
self._settings['create_send_end_actions'].setChecked(__prefs__['create_send_end_actions'])
files_to_create.layout().addWidget(self._settings['create_send_end_actions'], 1, 1)
layout.addWidget(files_to_create)
class Comments(Base):
def setup_ui(self, parent):
self._box = QGroupBox(parent)
self._box.setTitle('&' + self.col_metadata['name'])
self._layout = QVBoxLayout()
self._tb = CommentsEditor(self._box)
self._tb.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
# self._tb.setTabChangesFocus(True)
self._layout.addWidget(self._tb)
self._box.setLayout(self._layout)
self.widgets = [self._box]
def setter(self, val):
if not val or not val.strip():
val = ''
else:
val = comments_to_html(val)
self._tb.html = val
self._tb.wyswyg_dirtied()
def getter(self):
val = unicode(self._tb.html).strip()
if not val:
val = None
return val
class Comments(Base):
def setup_ui(self, parent):
self._box = QGroupBox(parent)
self._box.setTitle('&'+self.col_metadata['name'])
self._layout = QVBoxLayout()
self._tb = CommentsEditor(self._box)
self._tb.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
# self._tb.setTabChangesFocus(True)
self._layout.addWidget(self._tb)
self._box.setLayout(self._layout)
self.widgets = [self._box]
def setter(self, val):
if not val or not val.strip():
val = ''
else:
val = comments_to_html(val)
self._tb.html = val
self._tb.wyswyg_dirtied()
def getter(self):
val = unicode(self._tb.html).strip()
if not val:
val = None
return val
class LongText(Base):
def setup_ui(self, parent):
self._box = QGroupBox(parent)
self._box.setTitle('&' + self.col_metadata['name'])
self._layout = QVBoxLayout()
self._tb = QPlainTextEdit(self._box)
self._tb.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
self._layout.addWidget(self._tb)
self._box.setLayout(self._layout)
self.widgets = [self._box]
def setter(self, val):
self._tb.setPlainText(type('')(val or ''))
def getter(self):
return self._tb.toPlainText()
class LongText(Base):
def setup_ui(self, parent):
self._box = QGroupBox(parent)
self._box.setTitle('&'+self.col_metadata['name'])
self._layout = QVBoxLayout()
self._tb = QPlainTextEdit(self._box)
self._tb.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
self._layout.addWidget(self._tb)
self._box.setLayout(self._layout)
self.widgets = [self._box]
def setter(self, val):
self._tb.setPlainText(type(u'')(val or ''))
def getter(self):
return self._tb.toPlainText()
class Comments(Base):
def setup_ui(self, parent):
self._box = QGroupBox(parent)
self._box.setTitle('&' + self.col_metadata['name'])
self._layout = QVBoxLayout()
self._tb = CommentsEditor(
self._box,
toolbar_prefs_name=
u'metadata-comments-editor-widget-hidden-toolbars')
self._tb.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
# self._tb.setTabChangesFocus(True)
self._layout.addWidget(self._tb)
self._box.setLayout(self._layout)
self.widgets = [self._box]
def initialize(self, book_id):
path = self.db.abspath(book_id, index_is_id=True)
if path:
self._tb.set_base_url(
QUrl.fromLocalFile(os.path.join(path, 'metadata.html')))
return Base.initialize(self, book_id)
def setter(self, val):
if not val or not val.strip():
val = ''
else:
val = comments_to_html(val)
self._tb.html = val
self._tb.wyswyg_dirtied()
def getter(self):
val = unicode(self._tb.html).strip()
if not val:
val = None
return val
@dynamic_property
def tab(self):
def fget(self):
return self._tb.tab
def fset(self, val):
self._tb.tab = val
return property(fget=fget, fset=fset)
def __init__(self, derrors, parent=None):
QDialog.__init__(self, parent=parent)
self.setWindowFlags(Qt.Window)
self.derrors = derrors
buttonBox = QDialogButtonBox(QDialogButtonBox.Close)
browser = QTextBrowser()
browser.setText('')
browser.setFontFamily("Courier")
browser.setFontWeight(QFont.Bold)
browser.setLineWrapMode(QTextBrowser.NoWrap)
browser.setReadOnly(True)
self.ctc_button = QPushButton('Copy to clipboard')
self.ctc_button.setMaximumWidth(100)
gpbox2 = QGroupBox()
lay2 = QHBoxLayout()
gpbox2.setLayout(lay2)
lay2.addWidget(browser)
gpbox2.setMinimumHeight(500)
gpbox2.setMinimumWidth(1000)
lay = QVBoxLayout()
self.setLayout(lay)
lay.addWidget(gpbox2)
lay.addWidget(self.ctc_button)
lay.addWidget(buttonBox)
buttonBox.rejected.connect(self.reject)
self.ctc_button.clicked.connect(self.copy_to_clipboard)
self.setWindowTitle('%s: Calibre error checks' % CAPTION)
if 'scramb' in self.derrors:
msg = 'Original vs. After scrambling'
else:
msg = 'Original - ebook not yet scrambled'
gpbox2.setTitle(msg)
self.report = self.summarise_errors()
browser.setText(self.report)
class Comments(Base):
def setup_ui(self, parent):
self._box = QGroupBox(parent)
self._box.setTitle('&'+self.col_metadata['name'])
self._layout = QVBoxLayout()
self._tb = CommentsEditor(self._box, toolbar_prefs_name=u'metadata-comments-editor-widget-hidden-toolbars')
self._tb.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
# self._tb.setTabChangesFocus(True)
self._layout.addWidget(self._tb)
self._box.setLayout(self._layout)
self.widgets = [self._box]
def initialize(self, book_id):
path = self.db.abspath(book_id, index_is_id=True)
if path:
self._tb.set_base_url(QUrl.fromLocalFile(os.path.join(path, 'metadata.html')))
return Base.initialize(self, book_id)
def setter(self, val):
if not val or not val.strip():
val = ''
else:
val = comments_to_html(val)
self._tb.html = val
self._tb.wyswyg_dirtied()
def getter(self):
val = unicode(self._tb.html).strip()
if not val:
val = None
return val
@dynamic_property
def tab(self):
def fget(self):
return self._tb.tab
def fset(self, val):
self._tb.tab = val
return property(fget=fget, fset=fset)
def _initialize_file_type_settings(self, layout):
'''Initialize file creation/sending type settings'''
separator_b = QFrame()
separator_b.setFrameStyle(QFrame.HLine)
separator_b.setFrameShadow(QFrame.Sunken)
layout.addWidget(separator_b)
book_types_to_create = QGroupBox()
book_types_to_create.setTitle('Book types to create files for:')
book_types_to_create.setLayout(QHBoxLayout(book_types_to_create))
self._settings['mobi'] = QCheckBox('MOBI')
self._settings['mobi'].setChecked('mobi' in __prefs__['formats'])
book_types_to_create.layout().addWidget(self._settings['mobi'])
self._settings['azw3'] = QCheckBox('AZW3')
self._settings['azw3'].setChecked('azw3' in __prefs__['formats'])
book_types_to_create.layout().addWidget(self._settings['azw3'])
layout.addWidget(book_types_to_create)
file_preference_layout = QGroupBox()
file_preference_layout.setTitle(
'If device has both (mobi and azw3) formats, prefer:')
file_preference_layout.setLayout(QHBoxLayout(file_preference_layout))
file_preference_group = QButtonGroup()
self._settings['file_preference_mobi'] = QRadioButton('MOBI')
self._settings['file_preference_mobi'].setChecked(
__prefs__['file_preference'] == 'mobi')
file_preference_group.addButton(self._settings['file_preference_mobi'])
file_preference_layout.layout().addWidget(
self._settings['file_preference_mobi'])
self._settings['file_preference_azw3'] = QRadioButton('AZW3')
self._settings['file_preference_azw3'].setChecked(
__prefs__['file_preference'] == 'azw3')
file_preference_group.addButton(self._settings['file_preference_azw3'])
file_preference_layout.layout().addWidget(
self._settings['file_preference_azw3'])
layout.addWidget(file_preference_layout)
class Comments(Base):
def setup_ui(self, parent):
self._box = QGroupBox(parent)
self._box.setTitle('&' + self.col_metadata['name'])
self._layout = QVBoxLayout()
self._tb = CommentsEditor(
self._box,
toolbar_prefs_name='metadata-comments-editor-widget-hidden-toolbars'
)
self._tb.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
# self._tb.setTabChangesFocus(True)
self._layout.addWidget(self._tb)
self._box.setLayout(self._layout)
self.widgets = [self._box]
def setter(self, val):
if not val or not val.strip():
val = ''
else:
val = comments_to_html(val)
self._tb.html = val
self._tb.wyswyg_dirtied()
def getter(self):
val = str(self._tb.html).strip()
if not val:
val = None
return val
@dynamic_property
def tab(self):
def fget(self):
return self._tb.tab
def fset(self, val):
self._tb.tab = val
return property(fget=fget, fset=fset)
class ConfigWidget(QWidget):
def __init__(self):
QWidget.__init__(self)
self.l = QVBoxLayout()
self.setLayout(self.l)
self.spoilers = QCheckBox('Use spoilers when creating x-ray')
self.spoilers.setChecked(prefs['spoilers'])
self.l.addWidget(self.spoilers)
self.send_to_device = QCheckBox('Send x-ray to device if connected')
self.send_to_device.setChecked(prefs['send_to_device'])
self.l.addWidget(self.send_to_device)
self.create_xray_when_sending = QCheckBox('Create x-ray for files that don\'t already have them when sending to device')
self.create_xray_when_sending.setChecked(prefs['create_xray_when_sending'])
self.l.addWidget(self.create_xray_when_sending)
self.book_types_to_create = QGroupBox()
self.book_types_to_create.setTitle('Book types to create x-ray files for')
self.book_types_to_create.setLayout(QHBoxLayout (self.book_types_to_create))
self.mobi = QCheckBox('MOBI')
self.mobi.setChecked(prefs['mobi'])
self.book_types_to_create.layout().addWidget(self.mobi)
self.azw3 = QCheckBox('AZW3')
self.azw3.setChecked(prefs['azw3'])
self.book_types_to_create.layout().addWidget(self.azw3)
self.l.addWidget(self.book_types_to_create)
def save_settings(self):
prefs['spoilers'] = self.spoilers.isChecked()
prefs['send_to_device'] = self.send_to_device.isChecked()
prefs['create_xray_when_sending'] = self.create_xray_when_sending.isChecked()
prefs['mobi'] = self.mobi.isChecked()
prefs['azw3'] = self.azw3.isChecked()
def _intialize_file_settings(self, layout):
'''Initialize file creation/sending settings'''
separator_a = QFrame()
separator_a.setFrameStyle(QFrame.HLine)
separator_a.setFrameShadow(QFrame.Sunken)
layout.addWidget(separator_a)
files_to_create = QGroupBox()
files_to_create.setTitle('Files to create/send')
files_to_create.setLayout(QGridLayout(files_to_create))
self._settings['create_send_xray'] = QCheckBox('X-Ray')
self._settings['create_send_xray'].setChecked(
__prefs__['create_send_xray'])
files_to_create.layout().addWidget(self._settings['create_send_xray'],
0, 0)
self._settings['create_send_author_profile'] = QCheckBox(
'Author Profile')
self._settings['create_send_author_profile'].setChecked(
__prefs__['create_send_author_profile'])
files_to_create.layout().addWidget(
self._settings['create_send_author_profile'], 1, 0)
self._settings['create_send_start_actions'] = QCheckBox(
'Start Actions')
self._settings['create_send_start_actions'].setChecked(
__prefs__['create_send_start_actions'])
files_to_create.layout().addWidget(
self._settings['create_send_start_actions'], 0, 1)
self._settings['create_send_end_actions'] = QCheckBox('End Actions')
self._settings['create_send_end_actions'].setChecked(
__prefs__['create_send_end_actions'])
files_to_create.layout().addWidget(
self._settings['create_send_end_actions'], 1, 1)
layout.addWidget(files_to_create)
class MainWin(QMainWindow):
def __init__(self, fileName=None, logName=None, parent=None):
super(MainWin, self).__init__(parent)
#self.setWindowIcon(QIcon(':/images/logo.png'))
self.setToolButtonStyle(Qt.ToolButtonFollowStyle)
self.setupFileActions()
self.setupEditActions()
self.setupTextActions()
self.setupRunActions()
self.initializeSettings()
self.populateRunSettings() # FIXME put in initializeSettings()?
settingsMenu = QMenu('Settings', self)
self.menuBar().addMenu(settingsMenu)
settingsMenu.addAction('Configure...', self.configure)
helpMenu = QMenu("Help", self)
self.menuBar().addMenu(helpMenu)
helpMenu.addAction("About", self.about)
helpMenu.addAction("About &Qt", QApplication.instance().aboutQt)
self.splitter = QSplitter(self)
self.splitter.setOrientation(Qt.Vertical)
self.textPane = TextPane()
self.logPane = LogPane()
self.logBox = QGroupBox()
self.logBox.setFlat(True)
vbox = QVBoxLayout()
vbox.addWidget(self.logPane)
self.logBox.setLayout(vbox)
self.splitter.addWidget(self.textPane)
self.splitter.addWidget(QLabel()) # spacer
self.splitter.addWidget(self.logBox)
self.setCentralWidget(self.splitter)
self.loadSrc(fileName)
self.loadLog(logName)
#if logName and (-1 == self.comboLogFile.findText(logName)):
#self.comboLogFile.addItem(logName)
self.logPane.setFocus()
self.fontChanged(self.textPane.font())
self.textPane.document().modificationChanged.connect(self.actionSave.setEnabled)
self.textPane.document().modificationChanged.connect(self.setWindowModified)
self.textPane.document().undoAvailable.connect(self.actionUndo.setEnabled)
self.textPane.document().redoAvailable.connect( self.actionRedo.setEnabled)
self.setWindowModified(self.textPane.document().isModified())
self.actionSave.setEnabled(self.textPane.document().isModified())
self.actionUndo.setEnabled(self.textPane.document().isUndoAvailable())
self.actionRedo.setEnabled(self.textPane.document().isRedoAvailable())
self.actionUndo.triggered.connect(self.textPane.undo)
self.actionRedo.triggered.connect(self.textPane.redo)
self.actionCut.setEnabled(False)
self.actionCopy.setEnabled(False)
self.actionCut.triggered.connect(self.textPane.cut)
self.actionCopy.triggered.connect(self.textPane.copy)
self.actionPaste.triggered.connect(self.textPane.paste)
self.textPane.copyAvailable.connect(self.actionCut.setEnabled)
self.textPane.copyAvailable.connect(self.actionCopy.setEnabled)
QApplication.clipboard().dataChanged.connect(self.clipboardDataChanged)
self.actionRun.triggered.connect(self.scannoCheck)
self.logPane.lineMatchChanged.connect(self.logLineMatchChanged)
def closeEvent(self, e):
if self.maybeSave():
e.accept()
else:
e.ignore()
def setupFileActions(self):
tb = QToolBar(self)
tb.setWindowTitle("File Actions")
self.addToolBar(tb)
menu = QMenu("&File", self)
self.menuBar().addMenu(menu)
self.actionNew = QAction("&New", self, priority=QAction.LowPriority,
shortcut=QKeySequence.New, triggered=self.fileNew)
tb.addAction(self.actionNew)
menu.addAction(self.actionNew)
self.actionOpen = QAction("&Open...", self, shortcut=QKeySequence.Open,
triggered=self.fileOpen)
tb.addAction(self.actionOpen)
menu.addAction(self.actionOpen)
menu.addSeparator()
self.actionSave = QAction("&Save", self, shortcut=QKeySequence.Save,
triggered=self.fileSave, enabled=False)
tb.addAction(self.actionSave)
menu.addAction(self.actionSave)
self.actionSaveAs = QAction("Save &As...", self, priority=QAction.LowPriority,
shortcut=Qt.CTRL + Qt.SHIFT + Qt.Key_S, triggered=self.fileSaveAs)
menu.addAction(self.actionSaveAs)
menu.addSeparator()
self.actionQuit = QAction("&Quit", self, shortcut=QKeySequence.Quit, triggered=self.close)
menu.addAction(self.actionQuit)
def setupEditActions(self):
tb = QToolBar(self)
tb.setWindowTitle("Edit Actions")
self.addToolBar(tb)
menu = QMenu("&Edit", self)
self.menuBar().addMenu(menu)
self.actionUndo = QAction("&Undo", self, shortcut=QKeySequence.Undo)
tb.addAction(self.actionUndo)
menu.addAction(self.actionUndo)
self.actionRedo = QAction("&Redo", self, priority=QAction.LowPriority, shortcut=QKeySequence.Redo)
tb.addAction(self.actionRedo)
menu.addAction(self.actionRedo)
menu.addSeparator()
self.actionCut = QAction("Cu&t", self, priority=QAction.LowPriority, shortcut=QKeySequence.Cut)
tb.addAction(self.actionCut)
menu.addAction(self.actionCut)
self.actionCopy = QAction("&Copy", self, priority=QAction.LowPriority, shortcut=QKeySequence.Copy)
tb.addAction(self.actionCopy)
menu.addAction(self.actionCopy)
self.actionPaste = QAction("&Paste", self, priority=QAction.LowPriority,
shortcut=QKeySequence.Paste, enabled=(len(QApplication.clipboard().text()) != 0))
tb.addAction(self.actionPaste)
menu.addAction(self.actionPaste)
def setupTextActions(self):
tb = QToolBar(self)
tb.setWindowTitle("Format Actions")
self.addToolBar(tb)
tb = QToolBar(self)
tb.setAllowedAreas(Qt.TopToolBarArea | Qt.BottomToolBarArea)
tb.setWindowTitle("Format Actions")
self.addToolBarBreak(Qt.TopToolBarArea)
self.addToolBar(tb)
self.comboFont = QFontComboBox(tb)
tb.addWidget(self.comboFont)
self.comboFont.activated[str].connect(self.textFamily)
self.comboSize = QComboBox(tb)
self.comboSize.setObjectName("comboSize")
tb.addWidget(self.comboSize)
self.comboSize.setEditable(True)
db = QFontDatabase()
for size in db.standardSizes():
self.comboSize.addItem('{}'.format(size))
self.comboSize.activated[str].connect(self.textSize)
self.comboSize.setCurrentIndex(self.comboSize.findText('{}'.format(QApplication.font().pointSize())))
def setupRunActions(self):
tb = QToolBar(self)
tb.setWindowTitle("Run Actions")
self.addToolBar(tb)
menu = QMenu("Run", self)
self.menuBar().addMenu(menu)
self.actionRun = QAction(
"&Run", self, shortcut=Qt.CTRL + Qt.Key_R)
tb.addAction(self.actionRun)
menu.addAction(self.actionRun)
self.comboScannoFile = QComboBox(tb)
self.comboScannoFile.setObjectName("comboScannoFile")
tb.addWidget(self.comboScannoFile)
self.comboScannoFile.setEditable(True)
self.comboLogFile= QComboBox(tb)
self.comboLogFile.setObjectName("comboLogFile")
self.comboLogFile.setEditable(True)
tb.addWidget(self.comboLogFile)
def populateRunSettings(self):
for f in self.scannoFiles():
self.comboScannoFile.addItem(f)
if self.defaultScannoFile:
idx = self.comboScannoFile.findText(self.defaultScannoFile)
self.comboScannoFile.setCurrentIndex(idx)
self.comboLogFile.addItem('plog.txt')
def loadSrc(self, src):
if src:
if not self.textPane.load(src):
return False
self.setCurrentFileName(src)
return True
def loadLog(self, log):
if log:
if not self.logPane.load(log):
return False
self.comboLogFile.clear()
self.comboLogFile.addItem(log)
else:
self.logPane.clear()
self.logPane.setEnabled(False)
self.logBox.setTitle(self.tr('No log file loaded.'))
return True
def maybeSave(self):
if not self.textPane.document().isModified():
return True
ret = QMessageBox.warning(self, 'GuiScannos',
'The document has been modified.\n'
'Do you want to save your changes?',
QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
if ret == QMessageBox.Save:
return self.fileSave()
if ret == QMessageBox.Cancel:
return False
return True
def setCurrentFileName(self, fileName=''):
self.fileName = fileName
self.textPane.document().setModified(False)
if not fileName:
shownName = 'untitled.txt'
self.actionRun.setEnabled(False)
else:
shownName = QFileInfo(fileName).fileName()
self.actionRun.setEnabled(True)
self.setWindowTitle(self.tr('{}[*] - {}'.format(shownName, 'GUI Scannos')))
self.setWindowModified(False)
def fileNew(self):
if self.maybeSave():
self.textPane.clear()
self.loadLog(None) # clears logPane, logBox title, etc
self.setCurrentFileName()
def fileOpen(self):
fn, _ = QFileDialog.getOpenFileName(self, 'Open File...', None, 'Text Files (*.txt);;All Files (*)')
if fn:
self.loadSrc(fn)
self.loadLog(None) # clears logPane, logBox title, etc
def fileSave(self):
if not self.fileName:
return self.fileSaveAs()
return self.textpane.save(self.fileName)
def fileSaveAs(self):
fn, _ = QFileDialog.getSaveFileName(self, "Save as...", None, "text files (*.txt);;All Files (*)")
if not fn:
return False
self.setCurrentFileName(fn)
return self.fileSave()
def logLineMatchChanged(self):
linenum = self.logPane.srcLineNum()
col = self.logPane.srcColNum()
s = self.logPane.srcScanno()
self.textPane.setSelection(linenum, col, len(s))
def textFamily(self, family):
"""Set font family for text and log panes."""
self.textPane.setFontFamily(family)
self.logPane.setFontFamily(family)
def textSize(self, pointSize):
"""Set font size for text and log panes."""
self.textPane.setFontPointSize(pointSize)
self.logPane.setFontPointSize(pointSize)
def clipboardDataChanged(self):
self.actionPaste.setEnabled(len(QApplication.clipboard().text()) != 0)
def about(self):
QMessageBox.about(self, 'About', 'GUI for ppscannos.')
def fontChanged(self, font):
self.comboFont.setCurrentIndex(self.comboFont.findText(QFontInfo(font).family()))
self.comboSize.setCurrentIndex(self.comboSize.findText('{}'.format(font.pointSize())))
def scannoCheck(self):
"""Run ppscannos."""
scannodir = os.path.dirname(self.ppscannos)
cmd = sys.executable
assert(cmd)
scannoFile = self.comboScannoFile.currentText()
if not scannoFile:
scannoFile = self.defaultScannoFile
scannoFile = scannodir + '/' + scannoFile
src = self.fileName
log = self.comboLogFile.currentText()
if not log:
log = './plog.txt'
subprocess.call([cmd, self.ppscannos, '-s' + scannoFile, '-o' + log, '-i' + src])
self.loadLog(log)
self.logPane.setEnabled(True)
def configure(self):
"""Configure application settings by way of a dialog."""
dlg = ConfigDialog()
if dlg.exec():
self.setPPScannos(dlg.lineEditPPScannos.text())
self.setDefaultScannoFile(dlg.comboScannoFiles.currentText())
settings = QSettings(QApplication.organizationName(), QApplication.applicationName())
settings.setValue('ppscannos', self.ppscannos)
settings.setValue('defaultScannoFile', self.defaultScannoFile)
def setPPScannos(self, s):
self.ppscannos = s
self.actionRun.setEnabled(self.ppscannos and os.path.exists(self.ppscannos))
def scannoFiles(self):
"""Return list of .rc filenames (without path) that are in ppscannos directory."""
if not self.ppscannos:
return []
return getRCFilesForDir(os.path.dirname(self.ppscannos))
def setDefaultScannoFile(self, s):
self.defaultScannoFile = s
valid = False
if self.defaultScannoFile and self.ppscannos and os.path.exists(self.ppscannos):
if os.path.exists(os.path.dirname(self.ppscannos) + '/' + self.defaultScannoFile):
valid = True
self.actionRun.setEnabled(valid)
def initializeSettings(self):
"""Load persistent config settings."""
settings = QSettings()
s = settings.value('ppscannos', type=str)
if not s:
# try the default
s = os.path.expanduser('~') + '/ppscannos1/ppscannos1.py'
#s = os.environ['HOME'] + '/ppscannos1/ppscannos1.py'
self.setPPScannos(s)
s = settings.value('defaultScannoFile', type=str)
if (not s) and self.ppscannos:
# try the default
lst = getRCFilesForDir(os.path.dirname(self.ppscannos))
if len(lst):
# prefer 'regex.rc'; otherwise use the first one
s = lst[0]
for f in lst:
if f == 'regex.rc':
s = f
break
self.setDefaultScannoFile(s)
def __init__(self, ebook, orig, is_scrambled, fmap, parent=None):
QDialog.__init__(self, parent=parent)
self.setWindowFlags(Qt.Window)
self.orig = orig
self.ebook = ebook
self.revfmap = {v: k for (k, v) in iteritems(fmap)}
# create widgets
lay = QVBoxLayout()
self.setLayout(lay)
buttonBox = QDialogButtonBox(QDialogButtonBox.Close)
self.webview_orig = Webview()
self.webview_scram = Webview()
settings = self.webview_orig.settings()
if hasattr(settings, 'setUserStyleSheetUrl'):
# QWebView from QtWebKit
style = 'body {%s}' % CSSBG
cssurl = 'data:text/css;charset=utf-8;base64,'
cssurl += as_base64_unicode(style)
self.webview_orig.settings().setUserStyleSheetUrl(QUrl(cssurl))
self.webview_scram.settings().setUserStyleSheetUrl(QUrl(cssurl))
elif hasattr(self.webview_orig, 'setStyleSheet'):
# QWebEngineView from QtWebEngine
# setStyleSheet doesn't seem to work at the moment
self.webview_orig.setStyleSheet('Webview {%s}' % CSSBG)
self.webview_scram.setStyleSheet('Webview {%s}' % CSSBG)
dummytext = '<body><p>*** Text content could not be displayed ...</p></body>'
self.webview_orig.setHtml(dummytext)
self.webview_scram.setHtml(dummytext)
self.htmlList_orig = QListWidget()
self.htmlList_scram = QListWidget()
self.htmlList_orig.setMinimumWidth(300)
self.htmlList_scram.setMinimumWidth(300)
gpbox1 = QGroupBox()
lay1 = QHBoxLayout()
gpbox1.setLayout(lay1)
lay1.addWidget(self.htmlList_orig)
gpbox3 = QGroupBox()
lay3 = QHBoxLayout()
gpbox3.setLayout(lay3)
lay3.addWidget(self.htmlList_scram)
gpbox2 = QGroupBox('Original text content:')
lay2 = QHBoxLayout()
gpbox2.setLayout(lay2)
lay2.addWidget(self.webview_orig)
gpbox4 = QGroupBox('Original text content:')
lay4 = QHBoxLayout()
gpbox4.setLayout(lay4)
lay4.addWidget(self.webview_scram)
splitter = QSplitter(Qt.Horizontal)
splitter.addWidget(gpbox1)
splitter.addWidget(gpbox2)
splitter.addWidget(gpbox3)
splitter.addWidget(gpbox4)
lay.addWidget(splitter)
lay.addWidget(buttonBox)
# create connect signals/slots
buttonBox.rejected.connect(self.reject)
self.htmlList_scram.currentRowChanged.connect(
self.htmlList_currentRowChanged)
self.htmlList_scram.itemDoubleClicked.connect(
self.htmlList_itemDoubleClicked)
self.htmlList_orig.setEnabled(False)
self.htmlnames_scram = get_textnames(self.ebook)
self.htmlnames_orig = tuple(
[self.revfmap.get(an, an) for an in self.htmlnames_scram])
gpbox1.setTitle('Original HTML files: %s' % len(self.htmlnames_orig))
gpbox3.setTitle('Original HTML files: %s' % len(self.htmlnames_scram))
self.htmlList_orig.clear()
self.htmlList_orig.addItems(self.htmlnames_orig)
self.htmlList_scram.clear()
self.htmlList_scram.addItems(self.htmlnames_scram)
if not self.revfmap:
gpbox1.setVisible(False)
msg = '%s Preview: Original' % CAPTION
if not is_scrambled:
self.setWindowTitle(msg)
gpbox1.setVisible(False)
gpbox2.setVisible(False)
else:
self.setWindowTitle(msg + ' vs. Scrambled')
gpbox3.setTitle('Scrambled HTML files: %s' %
len(self.htmlnames_scram))
gpbox4.setTitle('Scrambled text content:')
self.htmlList_scram.setCurrentRow(0)
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 ConfigWidget(QWidget, Logger):
# Manually managed controls when saving/restoring
EXCLUDED_CONTROLS = [
'cfg_annotations_destination_comboBox'
]
#LOCATION_TEMPLATE = "{cls}:{func}({arg1}) {arg2}"
WIZARD_PROFILES = {
'Annotations': {
'label': 'mm_annotations',
'datatype': 'comments',
'display': {},
'is_multiple': False
}
}
def __init__(self, plugin_action):
self.gui = plugin_action.gui
self.opts = plugin_action.opts
QWidget.__init__(self)
self.l = QVBoxLayout()
self.setLayout(self.l)
# ~~~~~~~~ Create the runtime options group box ~~~~~~~~
self.cfg_runtime_options_gb = QGroupBox(self)
self.cfg_runtime_options_gb.setTitle(_('Runtime options'))
self.l.addWidget(self.cfg_runtime_options_gb)
self.cfg_runtime_options_qvl = QVBoxLayout(self.cfg_runtime_options_gb)
# ~~~~~~~~ Disable caching checkbox ~~~~~~~~
self.cfg_disable_caching_checkbox = QCheckBox(_('Disable caching'))
self.cfg_disable_caching_checkbox.setObjectName('cfg_disable_caching_checkbox')
self.cfg_disable_caching_checkbox.setToolTip(_('Force reload of reader database'))
self.cfg_disable_caching_checkbox.setChecked(False)
self.cfg_runtime_options_qvl.addWidget(self.cfg_disable_caching_checkbox)
# ~~~~~~~~ plugin logging checkbox ~~~~~~~~
self.cfg_plugin_debug_log_checkbox = QCheckBox(_('Enable debug logging for Annotations plugin'))
self.cfg_plugin_debug_log_checkbox.setObjectName('cfg_plugin_debug_log_checkbox')
self.cfg_plugin_debug_log_checkbox.setToolTip(_('Print plugin diagnostic messages to console'))
self.cfg_plugin_debug_log_checkbox.setChecked(False)
self.cfg_runtime_options_qvl.addWidget(self.cfg_plugin_debug_log_checkbox)
# ~~~~~~~~ libiMobileDevice logging checkbox ~~~~~~~~
self.cfg_libimobiledevice_debug_log_checkbox = QCheckBox(_('Enable debug logging for libiMobileDevice'))
self.cfg_libimobiledevice_debug_log_checkbox.setObjectName('cfg_libimobiledevice_debug_log_checkbox')
self.cfg_libimobiledevice_debug_log_checkbox.setToolTip(_('Print libiMobileDevice debug messages to console'))
self.cfg_libimobiledevice_debug_log_checkbox.setChecked(False)
self.cfg_libimobiledevice_debug_log_checkbox.setEnabled(LIBIMOBILEDEVICE_AVAILABLE)
self.cfg_runtime_options_qvl.addWidget(self.cfg_libimobiledevice_debug_log_checkbox)
# ~~~~~~~~ Create the Annotations options group box ~~~~~~~~
self.cfg_annotation_options_gb = QGroupBox(self)
self.cfg_annotation_options_gb.setTitle(_('Annotation options'))
self.l.addWidget(self.cfg_annotation_options_gb)
self.cfg_annotation_options_qgl = QGridLayout(self.cfg_annotation_options_gb)
current_row = 0
# Add the label/combobox for annotations destination
self.cfg_annotations_destination_label = QLabel(_('<b>Add fetched annotations to<b>'))
self.cfg_annotations_destination_label.setAlignment(Qt.AlignLeft)
self.cfg_annotation_options_qgl.addWidget(self.cfg_annotations_destination_label, current_row, 0)
current_row += 1
self.cfg_annotations_destination_comboBox = QComboBox(self.cfg_annotation_options_gb)
self.cfg_annotations_destination_comboBox.setObjectName('cfg_annotations_destination_comboBox')
self.cfg_annotations_destination_comboBox.setToolTip(_('Custom field to store annotations'))
self.cfg_annotation_options_qgl.addWidget(self.cfg_annotations_destination_comboBox, current_row, 0)
# Populate annotations_field combobox
db = self.gui.current_db
all_custom_fields = db.custom_field_keys()
self.custom_fields = {}
for custom_field in all_custom_fields:
field_md = db.metadata_for_field(custom_field)
if field_md['datatype'] in ['comments']:
self.custom_fields[field_md['name']] = {'field': custom_field,
'datatype': field_md['datatype']}
all_fields = self.custom_fields.keys() + ['Comments']
for cf in sorted(all_fields):
self.cfg_annotations_destination_comboBox.addItem(cf)
# Add CC Wizard
self.cfg_annotations_wizard = QToolButton()
self.cfg_annotations_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_annotations_wizard.setToolTip(_("Create a custom column to store annotations"))
self.cfg_annotations_wizard.clicked.connect(partial(self.launch_cc_wizard, 'Annotations'))
self.cfg_annotation_options_qgl.addWidget(self.cfg_annotations_wizard, current_row, 2)
current_row += 1
# ~~~~~~~~ Add a horizontal line ~~~~~~~~
self.cfg_appearance_hl = QFrame(self)
self.cfg_appearance_hl.setGeometry(QRect(0, 0, 1, 3))
self.cfg_appearance_hl.setFrameShape(QFrame.HLine)
self.cfg_appearance_hl.setFrameShadow(QFrame.Raised)
self.cfg_annotation_options_qgl.addWidget(self.cfg_appearance_hl, current_row, 0)
current_row += 1
# ~~~~~~~~ Add the Modify… button ~~~~~~~~
self.cfg_annotations_appearance_pushbutton = QPushButton(_("Modify appearance…"))
self.cfg_annotations_appearance_pushbutton.clicked.connect(self.configure_appearance)
self.cfg_annotation_options_qgl.addWidget(self.cfg_annotations_appearance_pushbutton, current_row, 0)
current_row += 1
self.spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
self.cfg_annotation_options_qgl.addItem(self.spacerItem, current_row, 0, 1, 1)
# ~~~~~~~~ Compilations group box ~~~~~~~~
self.cfg_compilation_options_gb = QGroupBox(self)
self.cfg_compilation_options_gb.setTitle(_('Compilations'))
self.l.addWidget(self.cfg_compilation_options_gb)
self.cfg_compilation_options_qgl = QGridLayout(self.cfg_compilation_options_gb)
current_row = 0
# News clippings
self.cfg_news_clippings_checkbox = QCheckBox(_('Collect News clippings'))
self.cfg_news_clippings_checkbox.setObjectName('cfg_news_clippings_checkbox')
self.cfg_compilation_options_qgl.addWidget(self.cfg_news_clippings_checkbox,
current_row, 0)
self.cfg_news_clippings_lineEdit = QLineEdit()
self.cfg_news_clippings_lineEdit.setObjectName('cfg_news_clippings_lineEdit')
self.cfg_news_clippings_lineEdit.setToolTip(_('Title for collected news clippings'))
self.cfg_compilation_options_qgl.addWidget(self.cfg_news_clippings_lineEdit,
current_row, 1)
# ~~~~~~~~ End of construction zone ~~~~~~~~
self.resize(self.sizeHint())
# Restore state of controls, populate annotations combobox
self.controls = inventory_controls(self, dump_controls=False)
restore_state(self)
self.populate_annotations()
# Hook changes to annotations_destination_combobox
# self.connect(self.cfg_annotations_destination_comboBox,
# pyqtSignal('currentIndexChanged(const QString &)'),
# self.annotations_destination_changed)
self.cfg_annotations_destination_comboBox.currentIndexChanged.connect(self.annotations_destination_changed)
# Hook changes to diagnostic checkboxes
self.cfg_disable_caching_checkbox.stateChanged.connect(self.restart_required)
self.cfg_libimobiledevice_debug_log_checkbox.stateChanged.connect(self.restart_required)
self.cfg_plugin_debug_log_checkbox.stateChanged.connect(self.restart_required)
# Hook changes to News clippings, initialize
self.cfg_news_clippings_checkbox.stateChanged.connect(self.news_clippings_toggled)
self.news_clippings_toggled(self.cfg_news_clippings_checkbox.checkState())
self.cfg_news_clippings_lineEdit.editingFinished.connect(self.news_clippings_destination_changed)
# Launch the annotated_books_scanner
field = get_cc_mapping('annotations', 'field', 'Comments')
self.annotated_books_scanner = InventoryAnnotatedBooks(self.gui, field)
self.annotated_books_scanner.signal.connect(self.inventory_complete)
# 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(repr(qs_new_destination_name))
self._log("self.custom_fields: %s" % self.custom_fields)
old_destination_field = get_cc_mapping('annotations', 'field', None)
if old_destination_field and not (old_destination_field in self.gui.current_db.custom_field_keys() or old_destination_field == 'Comments'):
return
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)
# Catch initial change from None to Comments - first run only
if old_destination_field is None:
return
# new_destination_name = unicode(qs_new_destination_name)
new_destination_name = unicode(self.cfg_annotations_destination_comboBox.currentText())
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 = None
if new_destination_name == 'Comments':
new_destination_field = 'Comments'
else:
new_destination_field = self.custom_fields[new_destination_name]['field']
if existing_annotations(self.opts.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.cfg_annotations_destination_comboBox.blockSignals(True)
old_index = self.cfg_annotations_destination_comboBox.findText(old_destination_name)
self.cfg_annotations_destination_comboBox.setCurrentIndex(old_index)
self.cfg_annotations_destination_comboBox.blockSignals(False)
"""
# Warn user that change will move existing annotations to new field
title = 'Move annotations?'
msg = ("<p>Existing annotations will be moved from <b>%s</b> to <b>%s</b>.</p>" %
(old_destination_name, new_destination_name) +
"<p>New annotations will be added to <b>%s</b>.</p>" %
new_destination_name +
"<p>Proceed?</p>")
d = MessageBox(MessageBox.QUESTION,
title, msg,
show_copy_button=False)
self._log_location("QUESTION: %s" % msg)
if d.exec_():
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)
else:
self.cfg_annotations_destination_comboBox.blockSignals(True)
old_index = self.cfg_annotations_destination_comboBox.findText(old_destination_name)
self.cfg_annotations_destination_comboBox.setCurrentIndex(old_index)
self.cfg_annotations_destination_comboBox.blockSignals(False)
"""
else:
# No existing annotations, just update prefs
set_cc_mapping('annotations', field=new_destination_field, combobox=new_destination_name)
def configure_appearance(self):
'''
'''
from calibre_plugins.annotations.appearance import default_elements
from calibre_plugins.annotations.appearance import default_timestamp
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 appearance dialog
aa = AnnotationsAppearance(self, get_icon('images/annotations.png'), 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, offer to re-render
field = get_cc_mapping('annotations', 'field', None)
if osh.digest() != nsh.digest() and existing_annotations(self.opts.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")
if self.annotated_books_scanner.isRunning():
self.annotated_books_scanner.wait()
move_annotations(self, self.annotated_books_scanner.annotation_map,
field, field, window_title=_("Updating appearance"))
def inventory_complete(self, msg):
self._log_location(msg)
def launch_cc_wizard(self, column_type):
'''
'''
def _update_combo_box(comboBox, destination, previous):
'''
'''
self._log_location()
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)
# Process the changed destination
self.annotations_destination_changed(destination)
cb.blockSignals(False)
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)
destination = dlg.modified_column['destination']
label = dlg.modified_column['label']
previous = dlg.modified_column['previous']
source = dlg.modified_column['source']
self._log("destination: %s" % destination)
self._log("label: %s" % label)
self._log("previous: %s" % previous)
self._log("source: %s" % source)
if source == "Annotations":
# Add/update the new destination so save_settings() can find it
if destination in self.custom_fields:
self.custom_fields[destination]['field'] = label
else:
self.custom_fields[destination] = {'field': label}
_update_combo_box('cfg_annotations_destination_comboBox', destination, previous)
# Save field manually in case user cancels
#self.prefs.set('cfg_annotations_destination_comboBox', destination)
#self.prefs.set('cfg_annotations_destination_field', label)
set_cc_mapping('annotations', field=label, combobox=destination)
# Inform user to restart
self.restart_required('custom_column')
else:
self._log("ERROR: Can't import from '%s'" % klass)
def launch_new_destination_dialog(self, old, new):
'''
Return 'move', 'change' or 'cancel'
'''
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 news_clippings_destination_changed(self):
qs_new_destination_name = self.cfg_news_clippings_lineEdit.text()
if not re.match(r'^\S+[A-Za-z0-9 ]+$', qs_new_destination_name):
# Complain about News clippings title
title = _('Invalid title for News clippings')
msg = _("Supply a valid title for News clippings, for example 'My News Clippings'.")
d = MessageBox(MessageBox.WARNING,
title, msg,
show_copy_button=False)
self._log_location("WARNING: %s" % msg)
d.exec_()
def news_clippings_toggled(self, state):
if state == Qt.Checked:
self.cfg_news_clippings_lineEdit.setEnabled(True)
else:
self.cfg_news_clippings_lineEdit.setEnabled(False)
def populate_annotations(self):
'''
Restore annotations combobox
'''
self._log_location()
target = 'Comments'
existing = get_cc_mapping('annotations', 'combobox')
if existing:
target = existing
ci = self.cfg_annotations_destination_comboBox.findText(target)
self.cfg_annotations_destination_comboBox.setCurrentIndex(ci)
def restart_required(self, state):
title = _('Restart required')
msg = _('To apply changes, restart calibre.')
d = MessageBox(MessageBox.WARNING,
title, msg,
show_copy_button=False)
self._log_location("WARNING: %s" % (msg))
d.exec_()
def save_settings(self):
save_state(self)
# Save the annotation destination field
ann_dest = unicode(self.cfg_annotations_destination_comboBox.currentText())
self._log_location("INFO: ann_dest=%s" % (ann_dest))
self._log_location("INFO: self.custom_fields=%s" % (self.custom_fields))
if ann_dest == 'Comments':
set_cc_mapping('annotations', field='Comments', combobox='Comments')
elif ann_dest:
set_cc_mapping('annotations', field=self.custom_fields[ann_dest]['field'], combobox=ann_dest)
def start_inventory(self):
self.annotated_books_scanner.start()
class Ui_ConfigureRPCserverDlg(object):
def setupUi(self, ConfigureRPCserverDlg):
ConfigureRPCserverDlg.setModal(True)
## -- Layout
self.layout = QGroupBox(ConfigureRPCserverDlg)
self.layout.setTitle("Local Pivx-Cli wallet Configuration")
self.layout.setContentsMargins(80, 30, 10, 10)
form = QFormLayout(ConfigureRPCserverDlg)
form.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
## -- ROW 1
line1 = QHBoxLayout()
self.edt_rpcIp = QLineEdit()
self.edt_rpcIp.setToolTip(
"rpc server (local wallet) IP address\n-- example [IPv4] 88.172.23.1\n-- example [IPv6] 2001:db8:85a3::8a2e:370:7334"
)
self.edt_rpcIp.setText(ConfigureRPCserverDlg.rpc_ip)
line1.addWidget(self.edt_rpcIp)
line1.addWidget(QLabel("IP Port"))
self.edt_rpcPort = QSpinBox()
self.edt_rpcPort.setRange(1, 65535)
self.edt_rpcPort.setValue(ConfigureRPCserverDlg.rpc_port)
self.edt_rpcPort.setFixedWidth(180)
line1.addWidget(self.edt_rpcPort)
form.addRow(QLabel("IP Address"), line1)
## -- ROW 2
self.edt_rpcUser = QLineEdit()
self.edt_rpcUser.setText(ConfigureRPCserverDlg.rpc_user)
form.addRow(QLabel("RPC Username"), self.edt_rpcUser)
## -- ROW 3
self.edt_rpcPassword = QLineEdit()
self.edt_rpcPassword.setText(ConfigureRPCserverDlg.rpc_password)
form.addRow(QLabel("RPC Password"), self.edt_rpcPassword)
## -- ROW 4
hBox = QHBoxLayout()
self.buttonCancel = QPushButton("Cancel")
self.buttonCancel.clicked.connect(
lambda: self.onButtonCancel(ConfigureRPCserverDlg))
hBox.addWidget(self.buttonCancel)
self.buttonSave = QPushButton("Save")
self.buttonSave.clicked.connect(
lambda: self.onButtonSave(ConfigureRPCserverDlg))
hBox.addWidget(self.buttonSave)
form.addRow(hBox)
## Set Layout
self.layout.setLayout(form)
ConfigureRPCserverDlg.setFixedSize(self.layout.sizeHint())
@pyqtSlot()
def onButtonSave(self, main_dlg):
main_dlg.rpc_ip = ip_address(self.edt_rpcIp.text().strip()).compressed
main_dlg.rpc_port = int(self.edt_rpcPort.value())
main_dlg.rpc_user = self.edt_rpcUser.text()
main_dlg.rpc_password = self.edt_rpcPassword.text()
conf = {}
conf["rpc_ip"] = main_dlg.rpc_ip
conf["rpc_port"] = main_dlg.rpc_port
conf["rpc_user"] = main_dlg.rpc_user
conf["rpc_password"] = main_dlg.rpc_password
# Update File
writeToFile(conf, rpc_File)
# Update current RPC Server
main_dlg.main_wnd.mainWindow.rpcClient = None
main_dlg.main_wnd.mainWindow.rpcConnected = False
printDbg("Trying to connect to RPC server [%s]:%s" %
(conf["rpc_ip"], str(conf["rpc_port"])))
self.runInThread = ThreadFuns.runInThread(
main_dlg.main_wnd.mainWindow.updateRPCstatus, (),
main_dlg.main_wnd.mainWindow.updateRPCled)
main_dlg.close()
@pyqtSlot()
def onButtonCancel(self, main_wnd):
main_wnd.close()
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.parent = parent
self.prefs = prefs
self.icon = icon
super(AnnotationsAppearance, self).__init__(parent, 'appearance_dialog')
self.setWindowTitle(_('Modify 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(
JSONConfig('plugins/annotations').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(
JSONConfig('plugins/annotations').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.elements_table.preview_css()
def reset_timestamp_to_default(self):
from calibre_plugins.annotations.appearance import default_timestamp
self.timestamp_fmt_le.setText(default_timestamp)
self.timestamp_fmt_changed()
def show_help(self):
'''
Display strftime help file
'''
hv = HelpView(self, self.icon, self.prefs,
html=get_resources('help/timestamp_formats.html'), title=_("Timestamp formats"))
hv.show()
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.elements_table.preview_css()
class FindAnnotationsDialog(SizePersistedDialog, Logger):
GENERIC_STYLE = 'Any style'
GENERIC_READER = 'Any reader'
def __init__(self, opts):
self.matched_ids = set()
self.opts = opts
self.prefs = opts.prefs
super(FindAnnotationsDialog, self).__init__(self.opts.gui, 'find_annotations_dialog')
self.setWindowTitle('Find Annotations')
self.setWindowIcon(self.opts.icon)
self.l = QVBoxLayout(self)
self.setLayout(self.l)
self.search_criteria_gb = QGroupBox(self)
self.search_criteria_gb.setTitle("Search criteria")
self.scgl = QGridLayout(self.search_criteria_gb)
self.l.addWidget(self.search_criteria_gb)
# addWidget(widget, row, col, rowspan, colspan)
row = 0
# ~~~~~~~~ Create the Readers comboBox ~~~~~~~~
self.reader_label = QLabel('Reader')
self.reader_label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.scgl.addWidget(self.reader_label, row, 0, 1, 1)
self.find_annotations_reader_comboBox = QComboBox()
self.find_annotations_reader_comboBox.setObjectName('find_annotations_reader_comboBox')
self.find_annotations_reader_comboBox.setToolTip('Reader annotations to search for')
self.find_annotations_reader_comboBox.addItem(self.GENERIC_READER)
racs = ReaderApp.get_reader_app_classes()
for ra in sorted(racs.keys()):
self.find_annotations_reader_comboBox.addItem(ra)
self.scgl.addWidget(self.find_annotations_reader_comboBox, row, 1, 1, 4)
row += 1
# ~~~~~~~~ Create the Styles comboBox ~~~~~~~~
self.style_label = QLabel('Style')
self.style_label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.scgl.addWidget(self.style_label, row, 0, 1, 1)
self.find_annotations_color_comboBox = QComboBox()
self.find_annotations_color_comboBox.setObjectName('find_annotations_color_comboBox')
self.find_annotations_color_comboBox.setToolTip('Annotation style to search for')
self.find_annotations_color_comboBox.addItem(self.GENERIC_STYLE)
all_colors = COLOR_MAP.keys()
all_colors.remove('Default')
for color in sorted(all_colors):
self.find_annotations_color_comboBox.addItem(color)
self.scgl.addWidget(self.find_annotations_color_comboBox, row, 1, 1, 4)
row += 1
# ~~~~~~~~ Create the Text LineEdit control ~~~~~~~~
self.text_label = QLabel('Text')
self.text_label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.scgl.addWidget(self.text_label, row, 0, 1, 1)
self.find_annotations_text_lineEdit = MyLineEdit()
self.find_annotations_text_lineEdit.setObjectName('find_annotations_text_lineEdit')
self.scgl.addWidget(self.find_annotations_text_lineEdit, row, 1, 1, 3)
self.reset_text_tb = QToolButton()
self.reset_text_tb.setObjectName('reset_text_tb')
self.reset_text_tb.setToolTip('Clear search criteria')
self.reset_text_tb.setIcon(QIcon(I('trash.png')))
self.reset_text_tb.clicked.connect(self.clear_text_field)
self.scgl.addWidget(self.reset_text_tb, row, 4, 1, 1)
row += 1
# ~~~~~~~~ Create the Note LineEdit control ~~~~~~~~
self.note_label = QLabel('Note')
self.note_label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.scgl.addWidget(self.note_label, row, 0, 1, 1)
self.find_annotations_note_lineEdit = MyLineEdit()
self.find_annotations_note_lineEdit.setObjectName('find_annotations_note_lineEdit')
self.scgl.addWidget(self.find_annotations_note_lineEdit, row, 1, 1, 3)
self.reset_note_tb = QToolButton()
self.reset_note_tb.setObjectName('reset_note_tb')
self.reset_note_tb.setToolTip('Clear search criteria')
self.reset_note_tb.setIcon(QIcon(I('trash.png')))
self.reset_note_tb.clicked.connect(self.clear_note_field)
self.scgl.addWidget(self.reset_note_tb, row, 4, 1, 1)
row += 1
# ~~~~~~~~ Create the Date range controls ~~~~~~~~
self.date_range_label = QLabel('Date range')
self.date_range_label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.scgl.addWidget(self.date_range_label, row, 0, 1, 1)
# Date 'From'
self.find_annotations_date_from_dateEdit = MyDateEdit(self, datetime(1970,1,1))
self.find_annotations_date_from_dateEdit.setObjectName('find_annotations_date_from_dateEdit')
#self.find_annotations_date_from_dateEdit.current_val = datetime(1970,1,1)
self.find_annotations_date_from_dateEdit.clear_button.clicked.connect(self.find_annotations_date_from_dateEdit.reset_from_date)
self.scgl.addWidget(self.find_annotations_date_from_dateEdit, row, 1, 1, 1)
self.scgl.addWidget(self.find_annotations_date_from_dateEdit.clear_button, row, 2, 1, 1)
# Date 'To'
self.find_annotations_date_to_dateEdit = MyDateEdit(self, datetime.today())
self.find_annotations_date_to_dateEdit.setObjectName('find_annotations_date_to_dateEdit')
#self.find_annotations_date_to_dateEdit.current_val = datetime.today()
self.find_annotations_date_to_dateEdit.clear_button.clicked.connect(self.find_annotations_date_to_dateEdit.reset_to_date)
self.scgl.addWidget(self.find_annotations_date_to_dateEdit, row, 3, 1, 1)
self.scgl.addWidget(self.find_annotations_date_to_dateEdit.clear_button, row, 4, 1, 1)
row += 1
# ~~~~~~~~ Create a horizontal line ~~~~~~~~
self.hl = QFrame(self)
self.hl.setGeometry(QRect(0, 0, 1, 3))
self.hl.setFrameShape(QFrame.HLine)
self.hl.setFrameShadow(QFrame.Raised)
self.scgl.addWidget(self.hl, row, 0, 1, 5)
row += 1
# ~~~~~~~~ Create the results label field ~~~~~~~~
self.result_label = QLabel('<p style="color:red">scanning…</p>')
self.result_label.setAlignment(Qt.AlignCenter)
self.result_label.setWordWrap(False)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Maximum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.result_label.sizePolicy().hasHeightForWidth())
self.result_label.setSizePolicy(sizePolicy)
self.result_label.setMinimumSize(QtCore.QSize(250, 0))
self.scgl.addWidget(self.result_label, row, 0, 1, 5)
row += 1
# ~~~~~~~~ Create the ButtonBox ~~~~~~~~
self.dialogButtonBox = QDialogButtonBox(self)
self.dialogButtonBox.setOrientation(Qt.Horizontal)
if False:
self.update_button = QPushButton('Update results')
self.update_button.setDefault(True)
self.update_button.setVisible(False)
self.dialogButtonBox.addButton(self.update_button, QDialogButtonBox.ActionRole)
self.cancel_button = self.dialogButtonBox.addButton(self.dialogButtonBox.Cancel)
self.find_button = self.dialogButtonBox.addButton(self.dialogButtonBox.Ok)
self.find_button.setText('Find Matching Books')
self.l.addWidget(self.dialogButtonBox)
self.dialogButtonBox.clicked.connect(self.find_annotations_dialog_clicked)
# ~~~~~~~~ Add a spacer ~~~~~~~~
self.spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
self.l.addItem(self.spacerItem)
# ~~~~~~~~ Restore previously saved settings ~~~~~~~~
self.restore_settings()
# ~~~~~~~~ Declare 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()
# ~~~~~~~~ Connect all signals ~~~~~~~~
self.find_annotations_reader_comboBox.currentIndexChanged.connect(partial(self.update_results, 'reader'))
self.find_annotations_color_comboBox.currentIndexChanged.connect(partial(self.update_results, 'color'))
self.find_annotations_text_lineEdit.editingFinished.connect(partial(self.update_results, 'text'))
self.find_annotations_note_lineEdit.editingFinished.connect(partial(self.update_results, 'note'))
# self.connect(self.find_annotations_text_lineEdit, pyqtSignal("return_pressed"), self.return_pressed)
self.find_annotations_text_lineEdit.return_pressed.connect(self.return_pressed)
# self.connect(self.find_annotations_note_lineEdit, pyqtSignal("return_pressed"), self.return_pressed)
self.find_annotations_note_lineEdit.return_pressed.connect(self.return_pressed)
# Date range signals connected in inventory_available()
# ~~~~~~~~ Allow dialog to render before doing inventory ~~~~~~~~
#field = self.prefs.get('cfg_annotations_destination_field', None)
field = get_cc_mapping('annotations', 'field', None)
self.annotated_books_scanner = InventoryAnnotatedBooks(self.opts.gui, field, get_date_range=True)
self.annotated_books_scanner.signal.connect(self.inventory_available)
QTimer.singleShot(1, self.start_inventory_scan)
def clear_note_field(self):
if str(self.find_annotations_note_lineEdit.text()) > '':
self.find_annotations_note_lineEdit.setText('')
self.update_results('clear_note_field')
def clear_text_field(self):
if str(self.find_annotations_text_lineEdit.text()) > '':
self.find_annotations_text_lineEdit.setText('')
self.update_results('clear_text_field')
def find_annotations_dialog_clicked(self, button):
if self.dialogButtonBox.buttonRole(button) == QDialogButtonBox.AcceptRole:
self.save_settings()
self.accept()
elif self.dialogButtonBox.buttonRole(button) == QDialogButtonBox.RejectRole:
self.close()
def inventory_available(self):
'''
Update the Date range widgets with the rounded oldest, newest dates
Don't connect date signals until date range available
'''
self._log_location()
# Reset the date range based on available annotations
oldest = QDateTime(datetime.fromtimestamp(self.annotated_books_scanner.oldest_annotation))
oldest_day = QDateTime(datetime.fromtimestamp(self.annotated_books_scanner.oldest_annotation).replace(hour=0, minute=0, second=0))
newest = QDateTime(datetime.fromtimestamp(self.annotated_books_scanner.newest_annotation))
newest_day = QDateTime(datetime.fromtimestamp(self.annotated_books_scanner.newest_annotation).replace(hour=23, minute=59, second=59))
# Set 'From' date limits to inventory values
self.find_annotations_date_from_dateEdit.setMinimumDateTime(oldest_day)
self.find_annotations_date_from_dateEdit.current_val = oldest
self.find_annotations_date_from_dateEdit.setMaximumDateTime(newest_day)
# Set 'To' date limits to inventory values
self.find_annotations_date_to_dateEdit.setMinimumDateTime(oldest_day)
self.find_annotations_date_to_dateEdit.current_val = newest_day
self.find_annotations_date_to_dateEdit.setMaximumDateTime(newest_day)
# Connect the signals for date range changes
self.find_annotations_date_from_dateEdit.dateTimeChanged.connect(partial(self.update_results, 'from_date'))
self.find_annotations_date_to_dateEdit.dateTimeChanged.connect(partial(self.update_results, 'to_date'))
self.update_results('inventory_available')
def restore_settings(self):
self.blockSignals(True)
ra = self.prefs.get('find_annotations_reader_comboBox', self.GENERIC_READER)
ra_index = self.find_annotations_reader_comboBox.findText(ra)
self.find_annotations_reader_comboBox.setCurrentIndex(ra_index)
color = self.prefs.get('find_annotations_color_comboBox', self.GENERIC_STYLE)
color_index = self.find_annotations_color_comboBox.findText(color)
self.find_annotations_color_comboBox.setCurrentIndex(color_index)
text = self.prefs.get('find_annotations_text_lineEdit', '')
self.find_annotations_text_lineEdit.setText(text)
note = self.prefs.get('find_annotations_note_lineEdit', '')
self.find_annotations_note_lineEdit.setText(note)
if False:
from_date = self.prefs.get('find_annotations_date_from_dateEdit', datetime(1970,1,1))
self.find_annotations_date_from_dateEdit.current_val = from_date
to_date = self.prefs.get('find_annotations_date_to_dateEdit', datetime.today())
self.find_annotations_date_to_dateEdit.current_val = to_date
self.blockSignals(False)
def return_pressed(self):
self.update_results("return_pressed")
def save_settings(self):
ra = str(self.find_annotations_reader_comboBox.currentText())
self.prefs.set('find_annotations_reader_comboBox', ra)
color = str(self.find_annotations_color_comboBox.currentText())
self.prefs.set('find_annotations_color_comboBox', color)
text = str(self.find_annotations_text_lineEdit.text())
self.prefs.set('find_annotations_text_lineEdit', text)
note = str(self.find_annotations_note_lineEdit.text())
self.prefs.set('find_annotations_note_lineEdit', note)
if False:
from_date = self.find_annotations_date_from_dateEdit.current_val
self.prefs.set('find_annotations_date_from_dateEdit', from_date)
to_date = self.find_annotations_date_to_dateEdit.current_val
self.prefs.set('find_annotations_date_to_dateEdit', to_date)
def start_inventory_scan(self):
self._log_location()
self.annotated_books_scanner.start()
def update_results(self, trigger):
#self._log_location(trigger)
reader_to_match = str(self.find_annotations_reader_comboBox.currentText())
color_to_match = str(self.find_annotations_color_comboBox.currentText())
text_to_match = str(self.find_annotations_text_lineEdit.text())
note_to_match = str(self.find_annotations_note_lineEdit.text())
from_date = self.find_annotations_date_from_dateEdit.dateTime().toTime_t()
to_date = self.find_annotations_date_to_dateEdit.dateTime().toTime_t()
annotation_map = self.annotated_books_scanner.annotation_map
#field = self.prefs.get("cfg_annotations_destination_field", None)
field = get_cc_mapping('annotations', 'field', None)
db = self.opts.gui.current_db
matched_titles = []
self.matched_ids = set()
for cid in annotation_map:
mi = db.get_metadata(cid, index_is_id=True)
soup = None
if field == 'Comments':
if mi.comments:
soup = BeautifulSoup(mi.comments)
else:
if mi.get_user_metadata(field, False)['#value#'] is not None:
soup = BeautifulSoup(mi.get_user_metadata(field, False)['#value#'])
if soup:
uas = soup.findAll('div', 'annotation')
for ua in uas:
# Are we already logged?
if cid in self.matched_ids:
continue
# Check reader
if reader_to_match != self.GENERIC_READER:
this_reader = ua['reader']
if this_reader != reader_to_match:
continue
# Check color
if color_to_match != self.GENERIC_STYLE:
this_color = ua.find('table')['color']
if this_color != color_to_match:
continue
# Check date range, allow for mangled timestamp
try:
timestamp = float(ua.find('td', 'timestamp')['uts'])
if timestamp < from_date or timestamp > to_date:
continue
except:
continue
highlight_text = ''
try:
pels = ua.findAll('p', 'highlight')
for pel in pels:
highlight_text += pel.string + '\n'
except:
pass
if text_to_match > '':
if not re.search(text_to_match, highlight_text, flags=re.IGNORECASE):
continue
note_text = ''
try:
nels = ua.findAll('p', 'note')
for nel in nels:
note_text += nel.string + '\n'
except:
pass
if note_to_match > '':
if not re.search(note_to_match, note_text, flags=re.IGNORECASE):
continue
# If we made it this far, add the id to matched_ids
self.matched_ids.add(cid)
matched_titles.append(mi.title)
# Update the results box
matched_titles.sort()
if len(annotation_map):
if len(matched_titles):
first_match = ("<i>%s</i>" % matched_titles[0])
if len(matched_titles) == 1:
results = first_match
else:
results = first_match + (" and %d more." % (len(matched_titles) - 1))
self.result_label.setText('<p style="color:blue">{0}</p>'.format(results))
else:
self.result_label.setText('<p style="color:red">no matches</p>')
else:
self.result_label.setText('<p style="color:red">no annotated books in library</p>')
self.resize_dialog()
class ComicalibreDialog(QDialog):
""" The main dialog for users to enter options before starting. """
def __init__(self, gui, icon, do_user_config):
""" Initialize the gui dialog. """
QDialog.__init__(self, gui)
self.gui = gui
self.icon = icon
self.do_user_config = do_user_config
self.db = gui.current_db
self.create_gui()
def start_process(self, process_type):
""" Starts the processing worker and progress bar. """
prefs["comic_vine_api_key"] = self.api_msg.text()
prefs["tags_to_add"] = self.tags_msg.text()
self.worker = ComicalibreWork(self.gui)
self.result_text.setText("Processing...")
self.title_start.setEnabled(False)
self.series_start.setEnabled(False)
self.ids_start.setEnabled(False)
keep_tags = self.keep_tags_cb.isChecked()
errors = self.worker.process(self.progress_bar, process_type,
keep_tags)
self.title_start.setEnabled(True)
self.series_start.setEnabled(True)
self.ids_start.setEnabled(True)
results = "Finished!" + os.linesep
for error in errors:
results = results + error + os.linesep
self.result_text.setText(results)
def title_process(self):
self.start_process(0)
def series_process(self):
self.start_process(1)
def ids_process(self):
self.start_process(2)
def create_gui(self):
""" Layout arrangement for the dialog and its input widgets. """
self.layout = QVBoxLayout()
self.layout.setSpacing(20)
self.setLayout(self.layout)
# Create an editable box for user to input Comic Vine API Key.
self.api_layout = QHBoxLayout()
self.api_msg = QLineEdit(self)
self.api_msg.setFixedWidth(350)
self.api_msg.setText(prefs["comic_vine_api_key"])
self.api_label = QLabel("Comic Vine API Key")
self.api_label.setBuddy(self.api_msg)
self.api_layout.addWidget(self.api_label)
self.api_layout.addWidget(self.api_msg)
# Create an editable box for user to input Tags to add to all books.
self.tags_layout = QHBoxLayout()
self.tags_msg = QLineEdit(self)
self.tags_msg.setText(prefs["tags_to_add"])
self.tags_label = QLabel("Tags To Add")
self.tags_label.setBuddy(self.tags_msg)
self.tags_layout.addWidget(self.tags_label)
self.tags_layout.addWidget(self.tags_msg)
# Add the fields to the main layout.
self.layout.addLayout(self.api_layout)
self.layout.addLayout(self.tags_layout)
# Option to keep current tags.
self.keep_tags_cb = QCheckBox("Keep existing tags while adding new.",
self)
self.layout.addWidget(self.keep_tags_cb)
# Separate the buttons from the input.
self.btn_sep = QFrame()
self.btn_sep.setFrameShape(QFrame.HLine)
self.btn_sep.setFrameShadow(QFrame.Sunken)
self.layout.addWidget(self.btn_sep)
# Create a start button to kick off the processing with title.
self.title_start = QPushButton("Using Title - Hover For Details", self)
self.title_start.setToolTip(
"This expects the title of a book to have a "
"specific formatted string containing volume "
"ID and issue#. e.g." + os.linesep + "Desired "
"Title --- v1234 n0124" + os.linesep + "Where "
"--- is required and the number after v "
"matches Comic Vine's volume ID. The number "
"after n is the issue number.")
self.title_start.clicked.connect(self.title_process)
self.layout.addWidget(self.title_start)
# Create a start button to kick off the processing with series.
self.series_start = QPushButton("Using Series - Hover For Details",
self)
self.series_start.setToolTip(
"This expects the series name to match the "
"Comic Vine volume ID and the series number "
"equals issue number.")
self.series_start.clicked.connect(self.series_process)
self.layout.addWidget(self.series_start)
# Create a start button to kick off the processing with CV IDs.
self.ids_start = QPushButton("Using IDs - Hover For Details", self)
self.ids_start.setToolTip(
"This expects two custom columns with lookup "
"comicvineissueid and comicvinevolumeid. "
"These must match Comic Vine's IDs for the "
"issue and the volume.")
self.ids_start.clicked.connect(self.ids_process)
self.layout.addWidget(self.ids_start)
# Separate the progress and results.
self.result_sep = QFrame()
self.result_sep.setFrameShape(QFrame.HLine)
self.result_sep.setFrameShadow(QFrame.Sunken)
self.layout.addWidget(self.result_sep)
# Create progress bar.
self.progress_bar = QProgressBar()
self.progress_bar.setRange(0, 100)
self.progress_bar.setMinimumWidth(485)
self.layout.addWidget(self.progress_bar)
# Create results text area.
self.result_box = QGroupBox()
self.result_box.setTitle("Results")
self.result_text = QLabel("Run Comicalibre to see results.")
self.result_scroll = QScrollArea()
self.result_scroll.setWidget(self.result_text)
self.result_scroll.setWidgetResizable(True)
self.result_layout = QVBoxLayout()
self.result_layout.addWidget(self.result_scroll)
self.result_box.setLayout(self.result_layout)
self.layout.addWidget(self.result_box)
self.setWindowTitle("Comicalibre")
self.setWindowIcon(self.icon)
self.resize(self.sizeHint())
def request_octo_init_settings(self, wizard, method):
vbox = QVBoxLayout()
next_enabled = True
label = QLabel(_("Enter a label to name your device:"))
name = QLineEdit()
hl = QHBoxLayout()
hl.addWidget(label)
hl.addWidget(name)
hl.addStretch(1)
vbox.addLayout(hl)
def clean_text(widget):
text = widget.toPlainText().strip()
return ' '.join(text.split())
if method in [TIM_NEW, TIM_RECOVER]:
gb = QGroupBox()
hbox1 = QHBoxLayout()
gb.setLayout(hbox1)
vbox.addWidget(gb)
gb.setTitle(_("Select your seed length:"))
bg_numwords = QButtonGroup()
for i, count in enumerate([12, 18, 24]):
rb = QRadioButton(gb)
rb.setText(_("%d words") % count)
bg_numwords.addButton(rb)
bg_numwords.setId(rb, i)
hbox1.addWidget(rb)
rb.setChecked(True)
cb_pin = QCheckBox(_('Enable PIN protection'))
cb_pin.setChecked(True)
else:
text = QTextEdit()
text.setMaximumHeight(60)
if method == TIM_MNEMONIC:
msg = _("Enter your BIP39 mnemonic:")
else:
msg = _("Enter the master private key beginning with xprv:")
def set_enabled():
from electrum.keystore import is_xprv
wizard.next_button.setEnabled(is_xprv(clean_text(text)))
text.textChanged.connect(set_enabled)
next_enabled = False
vbox.addWidget(QLabel(msg))
vbox.addWidget(text)
pin = QLineEdit()
pin.setValidator(QRegExpValidator(QRegExp('[1-9]{0,9}')))
pin.setMaximumWidth(100)
hbox_pin = QHBoxLayout()
hbox_pin.addWidget(QLabel(_("Enter your PIN (digits 1-9):")))
hbox_pin.addWidget(pin)
hbox_pin.addStretch(1)
if method in [TIM_NEW, TIM_RECOVER]:
vbox.addWidget(WWLabel(RECOMMEND_PIN))
vbox.addWidget(cb_pin)
else:
vbox.addLayout(hbox_pin)
passphrase_msg = WWLabel(PASSPHRASE_HELP_SHORT)
passphrase_warning = WWLabel(PASSPHRASE_NOT_PIN)
passphrase_warning.setStyleSheet("color: red")
cb_phrase = QCheckBox(_('Enable passphrases'))
cb_phrase.setChecked(False)
vbox.addWidget(passphrase_msg)
vbox.addWidget(passphrase_warning)
vbox.addWidget(cb_phrase)
# ask for recovery type (random word order OR matrix)
if method == TIM_RECOVER:
gb_rectype = QGroupBox()
hbox_rectype = QHBoxLayout()
gb_rectype.setLayout(hbox_rectype)
vbox.addWidget(gb_rectype)
gb_rectype.setTitle(_("Select recovery type:"))
bg_rectype = QButtonGroup()
rb1 = QRadioButton(gb_rectype)
rb1.setText(_('Scrambled words'))
bg_rectype.addButton(rb1)
bg_rectype.setId(rb1, RECOVERY_TYPE_SCRAMBLED_WORDS)
hbox_rectype.addWidget(rb1)
rb1.setChecked(True)
rb2 = QRadioButton(gb_rectype)
rb2.setText(_('Matrix'))
bg_rectype.addButton(rb2)
bg_rectype.setId(rb2, RECOVERY_TYPE_MATRIX)
hbox_rectype.addWidget(rb2)
else:
bg_rectype = None
wizard.exec_layout(vbox, next_enabled=next_enabled)
if method in [TIM_NEW, TIM_RECOVER]:
item = bg_numwords.checkedId()
pin = cb_pin.isChecked()
recovery_type = bg_rectype.checkedId() if bg_rectype else None
else:
item = ' '.join(str(clean_text(text)).split())
pin = str(pin.text())
recovery_type = None
return (item, name.text(), pin, cb_phrase.isChecked(), recovery_type)
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.cfg_annotations_label.clicked.connect(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.cfg_css_editor_label.clicked.connect(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)
self.annotations_field_comboBox.currentIndexChanged.connect(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.annotated_books_scanner.signal.connect(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)
# Signnls available have changed. Now receivin an indec rather than a name. Can get the name
# from the combobox
new_destination_name = unicode(self.annotations_field_comboBox.currentText())
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 init_ui(self):
main_widget_vbox_layout = QVBoxLayout()
# File buttons
file_box = QGroupBox()
file_box.setTitle("File...")
file_box_layout = QVBoxLayout()
self.openFileBtn = QPushButton("Open file")
self.saveFileBtn = QPushButton("Save file")
self.openFileBtn.setToolTip("Open a GSI-16 file")
self.saveFileBtn.setToolTip("Save as new GSI-16 file")
self.openFileBtn.clicked.connect(self.parent()._choose_gsi_file)
self.saveFileBtn.clicked.connect(self.parent().save_gsi_file)
file_box_layout.addWidget(self.openFileBtn)
file_box_layout.addWidget(self.saveFileBtn)
file_box.setLayout(file_box_layout)
# Tools box
tools_box = QGroupBox()
tools_box.setTitle("Tools")
tools_box_layout = QGridLayout()
label_validate = QLabel("Validate values")
tools_box_layout.addWidget(label_validate, 0, 0)
self.precisionCombo = QComboBox()
self.precisionCombo.addItems(self.precision_list)
self.precisionCombo.setEnabled(False)
self.precisionCombo.activated[str].connect(self.set_precision)
self.validate_values_btn = QPushButton("Validate")
self.validate_values_btn.setToolTip(
"Validate format of Measured data GSI words")
self.validate_values_btn.clicked.connect(
functools.partial(self.parent()._validate_gsi_objects, True))
self.validate_values_btn.setEnabled(False)
tools_box_layout.addWidget(self.validate_values_btn, 0, 1)
label = QLabel("Change Precision")
tools_box_layout.addWidget(label, 1, 0)
tools_box_layout.addWidget(self.precisionCombo, 1, 1)
tools_box.setLayout(tools_box_layout)
control_box_hbox_layout = QHBoxLayout()
control_box_hbox_layout.addWidget(file_box)
control_box_hbox_layout.addSpacing(40)
control_box_hbox_layout.addWidget(tools_box)
control_box_hbox_layout.addStretch(1)
main_widget_vbox_layout.addLayout(control_box_hbox_layout)
# Table widget
self.tableWidget = GsiTableWidget(self)
# self.tableWidget.setRowCount(30)
self.tableWidget.setColumnCount(8)
# Header stylesheet
stylesheet = "QHeaderView::section{Background-color:rgb(196,214,255); gridline-color: rgb(214, 214, 214)}"
self.tableWidget.setStyleSheet(stylesheet)
self.tableWidget.setHorizontalHeaderLabels([
"Pointnumber", "Y-coordinate", "X-coordinate", "Elevation", "Code",
"Attribute 1", "Attribute 2", "Attribute 3"
])
font = QFont()
font.setItalic(True)
font.setPointSize(10)
for idx in range(0, self.tableWidget.columnCount()):
self.tableWidget.horizontalHeaderItem(idx).setFont(font)
self.tableWidget.setColumnWidth(idx, 145)
main_widget_vbox_layout.addWidget(self.tableWidget)
self.setLayout(main_widget_vbox_layout)
self.setGeometry(0, 0, 1240, 600)
pal = self.palette()
pal.setColor(self.backgroundRole(), QColor(255, 247, 204))
self.setPalette(pal)
self.setAutoFillBackground(True)
self.setWindowTitle('Buttons')
class FindAnnotationsDialog(SizePersistedDialog, Logger):
GENERIC_STYLE = 'Any style'
GENERIC_READER = 'Any reader'
def __init__(self, opts):
self.matched_ids = set()
self.opts = opts
self.prefs = opts.prefs
super(FindAnnotationsDialog, self).__init__(self.opts.gui, 'find_annotations_dialog')
self.setWindowTitle(_('Find Annotations'))
self.setWindowIcon(self.opts.icon)
self.l = QVBoxLayout(self)
self.setLayout(self.l)
self.search_criteria_gb = QGroupBox(self)
self.search_criteria_gb.setTitle(_("Search criteria"))
self.scgl = QGridLayout(self.search_criteria_gb)
self.l.addWidget(self.search_criteria_gb)
# addWidget(widget, row, col, rowspan, colspan)
row = 0
# ~~~~~~~~ Create the Readers comboBox ~~~~~~~~
self.reader_label = QLabel(_('Reader'))
self.reader_label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.scgl.addWidget(self.reader_label, row, 0, 1, 1)
self.find_annotations_reader_comboBox = QComboBox()
self.find_annotations_reader_comboBox.setObjectName('find_annotations_reader_comboBox')
self.find_annotations_reader_comboBox.setToolTip(_('Reader annotations to search for'))
self.find_annotations_reader_comboBox.addItem(self.GENERIC_READER)
racs = ReaderApp.get_reader_app_classes()
for ra in sorted(racs.keys()):
self.find_annotations_reader_comboBox.addItem(ra)
self.scgl.addWidget(self.find_annotations_reader_comboBox, row, 1, 1, 4)
row += 1
# ~~~~~~~~ Create the Styles comboBox ~~~~~~~~
self.style_label = QLabel(_('Style'))
self.style_label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.scgl.addWidget(self.style_label, row, 0, 1, 1)
self.find_annotations_color_comboBox = QComboBox()
self.find_annotations_color_comboBox.setObjectName('find_annotations_color_comboBox')
self.find_annotations_color_comboBox.setToolTip(_('Annotation style to search for'))
self.find_annotations_color_comboBox.addItem(self.GENERIC_STYLE)
all_colors = COLOR_MAP.keys()
all_colors.remove('Default')
for color in sorted(all_colors):
self.find_annotations_color_comboBox.addItem(color)
self.scgl.addWidget(self.find_annotations_color_comboBox, row, 1, 1, 4)
row += 1
# ~~~~~~~~ Create the Text LineEdit control ~~~~~~~~
self.text_label = QLabel(_('Text'))
self.text_label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.scgl.addWidget(self.text_label, row, 0, 1, 1)
self.find_annotations_text_lineEdit = MyLineEdit()
self.find_annotations_text_lineEdit.setObjectName('find_annotations_text_lineEdit')
self.scgl.addWidget(self.find_annotations_text_lineEdit, row, 1, 1, 3)
self.reset_text_tb = QToolButton()
self.reset_text_tb.setObjectName('reset_text_tb')
self.reset_text_tb.setToolTip(_('Clear search criteria'))
self.reset_text_tb.setIcon(QIcon(I('trash.png')))
self.reset_text_tb.clicked.connect(self.clear_text_field)
self.scgl.addWidget(self.reset_text_tb, row, 4, 1, 1)
row += 1
# ~~~~~~~~ Create the Note LineEdit control ~~~~~~~~
self.note_label = QLabel(_('Note'))
self.note_label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.scgl.addWidget(self.note_label, row, 0, 1, 1)
self.find_annotations_note_lineEdit = MyLineEdit()
self.find_annotations_note_lineEdit.setObjectName('find_annotations_note_lineEdit')
self.scgl.addWidget(self.find_annotations_note_lineEdit, row, 1, 1, 3)
self.reset_note_tb = QToolButton()
self.reset_note_tb.setObjectName('reset_note_tb')
self.reset_note_tb.setToolTip(_('Clear search criteria'))
self.reset_note_tb.setIcon(QIcon(I('trash.png')))
self.reset_note_tb.clicked.connect(self.clear_note_field)
self.scgl.addWidget(self.reset_note_tb, row, 4, 1, 1)
row += 1
# ~~~~~~~~ Create the Date range controls ~~~~~~~~
self.date_range_label = QLabel(_('Date range'))
self.date_range_label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.scgl.addWidget(self.date_range_label, row, 0, 1, 1)
# Date 'From'
self.find_annotations_date_from_dateEdit = MyDateEdit(self, datetime(1970,1,1))
self.find_annotations_date_from_dateEdit.setObjectName('find_annotations_date_from_dateEdit')
#self.find_annotations_date_from_dateEdit.current_val = datetime(1970,1,1)
self.find_annotations_date_from_dateEdit.clear_button.clicked.connect(self.find_annotations_date_from_dateEdit.reset_from_date)
self.scgl.addWidget(self.find_annotations_date_from_dateEdit, row, 1, 1, 1)
self.scgl.addWidget(self.find_annotations_date_from_dateEdit.clear_button, row, 2, 1, 1)
# Date 'To'
self.find_annotations_date_to_dateEdit = MyDateEdit(self, datetime.today())
self.find_annotations_date_to_dateEdit.setObjectName('find_annotations_date_to_dateEdit')
#self.find_annotations_date_to_dateEdit.current_val = datetime.today()
self.find_annotations_date_to_dateEdit.clear_button.clicked.connect(self.find_annotations_date_to_dateEdit.reset_to_date)
self.scgl.addWidget(self.find_annotations_date_to_dateEdit, row, 3, 1, 1)
self.scgl.addWidget(self.find_annotations_date_to_dateEdit.clear_button, row, 4, 1, 1)
row += 1
# ~~~~~~~~ Create a horizontal line ~~~~~~~~
self.hl = QFrame(self)
self.hl.setGeometry(QRect(0, 0, 1, 3))
self.hl.setFrameShape(QFrame.HLine)
self.hl.setFrameShadow(QFrame.Raised)
self.scgl.addWidget(self.hl, row, 0, 1, 5)
row += 1
# ~~~~~~~~ Create the results label field ~~~~~~~~
self.result_label = QLabel('<p style="color:red">{0}</p>'.format(_('scanning…')))
self.result_label.setAlignment(Qt.AlignCenter)
self.result_label.setWordWrap(False)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Maximum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.result_label.sizePolicy().hasHeightForWidth())
self.result_label.setSizePolicy(sizePolicy)
self.result_label.setMinimumSize(QtCore.QSize(250, 0))
self.scgl.addWidget(self.result_label, row, 0, 1, 5)
row += 1
# ~~~~~~~~ Create the ButtonBox ~~~~~~~~
self.dialogButtonBox = QDialogButtonBox(self)
self.dialogButtonBox.setOrientation(Qt.Horizontal)
if False:
self.update_button = QPushButton(_('Update results'))
self.update_button.setDefault(True)
self.update_button.setVisible(False)
self.dialogButtonBox.addButton(self.update_button, QDialogButtonBox.ActionRole)
self.cancel_button = self.dialogButtonBox.addButton(self.dialogButtonBox.Cancel)
self.find_button = self.dialogButtonBox.addButton(self.dialogButtonBox.Ok)
self.find_button.setText(_('Find Matching Books'))
self.l.addWidget(self.dialogButtonBox)
self.dialogButtonBox.clicked.connect(self.find_annotations_dialog_clicked)
# ~~~~~~~~ Add a spacer ~~~~~~~~
self.spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
self.l.addItem(self.spacerItem)
# ~~~~~~~~ Restore previously saved settings ~~~~~~~~
self.restore_settings()
# ~~~~~~~~ Declare 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()
# ~~~~~~~~ Connect all signals ~~~~~~~~
self.find_annotations_reader_comboBox.currentIndexChanged.connect(partial(self.update_results, 'reader'))
self.find_annotations_color_comboBox.currentIndexChanged.connect(partial(self.update_results, 'color'))
self.find_annotations_text_lineEdit.editingFinished.connect(partial(self.update_results, 'text'))
self.find_annotations_note_lineEdit.editingFinished.connect(partial(self.update_results, 'note'))
# self.connect(self.find_annotations_text_lineEdit, pyqtSignal("return_pressed"), self.return_pressed)
self.find_annotations_text_lineEdit.return_pressed.connect(self.return_pressed)
# self.connect(self.find_annotations_note_lineEdit, pyqtSignal("return_pressed"), self.return_pressed)
self.find_annotations_note_lineEdit.return_pressed.connect(self.return_pressed)
# Date range signals connected in inventory_available()
# ~~~~~~~~ Allow dialog to render before doing inventory ~~~~~~~~
#field = self.prefs.get('cfg_annotations_destination_field', None)
field = get_cc_mapping('annotations', 'field', None)
self.annotated_books_scanner = InventoryAnnotatedBooks(self.opts.gui, field, get_date_range=True)
self.annotated_books_scanner.signal.connect(self.inventory_available)
QTimer.singleShot(1, self.start_inventory_scan)
def clear_note_field(self):
if str(self.find_annotations_note_lineEdit.text()) > '':
self.find_annotations_note_lineEdit.setText('')
self.update_results('clear_note_field')
def clear_text_field(self):
if str(self.find_annotations_text_lineEdit.text()) > '':
self.find_annotations_text_lineEdit.setText('')
self.update_results('clear_text_field')
def find_annotations_dialog_clicked(self, button):
if self.dialogButtonBox.buttonRole(button) == QDialogButtonBox.AcceptRole:
self.save_settings()
self.accept()
elif self.dialogButtonBox.buttonRole(button) == QDialogButtonBox.RejectRole:
self.close()
def inventory_available(self):
'''
Update the Date range widgets with the rounded oldest, newest dates
Don't connect date signals until date range available
'''
self._log_location()
# Reset the date range based on available annotations
oldest = QDateTime(datetime.fromtimestamp(self.annotated_books_scanner.oldest_annotation))
oldest_day = QDateTime(datetime.fromtimestamp(self.annotated_books_scanner.oldest_annotation).replace(hour=0, minute=0, second=0))
newest = QDateTime(datetime.fromtimestamp(self.annotated_books_scanner.newest_annotation))
newest_day = QDateTime(datetime.fromtimestamp(self.annotated_books_scanner.newest_annotation).replace(hour=23, minute=59, second=59))
# Set 'From' date limits to inventory values
self.find_annotations_date_from_dateEdit.setMinimumDateTime(oldest_day)
self.find_annotations_date_from_dateEdit.current_val = oldest
self.find_annotations_date_from_dateEdit.setMaximumDateTime(newest_day)
# Set 'To' date limits to inventory values
self.find_annotations_date_to_dateEdit.setMinimumDateTime(oldest_day)
self.find_annotations_date_to_dateEdit.current_val = newest_day
self.find_annotations_date_to_dateEdit.setMaximumDateTime(newest_day)
# Connect the signals for date range changes
self.find_annotations_date_from_dateEdit.dateTimeChanged.connect(partial(self.update_results, 'from_date'))
self.find_annotations_date_to_dateEdit.dateTimeChanged.connect(partial(self.update_results, 'to_date'))
self.update_results('inventory_available')
def restore_settings(self):
self.blockSignals(True)
ra = self.prefs.get('find_annotations_reader_comboBox', self.GENERIC_READER)
ra_index = self.find_annotations_reader_comboBox.findText(ra)
self.find_annotations_reader_comboBox.setCurrentIndex(ra_index)
color = self.prefs.get('find_annotations_color_comboBox', self.GENERIC_STYLE)
color_index = self.find_annotations_color_comboBox.findText(color)
self.find_annotations_color_comboBox.setCurrentIndex(color_index)
text = self.prefs.get('find_annotations_text_lineEdit', '')
self.find_annotations_text_lineEdit.setText(text)
note = self.prefs.get('find_annotations_note_lineEdit', '')
self.find_annotations_note_lineEdit.setText(note)
if False:
from_date = self.prefs.get('find_annotations_date_from_dateEdit', datetime(1970,1,1))
self.find_annotations_date_from_dateEdit.current_val = from_date
to_date = self.prefs.get('find_annotations_date_to_dateEdit', datetime.today())
self.find_annotations_date_to_dateEdit.current_val = to_date
self.blockSignals(False)
def return_pressed(self):
self.update_results("return_pressed")
def save_settings(self):
ra = str(self.find_annotations_reader_comboBox.currentText())
self.prefs.set('find_annotations_reader_comboBox', ra)
color = str(self.find_annotations_color_comboBox.currentText())
self.prefs.set('find_annotations_color_comboBox', color)
text = str(self.find_annotations_text_lineEdit.text())
self.prefs.set('find_annotations_text_lineEdit', text)
note = str(self.find_annotations_note_lineEdit.text())
self.prefs.set('find_annotations_note_lineEdit', note)
if False:
from_date = self.find_annotations_date_from_dateEdit.current_val
self.prefs.set('find_annotations_date_from_dateEdit', from_date)
to_date = self.find_annotations_date_to_dateEdit.current_val
self.prefs.set('find_annotations_date_to_dateEdit', to_date)
def start_inventory_scan(self):
self._log_location()
self.annotated_books_scanner.start()
def update_results(self, trigger):
#self._log_location(trigger)
reader_to_match = str(self.find_annotations_reader_comboBox.currentText())
color_to_match = str(self.find_annotations_color_comboBox.currentText())
text_to_match = str(self.find_annotations_text_lineEdit.text())
note_to_match = str(self.find_annotations_note_lineEdit.text())
from_date = self.find_annotations_date_from_dateEdit.dateTime().toTime_t()
to_date = self.find_annotations_date_to_dateEdit.dateTime().toTime_t()
annotation_map = self.annotated_books_scanner.annotation_map
#field = self.prefs.get("cfg_annotations_destination_field", None)
field = get_cc_mapping('annotations', 'field', None)
db = self.opts.gui.current_db
matched_titles = []
self.matched_ids = set()
for cid in annotation_map:
mi = db.get_metadata(cid, index_is_id=True)
soup = None
if field == 'Comments':
if mi.comments:
soup = BeautifulSoup(mi.comments)
else:
if mi.get_user_metadata(field, False)['#value#'] is not None:
soup = BeautifulSoup(mi.get_user_metadata(field, False)['#value#'])
if soup:
uas = soup.findAll('div', 'annotation')
for ua in uas:
# Are we already logged?
if cid in self.matched_ids:
continue
# Check reader
if reader_to_match != self.GENERIC_READER:
this_reader = ua['reader']
if this_reader != reader_to_match:
continue
# Check color
if color_to_match != self.GENERIC_STYLE:
this_color = ua.find('table')['color']
if this_color != color_to_match:
continue
# Check date range, allow for mangled timestamp
try:
timestamp = float(ua.find('td', 'timestamp')['uts'])
if timestamp < from_date or timestamp > to_date:
continue
except:
continue
highlight_text = ''
try:
pels = ua.findAll('p', 'highlight')
highlight_text = '\n'.join([p.string for p in pels])
except:
pass
if text_to_match > '':
if not re.search(text_to_match, highlight_text, flags=re.IGNORECASE):
continue
note_text = ''
try:
nels = ua.findAll('p', 'note')
note_text = '\n'.join([n.string for n in nels])
except:
pass
if note_to_match > '':
if not re.search(note_to_match, note_text, flags=re.IGNORECASE):
continue
# If we made it this far, add the id to matched_ids
self.matched_ids.add(cid)
matched_titles.append(mi.title)
# Update the results box
matched_titles.sort()
if len(annotation_map):
if len(matched_titles):
first_match = ("<i>%s</i>" % matched_titles[0])
if len(matched_titles) == 1:
results = first_match
else:
results = first_match + (_(" and {0} more.").format(len(matched_titles) - 1))
self.result_label.setText('<p style="color:blue">{0}</p>'.format(results))
else:
self.result_label.setText('<p style="color:red">{0}</p>'.format(_('no matches')))
else:
self.result_label.setText('<p style="color:red">{0}</p>'.format(_('no annotated books in library')))
self.resize_dialog()