def __init__(self, parent=None,):
print(repr(self), repr(parent))
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle("{0} {1}: Rename {0}".format(PLUGIN_NAME, PLUGIN_VERSION, parent.key_type_name))
layout = QVBoxLayout(self)
self.setLayout(layout)
data_group_box = QGroupBox('', self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
data_group_box_layout.addWidget(QLabel('New Key Name:', self))
self.key_ledit = QLineEdit(self.parent.listy.currentItem().text(), self)
self.key_ledit.setToolTip("Enter a new name for this existing {0}.".format(parent.key_type_name))
data_group_box_layout.addWidget(self.key_ledit)
layout.addSpacing(20)
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
def _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)
self._tb.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
# self._tb.setTabChangesFocus(True)
self._layout.addWidget(self._tb)
self._box.setLayout(self._layout)
self.widgets = [self._box]
def setter(self, val):
if not val or not val.strip():
val = ''
else:
val = comments_to_html(val)
self._tb.html = val
self._tb.wyswyg_dirtied()
def getter(self):
val = unicode(self._tb.html).strip()
if not val:
val = None
return val
def __init__(self, parent=None,):
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle(u"{0} {1}: Create New Barnes & Noble Key".format(PLUGIN_NAME, PLUGIN_VERSION))
layout = QVBoxLayout(self)
self.setLayout(layout)
data_group_box = QGroupBox(u"", self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
key_group = QHBoxLayout()
data_group_box_layout.addLayout(key_group)
key_group.addWidget(QLabel(u"Unique Key Name:", self))
self.key_ledit = QLineEdit("", self)
self.key_ledit.setToolTip(_(u"<p>Enter an identifying name for this new key.</p>" +
u"<p>It should be something that will help you remember " +
u"what personal information was used to create it."))
key_group.addWidget(self.key_ledit)
key_label = QLabel(_(''), self)
key_label.setAlignment(Qt.AlignHCenter)
data_group_box_layout.addWidget(key_label)
name_group = QHBoxLayout()
data_group_box_layout.addLayout(name_group)
name_group.addWidget(QLabel(u"B&N/nook account email address:", self))
self.name_ledit = QLineEdit(u"", self)
self.name_ledit.setToolTip(_(u"<p>Enter your email address as it appears in your B&N " +
u"account.</p>" +
u"<p>It will only be used to generate this " +
u"key and won\'t be stored anywhere " +
u"in calibre or on your computer.</p>" +
u"<p>eg: [email protected]</p>"))
name_group.addWidget(self.name_ledit)
name_disclaimer_label = QLabel(_(u"(Will not be saved in configuration data)"), self)
name_disclaimer_label.setAlignment(Qt.AlignHCenter)
data_group_box_layout.addWidget(name_disclaimer_label)
ccn_group = QHBoxLayout()
data_group_box_layout.addLayout(ccn_group)
ccn_group.addWidget(QLabel(u"B&N/nook account password:"******"", self)
self.cc_ledit.setToolTip(_(u"<p>Enter the password " +
u"for your B&N account.</p>" +
u"<p>The password will only be used to generate this " +
u"key and won\'t be stored anywhere in " +
u"calibre or on your computer."))
ccn_group.addWidget(self.cc_ledit)
ccn_disclaimer_label = QLabel(_('(Will not be saved in configuration data)'), self)
ccn_disclaimer_label.setAlignment(Qt.AlignHCenter)
data_group_box_layout.addWidget(ccn_disclaimer_label)
layout.addSpacing(10)
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
def __init__(self, parent=None,):
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle(u"{0} {1}: Add New Mobipocket PID".format(PLUGIN_NAME, PLUGIN_VERSION))
layout = QVBoxLayout(self)
self.setLayout(layout)
data_group_box = QGroupBox(u"", self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
key_group = QHBoxLayout()
data_group_box_layout.addLayout(key_group)
key_group.addWidget(QLabel(u"PID:", self))
self.key_ledit = QLineEdit("", self)
self.key_ledit.setToolTip(u"Enter a Mobipocket PID. Mobipocket PIDs are 8 or 10 characters long. Mobipocket PIDs are case-sensitive, so be sure to enter the upper and lower case letters unchanged.")
key_group.addWidget(self.key_ledit)
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
def __init__(
self,
parent=None,
):
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle("{0} {1}: Add New eInk Kobo Serial Number".format(
PLUGIN_NAME, PLUGIN_VERSION))
layout = QVBoxLayout(self)
self.setLayout(layout)
data_group_box = QGroupBox(u"", self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
key_group = QHBoxLayout()
data_group_box_layout.addLayout(key_group)
key_group.addWidget(QLabel("EInk Kobo Serial Number:", self))
self.key_ledit = QLineEdit("", self)
self.key_ledit.setToolTip(
"Enter an eInk Kobo serial number. EInk Kobo serial numbers are 13 characters long and usually start with a 'N'. Kobo Serial Numbers are case-sensitive, so be sure to enter the upper and lower case letters unchanged."
)
key_group.addWidget(self.key_ledit)
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
def _initialise_controls(self):
layout = QVBoxLayout(self)
self.setLayout(layout)
cust_col = self.library_config.get(PREFS_KEY_UPDATE_COLUMN, '')
cust_val = self.library_config.get(PREFS_KEY_UPDATE_VALUE, '')
content_groupbox = QGroupBox('After generating cover:', self)
layout.addWidget(content_groupbox)
col_layout = QGridLayout()
content_groupbox.setLayout(col_layout)
update_custom_columns = self._get_custom_columns(['text', 'bool'])
self.update_column_combo = CustomColumnComboBox(
self, update_custom_columns, cust_col, ['', 'tags'])
self.update_column_combo.setMinimumWidth(120)
self.update_value_ledit = QLineEdit(cust_val, self)
col_layout.addWidget(QLabel('Update column:', self), 0, 0, 1, 1)
col_layout.addWidget(QLabel('Update value:', self), 1, 0, 1, 1)
col_layout.addWidget(self.update_column_combo, 0, 1, 1, 1)
col_layout.addWidget(self.update_value_ledit, 1, 1, 1, 1)
keyboard_shortcuts_button = QPushButton('Keyboard shortcuts...', self)
keyboard_shortcuts_button.setToolTip(
_('Edit the keyboard shortcuts associated with this plugin'))
keyboard_shortcuts_button.clicked.connect(self._edit_shortcuts)
layout.addWidget(keyboard_shortcuts_button)
view_prefs_button = QPushButton('&View library preferences...', self)
view_prefs_button.setToolTip(
_('View data stored in the library database for this plugin'))
view_prefs_button.clicked.connect(self._view_prefs)
layout.addWidget(view_prefs_button)
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)
def __init__(self, parent=None,):
print repr(self), repr(parent)
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle("{0} {1}: Rename {0}".format(PLUGIN_NAME, PLUGIN_VERSION, parent.key_type_name))
layout = QVBoxLayout(self)
self.setLayout(layout)
data_group_box = QGroupBox('', self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
data_group_box_layout.addWidget(QLabel('New Key Name:', self))
self.key_ledit = QLineEdit(self.parent.listy.currentItem().text(), self)
self.key_ledit.setToolTip(u"Enter a new name for this existing {0}.".format(parent.key_type_name))
data_group_box_layout.addWidget(self.key_ledit)
layout.addSpacing(20)
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
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 __init__(self, parent=None,):
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle(u"{0} {1}: Add New EInk Kindle Serial Number".format(PLUGIN_NAME, PLUGIN_VERSION))
layout = QVBoxLayout(self)
self.setLayout(layout)
data_group_box = QGroupBox(u"", self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
key_group = QHBoxLayout()
data_group_box_layout.addLayout(key_group)
key_group.addWidget(QLabel(u"EInk Kindle Serial Number:", self))
self.key_ledit = QLineEdit("", self)
self.key_ledit.setToolTip(u"Enter an eInk Kindle serial number. EInk Kindle serial numbers are 16 characters long and usually start with a 'B' or a '9'. Kindle Serial Numbers are case-sensitive, so be sure to enter the upper and lower case letters unchanged.")
key_group.addWidget(self.key_ledit)
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
class Comments(Base):
def setup_ui(self, parent):
self._box = QGroupBox(parent)
self._box.setTitle('&' + self.col_metadata['name'])
self._layout = QVBoxLayout()
self._tb = CommentsEditor(self._box)
self._tb.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
# self._tb.setTabChangesFocus(True)
self._layout.addWidget(self._tb)
self._box.setLayout(self._layout)
self.widgets = [self._box]
def setter(self, val):
if not val or not val.strip():
val = ''
else:
val = comments_to_html(val)
self._tb.html = val
self._tb.wyswyg_dirtied()
def getter(self):
val = unicode(self._tb.html).strip()
if not val:
val = None
return val
def createSpeedControls():
speed_gb = QGroupBox("Speed")
speed_gb.setMaximumWidth(50)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
speed1_btn = QPushButton("1")
speed2_btn = QPushButton("2")
speed3_btn = QPushButton("3")
speed4_btn = QPushButton("4")
speed5_btn = QPushButton("5")
speed6_btn = QPushButton("6")
speed1_btn.clicked.connect(lambda: send_cmd(["1"]))
speed2_btn.clicked.connect(lambda: send_cmd(["2"]))
speed3_btn.clicked.connect(lambda: send_cmd(["3"]))
speed4_btn.clicked.connect(lambda: send_cmd(["4"]))
speed5_btn.clicked.connect(lambda: send_cmd(["5"]))
speed6_btn.clicked.connect(lambda: send_cmd(["6"]))
layout.addWidget(speed1_btn)
layout.addWidget(speed2_btn)
layout.addWidget(speed3_btn)
layout.addWidget(speed4_btn)
layout.addWidget(speed5_btn)
layout.addWidget(speed6_btn)
layout.addStretch(1)
speed_gb.setLayout(layout)
return speed_gb
def createCalibrationControls():
gb = QGroupBox("Calibration")
#------------------------------------------
layout = QGridLayout()
arduino = createArduinoCalibrationControls()
pc = createPcCalibrationControls()
gui = createGuiCalibration()
layout.addWidget(arduino, 0, 0, 1, 1)
layout.addWidget(pc, 1, 0, 1, 1)
layout.addWidget(gui, 0, 1, 2, 1)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(5)
upper = QWidget()
upper.setLayout(layout)
#------------------------------------------
vbox = QVBoxLayout()
vbox.addWidget(upper)
vbox.addStretch(1)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
gb.setLayout(vbox)
return gb
def __init__(self, parent=None,):
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle("{0} {1}: Add New Mobipocket PID".format(PLUGIN_NAME, PLUGIN_VERSION))
layout = QVBoxLayout(self)
self.setLayout(layout)
data_group_box = QGroupBox("", self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
key_group = QHBoxLayout()
data_group_box_layout.addLayout(key_group)
key_group.addWidget(QLabel("PID:", self))
self.key_ledit = QLineEdit("", self)
self.key_ledit.setToolTip("Enter a Mobipocket PID. Mobipocket PIDs are 8 or 10 characters long. Mobipocket PIDs are case-sensitive, so be sure to enter the upper and lower case letters unchanged.")
key_group.addWidget(self.key_ledit)
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
def __init__(self, plugin):
DefaultConfigWidget.__init__(self, plugin)
c = plugin_prefs[STORE_NAME]
other_group_box = QGroupBox('Other options', self)
self.l.addWidget(other_group_box, self.l.rowCount(), 0, 1, 2)
other_group_box_layout = QHBoxLayout()
other_group_box.setLayout(other_group_box_layout)
max_label = QLabel(
'Maximum title/author search matches to evaluate (1 = fastest):',
self)
max_label.setToolTip(
'Libri.hu do not always have links to large covers for every ISBN\n'
'of the same book. Increasing this value will take effect when doing\n'
'title/author searches to consider more ISBN editions.\n\n'
'This will increase the potential likelihood of getting a larger cover\n'
'though does not guarantee it.')
other_group_box_layout.addWidget(max_label)
self.max_downloads_spin = QtGui.QSpinBox(self)
self.max_downloads_spin.setMinimum(5)
self.max_downloads_spin.setMaximum(50)
self.max_downloads_spin.setProperty(
'value',
c.get(KEY_MAX_DOWNLOADS, DEFAULT_STORE_VALUES[KEY_MAX_DOWNLOADS]))
other_group_box_layout.addWidget(self.max_downloads_spin)
other_group_box_layout.insertStretch(-1)
def __init__(self, parent=None,):
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle(u"{0} {1}: Add New Kindle for Android Serial Number".format(PLUGIN_NAME, PLUGIN_VERSION))
layout = QVBoxLayout(self)
self.setLayout(layout)
data_group_box = QGroupBox(u"", self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
key_group = QHBoxLayout()
data_group_box_layout.addLayout(key_group)
key_group.addWidget(QLabel(u"Kindle for Android Serial Number:", self))
self.key_ledit = QLineEdit("", self)
self.key_ledit.setToolTip(u"Enter a Kindle for ANdroid serial number. These can be found using the androidkindlekey.py script.")
key_group.addWidget(self.key_ledit)
key_label = QLabel(_(''), self)
key_label.setAlignment(Qt.AlignHCenter)
data_group_box_layout.addWidget(key_label)
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
def initialize_controls(self):
self.setWindowTitle(DIALOG_NAME)
layout = QVBoxLayout(self)
self.setLayout(layout)
title_layout = ImageTitleLayout(self, 'images/icon.png', 'Update custom columns in Library')
layout.addLayout(title_layout)
column_group = QGroupBox(_("Columns to update"), self)
layout.addWidget(column_group)
column_layout = QGridLayout()
column_group.setLayout(column_layout)
pos = 0
self.checkbox = {}
for key in sorted (self.custom_cols):
value = self.custom_cols[key]
self.checkbox[key] = self.createCheckbox (value)
column_layout.addWidget(self.checkbox[key], int ((pos / 2)), int ((pos % 2)* 2 + 1), 1, 1)
pos = pos + 1
layout.addStretch(1)
# Dialog buttons
button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
button_box.accepted.connect(self.ok_clicked)
button_box.rejected.connect(self.reject)
layout.addWidget(button_box)
def make_groupbox(self, group, parent):
groupbox = QGroupBox(group["Title"], self)
setattr(self, group["Name"] + "_box", groupbox)
parent.addWidget(groupbox)
groupbox_layout = QGridLayout()
setattr(self, group["Name"] + "_layout", groupbox_layout)
groupbox.setLayout(groupbox_layout)
return groupbox_layout
def make_groupbox(self, name, title, parent):
groupbox = QGroupBox(title, self)
setattr(self, name, groupbox)
parent.addWidget(groupbox)
groupbox_layout = QGridLayout()
setattr(self, name + "_layout", groupbox_layout)
groupbox.setLayout(groupbox_layout)
return groupbox_layout
def createNavigationControls():
gb = QGroupBox("Navigation Controls")
#-------------------------------------------
layout = QGridLayout()
pause_both_btn = QPushButton("Pause vector && time")
pause_btn = QPushButton("Pause vector")
pause_time_btn = QPushButton("Pause time")
continue_btn = QPushButton("Continue")
release_btn = QPushButton("Release")
cwHalfStep_btn = QPushButton("=> half step")
ccwHalfStep_btn = QPushButton("<= half step")
ccwDir_btn = QPushButton("CCW direction")
cwDir_btn = QPushButton("CW direction")
continue_btn.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
pause_both_btn.clicked.connect(pause_vector_and_time)
pause_btn.clicked.connect(lambda: send_cmd(["p"]))
pause_time_btn.clicked.connect(tracker.pause_time)
continue_btn.clicked.connect(continue_)
release_btn.clicked.connect(lambda: send_cmd(["r"]))
cwHalfStep_btn.clicked.connect(lambda: send_cmd([">", "h", "<"]))
ccwHalfStep_btn.clicked.connect(lambda: send_cmd(["<", "h"]))
ccwDir_btn.clicked.connect(lambda: send_cmd(["<"]))
cwDir_btn.clicked.connect(lambda: send_cmd([">"]))
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.setVerticalSpacing(0)
layout.addWidget(pause_both_btn, 0, 0)
layout.addWidget(pause_btn, 1, 0)
layout.addWidget(pause_time_btn, 2, 0)
layout.addWidget(continue_btn, 0, 1, 3, 1)
layout.addWidget(ccwHalfStep_btn, 3, 0)
layout.addWidget(cwHalfStep_btn, 3, 1)
layout.addWidget(ccwDir_btn, 4, 0)
layout.addWidget(cwDir_btn, 4, 1)
layout.addWidget(createGotoControls(), 5, 0, 1, 2)
layout.addWidget(release_btn, 6, 0, 1, 2)
upper = QWidget()
upper.setLayout(layout)
#-------------------------------------------
vbox = QVBoxLayout()
vbox.addWidget(upper)
vbox.addStretch(1)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
gb.setLayout(vbox)
return gb
def createArduinoCalibrationControls():
gb = QGroupBox("Arduino Calibration")
vbox = QVBoxLayout()
#-------------------------------------------
layout = QHBoxLayout()
label = QLabel("Set current position as:")
lineEdit = QLineEdit()
degreesLabel = QLabel("deg")
set_btn = QPushButton("Set")
lineEdit.setMaximumWidth(30)
set_btn.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
set_btn.clicked.connect(lambda: send_cmd(["=" + lineEdit.displayText()]))
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(label)
layout.addWidget(lineEdit)
layout.addWidget(degreesLabel)
layout.addWidget(set_btn)
upper = QWidget()
upper.setLayout(layout)
#-------------------------------------------
layout = QHBoxLayout()
btn0 = QPushButton("Set as 0")
btn180 = QPushButton("Set as 180")
btn0.clicked.connect(lambda: send_cmd(["=0"]))
btn180.clicked.connect(lambda: send_cmd(["=180"]))
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(btn0)
layout.addWidget(btn180)
layout.addStretch(1)
lower = QWidget()
lower.setLayout(layout)
#-------------------------------------------
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
vbox.addWidget(upper)
vbox.addWidget(lower)
gb.setLayout(vbox)
return gb
def __init__(self, plugin):
DefaultConfigWidget.__init__(self, plugin)
c = plugin_prefs[STORE_NAME]
other_group_box = QGroupBox('Other options', self)
self.l.addWidget(other_group_box, self.l.rowCount(), 0, 1, 2)
other_group_box_layout = QGridLayout()
other_group_box.setLayout(other_group_box_layout)
# Guess Series
guess_series_label = QLabel(
'Guess Series and Series Index from Title:', self)
guess_series_label.setToolTip('DNB only rarely provides data about a book\'s series.\n'
'This plugin can try to extract series and series_index from the book title.\n')
other_group_box_layout.addWidget(guess_series_label, 0, 0, 1, 1)
self.guess_series_checkbox = QtGui.QCheckBox(self)
self.guess_series_checkbox.setChecked(
c.get(KEY_GUESS_SERIES, DEFAULT_STORE_VALUES[KEY_GUESS_SERIES]))
other_group_box_layout.addWidget(
self.guess_series_checkbox, 0, 1, 1, 1)
# Append Edition to Title
append_edition_to_title_label = QLabel(
'Append Edition to Title:', self)
append_edition_to_title_label.setToolTip('For some books DNB has information about the edition.\n'
'This plugin can fetch this information and append it to the book\'s title,\n'
'e.g. "Mord am Tegernsee : Ein Bayern-Krimi : 2. Aufl.".\n'
'Of course this only works reliable if you search for a book with a known unique identifier such as dnb-idn or ISBN.')
other_group_box_layout.addWidget(
append_edition_to_title_label, 1, 0, 1, 1)
self.append_edition_to_title_checkbox = QtGui.QCheckBox(self)
self.append_edition_to_title_checkbox.setChecked(c.get(
KEY_APPEND_EDITION_TO_TITLE, DEFAULT_STORE_VALUES[KEY_APPEND_EDITION_TO_TITLE]))
other_group_box_layout.addWidget(
self.append_edition_to_title_checkbox, 1, 1, 1, 1)
# Fetch Subjects
fetch_subjects_label = QLabel('Fetch Subjects:', self)
fetch_subjects_label.setToolTip('DNB provides several types of subjects:\n'
' - Standardized subjects according to the GND\n'
' - Subjects delivered by the publisher\n'
'You can choose which ones to fetch.')
other_group_box_layout.addWidget(fetch_subjects_label, 2, 0, 1, 1)
self.fetch_subjects_radios_group = QtGui.QButtonGroup(other_group_box)
titles = ['only GND subjects', 'GND subjects if available, otherwise non-GND subjects', 'GND and non-GND subjects',
'non-GND subjects if available, otherwise GND subjects', 'only non-GND subjects', 'none']
self.fetch_subjects_radios = [
QtGui.QRadioButton(title) for title in titles]
for i, radio in enumerate(self.fetch_subjects_radios):
if i == c.get(KEY_FETCH_SUBJECTS, DEFAULT_STORE_VALUES[KEY_FETCH_SUBJECTS]):
radio.setChecked(True)
self.fetch_subjects_radios_group.addButton(radio, i)
other_group_box_layout.addWidget(radio, 2 + i, 1, 1, 1)
class Group(QDlgContainer):
def __init__(self, title: str):
self.groupBox = QGroupBox(title)
self.layout = QVBoxLayout()
self.groupBox.setLayout(self.layout)
qDlgStackTop().addChild(self.groupBox)
def addChild(self, child):
addLayoutOrWidget(self.layout, child)
return self
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle(u"{0} {1}: Getting Default Adobe Digital Editions Key".format(PLUGIN_NAME, PLUGIN_VERSION))
layout = QVBoxLayout(self)
self.setLayout(layout)
try:
if iswindows or isosx:
from calibre_plugins.dedrm.adobekey import adeptkeys
defaultkeys = adeptkeys()
else: # linux
from wineutils import WineGetKeys
scriptpath = os.path.join(parent.parent.alfdir, u"adobekey.py")
defaultkeys = WineGetKeys(scriptpath, u".der", parent.getwineprefix())
self.default_key = defaultkeys[0]
except:
traceback.print_exc()
self.default_key = u""
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
if len(self.default_key) > 0:
data_group_box = QGroupBox(u"", self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
key_group = QHBoxLayout()
data_group_box_layout.addLayout(key_group)
key_group.addWidget(QLabel(u"Unique Key Name:", self))
self.key_ledit = QLineEdit(u"default_key", self)
self.key_ledit.setToolTip(
u"<p>Enter an identifying name for the current default Adobe Digital Editions key."
)
key_group.addWidget(self.key_ledit)
self.button_box.accepted.connect(self.accept)
else:
default_key_error = QLabel(
u"The default encryption key for Adobe Digital Editions could not be found.", self
)
default_key_error.setAlignment(Qt.AlignHCenter)
layout.addWidget(default_key_error)
# if no default, bot buttons do the same
self.button_box.accepted.connect(self.reject)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
def __init__(self, plugin_action):
QWidget.__init__(self)
self.plugin_action = plugin_action
layout = QVBoxLayout(self)
self.setLayout(layout)
# --- Directory Options ---
directory_group_box = QGroupBox(_('Default Unpack Directory:'), self)
layout.addWidget(directory_group_box)
directory_group_box_layout = QVBoxLayout()
directory_group_box.setLayout(directory_group_box_layout)
# Directory path Textbox
# Load the textbox with the current preference setting
self.directory_txtBox = QLineEdit(plugin_prefs['Unpack_Folder'], self)
self.directory_txtBox.setToolTip(_('<p>Default directory to extract files to'))
directory_group_box_layout.addWidget(self.directory_txtBox)
self.directory_txtBox.setReadOnly(True)
# Folder select button
directory_button = QPushButton(_('Select/Change Unpack Directory'), self)
directory_button.setToolTip(_('<p>Select/Change directory to extract files to.'))
# Connect button to the getDirectory function
directory_button.clicked.connect(self.getDirectory)
directory_group_box_layout.addWidget(directory_button)
self.default_folder_check = QCheckBox(_('Always use the Default Unpack Directory'), self)
self.default_folder_check.setToolTip(_('<p>When unchecked... you will be prompted to select a destination '+
'directory for the extracted content each time you use Mobiunpack.'))
directory_group_box_layout.addWidget(self.default_folder_check)
# Load the checkbox with the current preference setting
self.default_folder_check.setChecked(plugin_prefs['Always_Use_Unpack_Folder'])
misc_group_box = QGroupBox(_('Default settings:'), self)
layout.addWidget(misc_group_box)
misc_group_box_layout = QVBoxLayout()
misc_group_box.setLayout(misc_group_box_layout)
self.use_hd_images = QCheckBox(_('Always use HD images if present'), self)
self.use_hd_images.setToolTip(_('<p>When checked... any HD images present in the kindlebook '+
'will be used for creating the ePub.'))
misc_group_box_layout.addWidget(self.use_hd_images)
# Load the checkbox with the current preference setting
self.use_hd_images.setChecked(plugin_prefs['Use_HD_Images'])
combo_label = QLabel('Select epub version output:', self)
misc_group_box_layout.addWidget(combo_label)
self.epub_version_combobox = QComboBox()
self.epub_version_combobox.setToolTip(_('<p>Select the type of OPF file to create.'))
misc_group_box_layout.addWidget(self.epub_version_combobox)
self.epub_version_combobox.addItems(['Auto-detect', 'ePub2', 'ePub3'])
if plugin_prefs['Epub_Version'] == 'A':
self.epub_version_combobox.setCurrentIndex(0)
else:
self.epub_version_combobox.setCurrentIndex(int(plugin_prefs['Epub_Version'])-1)
def __init__(self, parent=None,):
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle(u"{0} {1}: Getting Default Kindle for Mac/PC Key".format(PLUGIN_NAME, PLUGIN_VERSION))
layout = QVBoxLayout(self)
self.setLayout(layout)
try:
if iswindows or isosx:
from calibre_plugins.dedrm.kindlekey import kindlekeys
defaultkeys = kindlekeys()
else: # linux
from wineutils import WineGetKeys
scriptpath = os.path.join(parent.parent.alfdir,u"kindlekey.py")
defaultkeys = WineGetKeys(scriptpath, u".k4i",parent.getwineprefix())
self.default_key = defaultkeys[0]
except:
traceback.print_exc()
self.default_key = u""
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
if len(self.default_key)>0:
data_group_box = QGroupBox(u"", self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
key_group = QHBoxLayout()
data_group_box_layout.addLayout(key_group)
key_group.addWidget(QLabel(u"Unique Key Name:", self))
self.key_ledit = QLineEdit(u"default_key", self)
self.key_ledit.setToolTip(u"<p>Enter an identifying name for the current default Kindle for Mac/PC key.")
key_group.addWidget(self.key_ledit)
key_label = QLabel(_(''), self)
key_label.setAlignment(Qt.AlignHCenter)
data_group_box_layout.addWidget(key_label)
self.button_box.accepted.connect(self.accept)
else:
default_key_error = QLabel(u"The default encryption key for Kindle for Mac/PC could not be found.", self)
default_key_error.setAlignment(Qt.AlignHCenter)
layout.addWidget(default_key_error)
# if no default, bot buttons do the same
self.button_box.accepted.connect(self.reject)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle(u"{0} {1}: Create New eReader Key".format(PLUGIN_NAME, PLUGIN_VERSION))
layout = QVBoxLayout(self)
self.setLayout(layout)
data_group_box = QGroupBox(u"", self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
key_group = QHBoxLayout()
data_group_box_layout.addLayout(key_group)
key_group.addWidget(QLabel(u"Unique Key Name:", self))
self.key_ledit = QLineEdit("", self)
self.key_ledit.setToolTip(
u"<p>Enter an identifying name for this new key.\nIt should be something that will help you remember what personal information was used to create it."
)
key_group.addWidget(self.key_ledit)
name_group = QHBoxLayout()
data_group_box_layout.addLayout(name_group)
name_group.addWidget(QLabel(u"Your Name:", self))
self.name_ledit = QLineEdit(u"", self)
self.name_ledit.setToolTip(
u"Enter the name for this eReader key, usually the name on your credit card.\nIt will only be used to generate this one-time key and won't be stored anywhere in calibre or on your computer.\n(ex: Mr Jonathan Q Smith)"
)
name_group.addWidget(self.name_ledit)
name_disclaimer_label = QLabel(_(u"(Will not be saved in configuration data)"), self)
name_disclaimer_label.setAlignment(Qt.AlignHCenter)
data_group_box_layout.addWidget(name_disclaimer_label)
ccn_group = QHBoxLayout()
data_group_box_layout.addLayout(ccn_group)
ccn_group.addWidget(QLabel(u"Credit Card#:", self))
self.cc_ledit = QLineEdit(u"", self)
self.cc_ledit.setToolTip(
u"<p>Enter the last 8 digits of credit card number for this eReader key.\nThey will only be used to generate this one-time key and won't be stored anywhere in calibre or on your computer."
)
ccn_group.addWidget(self.cc_ledit)
ccn_disclaimer_label = QLabel(_("(Will not be saved in configuration data)"), self)
ccn_disclaimer_label.setAlignment(Qt.AlignHCenter)
data_group_box_layout.addWidget(ccn_disclaimer_label)
layout.addSpacing(10)
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
def __init__(self, parent, key_type_name, plugin_keys, create_key, keyfile_ext = u""):
QDialog.__init__(self,parent)
self.parent = parent
self.key_type_name = key_type_name
self.plugin_keys = plugin_keys
self.create_key = create_key
self.keyfile_ext = keyfile_ext
self.json_file = (keyfile_ext == u"k4i")
self.setWindowTitle("{0} {1}: Manage {2}s".format(PLUGIN_NAME, PLUGIN_VERSION, self.key_type_name))
# Start Qt Gui dialog layout
layout = QVBoxLayout(self)
self.setLayout(layout)
keys_group_box = QGroupBox(_(u"{0}s".format(self.key_type_name)), self)
layout.addWidget(keys_group_box)
keys_group_box_layout = QHBoxLayout()
keys_group_box.setLayout(keys_group_box_layout)
self.listy = QListWidget(self)
self.listy.setToolTip(u"{0}s that will be used to decrypt ebooks".format(self.key_type_name))
self.listy.setSelectionMode(QAbstractItemView.SingleSelection)
self.populate_list()
keys_group_box_layout.addWidget(self.listy)
button_layout = QVBoxLayout()
keys_group_box_layout.addLayout(button_layout)
self._add_key_button = QtGui.QToolButton(self)
self._add_key_button.setIcon(QIcon(I('plus.png')))
self._add_key_button.setToolTip(u"Create new {0}".format(self.key_type_name))
self._add_key_button.clicked.connect(self.add_key)
button_layout.addWidget(self._add_key_button)
self._delete_key_button = QtGui.QToolButton(self)
self._delete_key_button.setToolTip(_(u"Delete highlighted key"))
self._delete_key_button.setIcon(QIcon(I('list_remove.png')))
self._delete_key_button.clicked.connect(self.delete_key)
button_layout.addWidget(self._delete_key_button)
spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
button_layout.addItem(spacerItem)
layout.addSpacing(5)
migrate_layout = QHBoxLayout()
layout.addLayout(migrate_layout)
migrate_layout.addStretch()
self.button_box = QDialogButtonBox(QDialogButtonBox.Close)
self.button_box.rejected.connect(self.close)
migrate_layout.addWidget(self.button_box)
self.resize(self.sizeHint())
def __init__(self, parent=None,):
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle(u"{0} {1}: Create New eReader Key".format(PLUGIN_NAME, PLUGIN_VERSION))
layout = QVBoxLayout(self)
self.setLayout(layout)
data_group_box = QGroupBox(u"", self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
key_group = QHBoxLayout()
data_group_box_layout.addLayout(key_group)
key_group.addWidget(QLabel(u"Unique Key Name:", self))
self.key_ledit = QLineEdit("", self)
self.key_ledit.setToolTip(u"<p>Enter an identifying name for this new key.\nIt should be something that will help you remember what personal information was used to create it.")
key_group.addWidget(self.key_ledit)
key_label = QLabel(_(''), self)
key_label.setAlignment(Qt.AlignHCenter)
data_group_box_layout.addWidget(key_label)
name_group = QHBoxLayout()
data_group_box_layout.addLayout(name_group)
name_group.addWidget(QLabel(u"Your Name:", self))
self.name_ledit = QLineEdit(u"", self)
self.name_ledit.setToolTip(u"Enter the name for this eReader key, usually the name on your credit card.\nIt will only be used to generate this one-time key and won\'t be stored anywhere in calibre or on your computer.\n(ex: Mr Jonathan Q Smith)")
name_group.addWidget(self.name_ledit)
name_disclaimer_label = QLabel(_(u"(Will not be saved in configuration data)"), self)
name_disclaimer_label.setAlignment(Qt.AlignHCenter)
data_group_box_layout.addWidget(name_disclaimer_label)
ccn_group = QHBoxLayout()
data_group_box_layout.addLayout(ccn_group)
ccn_group.addWidget(QLabel(u"Credit Card#:", self))
self.cc_ledit = QLineEdit(u"", self)
self.cc_ledit.setToolTip(u"<p>Enter the last 8 digits of credit card number for this eReader key.\nThey will only be used to generate this one-time key and won\'t be stored anywhere in calibre or on your computer.")
ccn_group.addWidget(self.cc_ledit)
ccn_disclaimer_label = QLabel(_('(Will not be saved in configuration data)'), self)
ccn_disclaimer_label.setAlignment(Qt.AlignHCenter)
data_group_box_layout.addWidget(ccn_disclaimer_label)
layout.addSpacing(10)
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
def createControlWidgets():
gb = QGroupBox()
layout = QGridLayout()
layout.addWidget(createSpeedControls(), 0, 0, 1, 1)
layout.addWidget(createCalibrationControls(), 0, 1, 1, 1)
layout.addWidget(createGuiControls(), 1, 1, 1, 1)
layout.addWidget(createNavigationControls(), 0, 2, 2, 1)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(5)
upper = QWidget()
upper.setLayout(layout)
#------------------------------------------
lower = createMonitorControls()
#------------------------------------------
vbox = QVBoxLayout()
vbox.addWidget(upper)
vbox.addWidget(lower)
vbox.addStretch(1)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
right = QWidget()
right.setLayout(vbox)
#------------------------------------------
layout = QHBoxLayout()
layout.addStretch(1)
layout.addWidget(right)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
gb.setLayout(layout)
gb.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
gb.setMaximumHeight(400)
return gb
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()
def __init__(self, metadata, parent=None):
QDialog.__init__(self, parent=parent)
self.setWindowFlags(Qt.Window)
buttonBox = QDialogButtonBox(QDialogButtonBox.Close)
origbrowser = QTextBrowser()
origbrowser.setText('')
origbrowser.setReadOnly(True)
browser = QTextBrowser()
browser.setText('')
browser.setReadOnly(True)
gpbox2 = QGroupBox('Metadata: Original')
lay2 = QHBoxLayout()
gpbox2.setLayout(lay2)
lay2.addWidget(origbrowser)
gpbox4 = QGroupBox('Metadata: After scrambling')
lay4 = QHBoxLayout()
gpbox4.setLayout(lay4)
lay4.addWidget(browser)
splitter = QSplitter(Qt.Horizontal)
splitter.addWidget(gpbox2)
splitter.addWidget(gpbox4)
splitter.setMinimumHeight(500)
splitter.setMinimumWidth(1000)
lay = QVBoxLayout()
self.setLayout(lay)
lay.addWidget(splitter)
lay.addWidget(buttonBox)
# create connect signals/slots
buttonBox.rejected.connect(self.reject)
metaorig = metadata.get('orig', '')
metaorig = re.sub(r'\n\s*', r'\n ', metaorig)
origbrowser.setText(metaorig)
browser.setText(metadata.get('scramb', ''))
self.setWindowTitle('%s: Metadata' % CAPTION)
if not 'scramb' in metadata:
gpbox4.setVisible(False)
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()
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 add_declarant(self, var=True, gl=None):
if not gl:
gl = self.dec_layout
dc = {}
gb_l = QGridLayout()
if self.cb.currentIndex() == 0 or gl != self.dec_layout:
# Add Individual
gb = QGroupBox(tr('Физическое лицо *'))
gb_l.addWidget(QLabel(tr('Фамилия <em style="color: red">*</em>')))
w = QLineEdit()
gb_l.addWidget(w, 0, 1, 1, 1)
dc['surname'] = w
gb_l.addWidget(QLabel(tr('Имя <em style="color: red">*</em>')))
w = QLineEdit()
gb_l.addWidget(w)
dc['first_name'] = w
gb_l.addWidget(QLabel(tr('Отчество')))
w = QLineEdit()
gb_l.addWidget(w)
dc['patronymic'] = w
adr = QGroupBox(tr('Адрес регистрации *'))
adr_l = QGridLayout()
dc['address'] = self.__add_address(adr_l)
adr.setLayout(adr_l)
gb_l.addWidget(adr, gb_l.rowCount() + 1, 0, 1, 2)
gb.setLayout(gb_l)
gl.addWidget(gb, gl.rowCount() + 1, 0, 1, 2)
self.individuals.append(dc)
else:
# Add LegalEntity
gb = QGroupBox(
tr('Юридическое лицо/Индивидуальный предприниматель *'))
gb_l.addWidget(
QLabel(
tr('Краткое наименование ЮЛ <em style="color: red">*</em>')
))
w = QLineEdit()
gb_l.addWidget(w, 0, 1, 1, 1)
dc['name'] = w
adr = QGroupBox(tr('Юридический адрес *'))
adr_l = QGridLayout()
dc['address'] = self.__add_address(adr_l)
adr.setLayout(adr_l)
gb_l.addWidget(adr, gb_l.rowCount() + 1, 0, 1, 2)
gb.setLayout(gb_l)
gl.addWidget(gb, gl.rowCount() + 1, 0, 1, 2)
self.entities.append(dc)
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 createMonitorControls():
gb = QGroupBox("Monitor")
#------------------------------------------
layout = QHBoxLayout()
label1 = QLabel("Angle:")
label2 = QLabel("Half steps:")
global angle_le
angle_le = QLineEdit()
global halfSteps_le
halfSteps_le = QLineEdit()
angle_le.setMaximumWidth(50)
halfSteps_le.setMaximumWidth(50)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(5)
layout.addWidget(label1)
layout.addWidget(angle_le)
layout.addWidget(label2)
layout.addWidget(halfSteps_le)
layout.addStretch()
upper = QWidget()
upper.setLayout(layout)
#------------------------------------------
vbox = QVBoxLayout()
vbox.addWidget(upper)
vbox.addStretch(1)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
gb.setLayout(vbox)
return gb
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)
def __init__(self, plugin):
DefaultConfigWidget.__init__(self, plugin)
c = plugin_prefs[STORE_NAME]
other_group_box = QGroupBox('Other options', self)
self.l.addWidget(other_group_box, self.l.rowCount(), 0, 1, 2)
other_group_box_layout = QGridLayout()
other_group_box.setLayout(other_group_box_layout)
# Maximum # of title/author searches to review.
max_label = QLabel(
'Maximum title/author search matches to evaluate (1 = fastest):',
self)
max_label.setToolTip(
'ISFDB doesn\'t always have links to large covers for every ISBN\n'
'of the same book. Increasing this value will take effect when doing\n'
'title/author searches to consider more ISBN editions.\n\n'
'This will increase the potential likelihood of getting a larger cover,\n'
'though does not guarantee it.')
other_group_box_layout.addWidget(max_label, 0, 0, 1, 1)
self.max_downloads_spin = QtGui.QSpinBox(self)
self.max_downloads_spin.setMinimum(1)
self.max_downloads_spin.setMaximum(5)
self.max_downloads_spin.setProperty(
'value',
c.get(KEY_MAX_DOWNLOADS, DEFAULT_STORE_VALUES[KEY_MAX_DOWNLOADS]))
other_group_box_layout.addWidget(self.max_downloads_spin, 0, 1, 1, 1)
other_group_box_layout.setColumnStretch(2, 1)
# Contents field, if possible.
self.contents_checkbox = QCheckBox(
'Append Contents if available to comments', self)
self.contents_checkbox.setToolTip(
'Choosing this option will write the Contents section to the comments\n'
'field, if such a section exists.')
self.contents_checkbox.setChecked(
c.get(KEY_APPEND_CONTENTS,
DEFAULT_STORE_VALUES[KEY_APPEND_CONTENTS]))
other_group_box_layout.addWidget(self.contents_checkbox, 2, 0, 1, 3)
def createGuiControls():
gb = QGroupBox("GUI Controls")
#-------------------------------------------------
layout = QVBoxLayout()
drawShadow_cb = QCheckBox("Draw Shadow")
drawRotatingVector_cb = QCheckBox("Draw Rotating Vector and projection")
drawShadow_cb.setChecked(tracker.draw_shadow)
drawRotatingVector_cb.setChecked(tracker.draw_rotating_vector)
drawShadow_cb.stateChanged.connect(
lambda: tracker.show_shadow(drawShadow_cb.isChecked()))
drawRotatingVector_cb.stateChanged.connect(
lambda: tracker.show_rotating_vector(drawRotatingVector_cb.isChecked()
))
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(drawShadow_cb)
layout.addWidget(drawRotatingVector_cb)
upper = QWidget()
upper.setLayout(layout)
#-------------------------------------------------
vbox = QVBoxLayout()
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
vbox.addWidget(upper)
vbox.addStretch(1)
gb.setLayout(vbox)
return gb
def __init__(self, gui, formats, parent=None):
QDialog.__init__(self, parent=parent)
self.gui = gui
self.formats = formats
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok)
msg = '\nThis book has multiple formats which could be scrambled.\n' \
'Please select one of the following:\n'
label = QLabel(msg)
self.dradio = {}
for k in self.formats:
self.dradio[k] = QRadioButton(k)
gpbox1 = QGroupBox('Formats available:')
lay1 = QHBoxLayout()
gpbox1.setLayout(lay1)
for fmt in self.formats:
lay1.addWidget(self.dradio[fmt])
if 'EPUB' in self.formats:
self.dradio['EPUB'].setChecked(True)
else:
self.dradio[self.formats[0]].setChecked(True)
lay = QVBoxLayout()
lay.addWidget(label)
lay.addWidget(gpbox1)
lay.addStretch()
lay.addWidget(buttonBox)
self.setLayout(lay)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
self.setWindowTitle('ScrambleEbook: Select a single format')
self.setWindowIcon(get_icons('images/plugin_icon.png'))
def __init__(self, parent=None,):
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle("{0} {1}: Add new Kindle for Android Key".format(PLUGIN_NAME, PLUGIN_VERSION))
layout = QVBoxLayout(self)
self.setLayout(layout)
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
data_group_box = QGroupBox("", self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
file_group = QHBoxLayout()
data_group_box_layout.addLayout(file_group)
add_btn = QPushButton("Choose Backup File", self)
add_btn.setToolTip("Import Kindle for Android backup file.")
add_btn.clicked.connect(self.get_android_file)
file_group.addWidget(add_btn)
self.selected_file_name = QLabel("",self)
self.selected_file_name.setAlignment(Qt.AlignHCenter)
file_group.addWidget(self.selected_file_name)
key_group = QHBoxLayout()
data_group_box_layout.addLayout(key_group)
key_group.addWidget(QLabel("Unique Key Name:", self))
self.key_ledit = QLineEdit("", self)
self.key_ledit.setToolTip("<p>Enter an identifying name for the Android for Kindle key.")
key_group.addWidget(self.key_ledit)
#key_label = QLabel(_(''), self)
#key_label.setAlignment(Qt.AlignHCenter)
#data_group_box_layout.addWidget(key_label)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
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 __init__(self, parent=None,):
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle(u"{0} {1}: Add new Kindle for Android Key".format(PLUGIN_NAME, PLUGIN_VERSION))
layout = QVBoxLayout(self)
self.setLayout(layout)
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
data_group_box = QGroupBox(u"", self)
layout.addWidget(data_group_box)
data_group_box_layout = QVBoxLayout()
data_group_box.setLayout(data_group_box_layout)
file_group = QHBoxLayout()
data_group_box_layout.addLayout(file_group)
add_btn = QPushButton(u"Choose Backup File", self)
add_btn.setToolTip(u"Import Kindle for Android backup file.")
add_btn.clicked.connect(self.get_android_file)
file_group.addWidget(add_btn)
self.selected_file_name = QLabel(u"",self)
self.selected_file_name.setAlignment(Qt.AlignHCenter)
file_group.addWidget(self.selected_file_name)
key_group = QHBoxLayout()
data_group_box_layout.addLayout(key_group)
key_group.addWidget(QLabel(u"Unique Key Name:", self))
self.key_ledit = QLineEdit(u"", self)
self.key_ledit.setToolTip(u"<p>Enter an identifying name for the Android for Kindle key.")
key_group.addWidget(self.key_ledit)
#key_label = QLabel(_(''), self)
#key_label.setAlignment(Qt.AlignHCenter)
#data_group_box_layout.addWidget(key_label)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.resize(self.sizeHint())
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, plugin_path, alfdir):
QWidget.__init__(self)
self.plugin_path = plugin_path
self.alfdir = alfdir
# get the prefs
self.dedrmprefs = prefs.DeDRM_Prefs()
# make a local copy
self.tempdedrmprefs = {}
self.tempdedrmprefs['bandnkeys'] = self.dedrmprefs['bandnkeys'].copy()
self.tempdedrmprefs['adeptkeys'] = self.dedrmprefs['adeptkeys'].copy()
self.tempdedrmprefs['ereaderkeys'] = self.dedrmprefs['ereaderkeys'].copy()
self.tempdedrmprefs['kindlekeys'] = self.dedrmprefs['kindlekeys'].copy()
self.tempdedrmprefs['androidkeys'] = self.dedrmprefs['androidkeys'].copy()
self.tempdedrmprefs['pids'] = list(self.dedrmprefs['pids'])
self.tempdedrmprefs['serials'] = list(self.dedrmprefs['serials'])
self.tempdedrmprefs['adobewineprefix'] = self.dedrmprefs['adobewineprefix']
self.tempdedrmprefs['kindlewineprefix'] = self.dedrmprefs['kindlewineprefix']
# Start Qt Gui dialog layout
layout = QVBoxLayout(self)
self.setLayout(layout)
help_layout = QHBoxLayout()
layout.addLayout(help_layout)
# Add hyperlink to a help file at the right. We will replace the correct name when it is clicked.
help_label = QLabel('<a href="http://www.foo.com/">Plugin Help</a>', self)
help_label.setTextInteractionFlags(Qt.LinksAccessibleByMouse | Qt.LinksAccessibleByKeyboard)
help_label.setAlignment(Qt.AlignRight)
help_label.linkActivated.connect(self.help_link_activated)
help_layout.addWidget(help_label)
keys_group_box = QGroupBox(_('Configuration:'), self)
layout.addWidget(keys_group_box)
keys_group_box_layout = QHBoxLayout()
keys_group_box.setLayout(keys_group_box_layout)
button_layout = QVBoxLayout()
keys_group_box_layout.addLayout(button_layout)
self.bandn_button = QtGui.QPushButton(self)
self.bandn_button.setToolTip(_(u"Click to manage keys for Barnes and Noble ebooks"))
self.bandn_button.setText(u"Barnes and Noble ebooks")
self.bandn_button.clicked.connect(self.bandn_keys)
self.kindle_android_button = QtGui.QPushButton(self)
self.kindle_android_button.setToolTip(_(u"Click to manage keys for Kindle for Android ebooks"))
self.kindle_android_button.setText(u"Kindle for Android ebooks")
self.kindle_android_button.clicked.connect(self.kindle_android)
self.kindle_serial_button = QtGui.QPushButton(self)
self.kindle_serial_button.setToolTip(_(u"Click to manage eInk Kindle serial numbers for Kindle ebooks"))
self.kindle_serial_button.setText(u"eInk Kindle ebooks")
self.kindle_serial_button.clicked.connect(self.kindle_serials)
self.kindle_key_button = QtGui.QPushButton(self)
self.kindle_key_button.setToolTip(_(u"Click to manage keys for Kindle for Mac/PC ebooks"))
self.kindle_key_button.setText(u"Kindle for Mac/PC ebooks")
self.kindle_key_button.clicked.connect(self.kindle_keys)
self.adept_button = QtGui.QPushButton(self)
self.adept_button.setToolTip(_(u"Click to manage keys for Adobe Digital Editions ebooks"))
self.adept_button.setText(u"Adobe Digital Editions ebooks")
self.adept_button.clicked.connect(self.adept_keys)
self.mobi_button = QtGui.QPushButton(self)
self.mobi_button.setToolTip(_(u"Click to manage PIDs for Mobipocket ebooks"))
self.mobi_button.setText(u"Mobipocket ebooks")
self.mobi_button.clicked.connect(self.mobi_keys)
self.ereader_button = QtGui.QPushButton(self)
self.ereader_button.setToolTip(_(u"Click to manage keys for eReader ebooks"))
self.ereader_button.setText(u"eReader ebooks")
self.ereader_button.clicked.connect(self.ereader_keys)
button_layout.addWidget(self.kindle_serial_button)
button_layout.addWidget(self.kindle_android_button)
button_layout.addWidget(self.bandn_button)
button_layout.addWidget(self.mobi_button)
button_layout.addWidget(self.ereader_button)
button_layout.addWidget(self.adept_button)
button_layout.addWidget(self.kindle_key_button)
self.resize(self.sizeHint())
def __init__(self, parent, key_type_name, plugin_keys, create_key, keyfile_ext = u"", wineprefix = None):
QDialog.__init__(self,parent)
self.parent = parent
self.key_type_name = key_type_name
self.plugin_keys = plugin_keys
self.create_key = create_key
self.keyfile_ext = keyfile_ext
self.import_key = (keyfile_ext != u"")
self.binary_file = (keyfile_ext == u"der")
self.json_file = (keyfile_ext == u"k4i")
self.android_file = (keyfile_ext == u"k4a")
self.wineprefix = wineprefix
self.setWindowTitle("{0} {1}: Manage {2}s".format(PLUGIN_NAME, PLUGIN_VERSION, self.key_type_name))
# Start Qt Gui dialog layout
layout = QVBoxLayout(self)
self.setLayout(layout)
help_layout = QHBoxLayout()
layout.addLayout(help_layout)
# Add hyperlink to a help file at the right. We will replace the correct name when it is clicked.
help_label = QLabel('<a href="http://www.foo.com/">Help</a>', self)
help_label.setTextInteractionFlags(Qt.LinksAccessibleByMouse | Qt.LinksAccessibleByKeyboard)
help_label.setAlignment(Qt.AlignRight)
help_label.linkActivated.connect(self.help_link_activated)
help_layout.addWidget(help_label)
keys_group_box = QGroupBox(_(u"{0}s".format(self.key_type_name)), self)
layout.addWidget(keys_group_box)
keys_group_box_layout = QHBoxLayout()
keys_group_box.setLayout(keys_group_box_layout)
self.listy = QListWidget(self)
self.listy.setToolTip(u"{0}s that will be used to decrypt ebooks".format(self.key_type_name))
self.listy.setSelectionMode(QAbstractItemView.SingleSelection)
self.populate_list()
keys_group_box_layout.addWidget(self.listy)
button_layout = QVBoxLayout()
keys_group_box_layout.addLayout(button_layout)
self._add_key_button = QtGui.QToolButton(self)
self._add_key_button.setIcon(QIcon(I('plus.png')))
self._add_key_button.setToolTip(u"Create new {0}".format(self.key_type_name))
self._add_key_button.clicked.connect(self.add_key)
button_layout.addWidget(self._add_key_button)
self._delete_key_button = QtGui.QToolButton(self)
self._delete_key_button.setToolTip(_(u"Delete highlighted key"))
self._delete_key_button.setIcon(QIcon(I('list_remove.png')))
self._delete_key_button.clicked.connect(self.delete_key)
button_layout.addWidget(self._delete_key_button)
if type(self.plugin_keys) == dict and self.import_key:
self._rename_key_button = QtGui.QToolButton(self)
self._rename_key_button.setToolTip(_(u"Rename highlighted key"))
self._rename_key_button.setIcon(QIcon(I('edit-select-all.png')))
self._rename_key_button.clicked.connect(self.rename_key)
button_layout.addWidget(self._rename_key_button)
self.export_key_button = QtGui.QToolButton(self)
self.export_key_button.setToolTip(u"Save highlighted key to a .{0} file".format(self.keyfile_ext))
self.export_key_button.setIcon(QIcon(I('save.png')))
self.export_key_button.clicked.connect(self.export_key)
button_layout.addWidget(self.export_key_button)
spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
button_layout.addItem(spacerItem)
if self.wineprefix is not None:
layout.addSpacing(5)
wineprefix_layout = QHBoxLayout()
layout.addLayout(wineprefix_layout)
wineprefix_layout.setAlignment(Qt.AlignCenter)
self.wp_label = QLabel(u"WINEPREFIX:")
wineprefix_layout.addWidget(self.wp_label)
self.wp_lineedit = QLineEdit(self)
wineprefix_layout.addWidget(self.wp_lineedit)
self.wp_label.setBuddy(self.wp_lineedit)
self.wp_lineedit.setText(self.wineprefix)
layout.addSpacing(5)
migrate_layout = QHBoxLayout()
layout.addLayout(migrate_layout)
if self.import_key:
migrate_layout.setAlignment(Qt.AlignJustify)
self.migrate_btn = QPushButton(u"Import Existing Keyfiles", self)
self.migrate_btn.setToolTip(u"Import *.{0} files (created using other tools).".format(self.keyfile_ext))
self.migrate_btn.clicked.connect(self.migrate_wrapper)
migrate_layout.addWidget(self.migrate_btn)
migrate_layout.addStretch()
self.button_box = QDialogButtonBox(QDialogButtonBox.Close)
self.button_box.rejected.connect(self.close)
migrate_layout.addWidget(self.button_box)
self.resize(self.sizeHint())
def do_layout(self):
self.central_widget.clear()
self.labels = []
sto = QWidget.setTabOrder
self.central_widget.tabBar().setVisible(False)
tab0 = QWidget(self)
self.central_widget.addTab(tab0, _("&Metadata"))
l = QGridLayout()
tab0.setLayout(l)
# Basic metadata in col 0
tl = QGridLayout()
gb = QGroupBox(_('Basic metadata'), tab0)
l.addWidget(gb, 0, 0, 1, 1)
gb.setLayout(tl)
self.button_box_layout.insertWidget(1, self.fetch_metadata_button)
self.button_box_layout.insertWidget(2, self.config_metadata_button)
sto(self.button_box, self.fetch_metadata_button)
sto(self.fetch_metadata_button, self.config_metadata_button)
sto(self.config_metadata_button, self.title)
def create_row(row, widget, tab_to, button=None, icon=None, span=1):
ql = BuddyLabel(widget)
tl.addWidget(ql, row, 1, 1, 1)
tl.addWidget(widget, row, 2, 1, 1)
if button is not None:
tl.addWidget(button, row, 3, span, 1)
if icon is not None:
button.setIcon(QIcon(I(icon)))
if tab_to is not None:
if button is not None:
sto(widget, button)
sto(button, tab_to)
else:
sto(widget, tab_to)
tl.addWidget(self.swap_title_author_button, 0, 0, 2, 1)
tl.addWidget(self.manage_authors_button, 2, 0, 2, 1)
tl.addWidget(self.paste_isbn_button, 12, 0, 1, 1)
tl.addWidget(self.tags_editor_button, 6, 0, 1, 1)
create_row(0, self.title, self.title_sort,
button=self.deduce_title_sort_button, span=2,
icon='auto_author_sort.png')
create_row(1, self.title_sort, self.authors)
create_row(2, self.authors, self.author_sort,
button=self.deduce_author_sort_button,
span=2, icon='auto_author_sort.png')
create_row(3, self.author_sort, self.series)
create_row(4, self.series, self.series_index,
button=self.clear_series_button, icon='trash.png')
create_row(5, self.series_index, self.tags)
create_row(6, self.tags, self.rating, button=self.clear_tags_button)
create_row(7, self.rating, self.pubdate, button=self.clear_ratings_button)
create_row(8, self.pubdate, self.publisher,
button=self.pubdate.clear_button, icon='trash.png')
create_row(9, self.publisher, self.languages,
button=self.publisher.clear_button, icon='trash.png')
create_row(10, self.languages, self.timestamp)
create_row(11, self.timestamp, self.identifiers,
button=self.timestamp.clear_button, icon='trash.png')
create_row(12, self.identifiers, self.comments,
button=self.clear_identifiers_button, icon='trash.png')
sto(self.clear_identifiers_button, self.swap_title_author_button)
sto(self.swap_title_author_button, self.manage_authors_button)
sto(self.manage_authors_button, self.tags_editor_button)
sto(self.tags_editor_button, self.paste_isbn_button)
tl.addItem(QSpacerItem(1, 1, QSizePolicy.Fixed, QSizePolicy.Expanding),
13, 1, 1 ,1)
# Custom metadata in col 1
w = getattr(self, 'custom_metadata_widgets_parent', None)
if w is not None:
gb = QGroupBox(_('Custom metadata'), tab0)
gbl = QVBoxLayout()
gb.setLayout(gbl)
sr = QScrollArea(gb)
sr.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
sr.setWidgetResizable(True)
sr.setFrameStyle(QFrame.NoFrame)
sr.setWidget(w)
gbl.addWidget(sr)
l.addWidget(gb, 0, 1, 1, 1)
sp = QSizePolicy()
sp.setVerticalStretch(10)
sp.setHorizontalPolicy(QSizePolicy.Minimum)
sp.setVerticalPolicy(QSizePolicy.Expanding)
gb.setSizePolicy(sp)
self.set_custom_metadata_tab_order()
# comments span col 0 & 1
w = QGroupBox(_('Comments'), tab0)
sp = QSizePolicy()
sp.setVerticalStretch(10)
sp.setHorizontalPolicy(QSizePolicy.Expanding)
sp.setVerticalPolicy(QSizePolicy.Expanding)
w.setSizePolicy(sp)
lb = QHBoxLayout()
w.setLayout(lb)
lb.addWidget(self.comments)
l.addWidget(w, 1, 0, 1, 2)
# Cover & formats in col 3
gb = QGroupBox(_('Cover'), tab0)
lb = QGridLayout()
gb.setLayout(lb)
lb.addWidget(self.cover, 0, 0, 1, 3, alignment=Qt.AlignCenter)
sto(self.manage_authors_button, self.cover.buttons[0])
for i, b in enumerate(self.cover.buttons[:3]):
lb.addWidget(b, 1, i, 1, 1)
sto(b, self.cover.buttons[i+1])
hl = QHBoxLayout()
for b in self.cover.buttons[3:]:
hl.addWidget(b)
sto(self.cover.buttons[-2], self.cover.buttons[-1])
lb.addLayout(hl, 2, 0, 1, 3)
l.addWidget(gb, 0, 2, 1, 1)
l.addWidget(self.formats_manager, 1, 2, 1, 1)
sto(self.cover.buttons[-1], self.formats_manager)
self.formats_manager.formats.setMaximumWidth(10000)
self.formats_manager.formats.setIconSize(QSize(32, 32))
class EKWindow(QDialog):
"""
Class which is responisble for running this entire application
"""
def __init__(self):
"""
Constructor for this class
"""
super(EKWindow, self).__init__()
self.engine = Engine("tables/Tamil-bamini.txt.in")
# Settings file initialization
self.settingsFilePath = os.getenv("APPDATA") + "\\" + qApp.applicationName() + "\eksettings.ini"
self.init_settings() # Function to check whether the settings file is or not.
self.iniSettings = QSettings(self.settingsFilePath, QSettings.IniFormat)
# Variable Initialization
self.registrySettings = QSettings("HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run", QSettings.NativeFormat)
self.shortcutModifierKey = self.iniSettings.value("shortcut_modifier")
self.shortcutKey = self.iniSettings.value("shortcut")
self.selectedKeyboard = self.iniSettings.value("selected_keyboard")
self.keyboardStatus = False
self.fileName = ""
# Ui variable Initialization
self.iconGroupBox = QGroupBox("Keyboards")
self.iconLabel = QLabel("Keyboard:")
self.iconComboBox = QComboBox(self)
self.shortcutGroupBox = QGroupBox("Shortcut Setting")
self.shortcutComboBox1 = QComboBox(self)
self.shortcutComboBox2 = QComboBox(self)
self.otherSettingsGroupBox = QGroupBox("Other Settings")
self.checkboxStartWithWindows = QCheckBox()
self.minimizeAction = QAction("Minimize", self)
self.maximizeAction = QAction("Maximize", self)
self.settingsAction = QAction("Settings", self)
self.aboutAction = QAction("About", self)
self.quitAction = QAction("Quit", self)
self.trayIconMenu = QMenu(self)
self.trayIcon = QSystemTrayIcon(self)
self.mainLayout = QVBoxLayout()
self.mainLayout.addWidget(self.iconGroupBox)
self.mainLayout.addWidget(self.shortcutGroupBox)
self.mainLayout.addWidget(self.otherSettingsGroupBox)
self.setLayout(self.mainLayout)
# UI constructor and connectors
self.create_settings_group_boxes()
self.create_actions()
self.create_tray_icon()
# Signal connectors
self.iconComboBox.currentIndexChanged.connect(self.change_keyboard)
self.shortcutComboBox1.currentIndexChanged.connect(self.set_shortcut_modifier)
self.shortcutComboBox2.currentIndexChanged.connect(self.set_shortcut_key)
self.trayIcon.activated.connect(self.icon_activated)
self.checkboxStartWithWindows.stateChanged.connect(self.checkbox_start_with_windows_ticked)
if self.keyboardStatus:
self.iconComboBox.setCurrentIndex(self.selectedKeyBoard)
else:
self.change_keyboard(0)
self.iconComboBox.setCurrentIndex(0)
self.trayIcon.show()
self.set_shortcut_key()
self.setWindowTitle(qApp.applicationName() + " " + qApp.applicationVersion())
def init_settings(self):
"""
Function to check whether the settings file is there or not. If there is no file, then it will create with
default settings.
"""
if not os.path.exists(self.settingsFilePath):
settings_dir = os.getenv("APPDATA") + "\\" + qApp.applicationName()
if not os.path.exists(settings_dir):
os.makedirs(settings_dir)
setting_path = ""
if getattr(sys, 'frozen', False):
setting_path = os.path.dirname(sys.executable)
elif __file__:
setting_path = os.path.dirname(__file__)
shutil.copyfile(os.path.join(setting_path, "resources\eksettings.ini"), self.settingsFilePath)
return
def create_settings_group_boxes(self):
"""
UI generator function.
"""
self.iconComboBox.addItem("No Keyboard")
self.iconComboBox.addItem("Tamil99")
self.iconComboBox.addItem("Phonetic")
self.iconComboBox.addItem("Typewriter")
self.iconComboBox.addItem("Bamini")
self.iconComboBox.addItem("Inscript")
icon_layout = QHBoxLayout(self)
icon_layout.addWidget(self.iconLabel)
icon_layout.addWidget(self.iconComboBox)
icon_layout.addStretch()
self.iconGroupBox.setLayout(icon_layout)
shortcut_label_1 = QLabel("Modifier Key:")
shortcut_label_2 = QLabel("Shortcut Key:")
self.shortcutComboBox1.addItem("NONE")
self.shortcutComboBox1.addItem("CTRL")
self.shortcutComboBox1.addItem("ALT")
modifier_index = self.shortcutComboBox1.findText(self.shortcutModifierKey)
self.shortcutComboBox1.setCurrentIndex(modifier_index)
self.shortcutComboBox2.setMinimumContentsLength(3)
if modifier_index == 0:
self.shortcutComboBox2.addItem("F1")
self.shortcutComboBox2.addItem("ESC")
self.shortcutComboBox2.addItem("F2")
self.shortcutComboBox2.addItem("F3")
self.shortcutComboBox2.addItem("F4")
self.shortcutComboBox2.addItem("F5")
self.shortcutComboBox2.addItem("F6")
self.shortcutComboBox2.addItem("F7")
self.shortcutComboBox2.addItem("F8")
self.shortcutComboBox2.addItem("F9")
self.shortcutComboBox2.addItem("F10")
else:
self.shortcutComboBox2.addItem("1")
self.shortcutComboBox2.addItem("2")
self.shortcutComboBox2.addItem("3")
self.shortcutComboBox2.addItem("4")
self.shortcutComboBox2.addItem("5")
self.shortcutComboBox2.addItem("6")
self.shortcutComboBox2.addItem("7")
self.shortcutComboBox2.addItem("8")
self.shortcutComboBox2.addItem("9")
self.shortcutComboBox2.addItem("0")
key_index = self.shortcutComboBox2.findText(self.shortcutKey)
self.shortcutComboBox2.setCurrentIndex(key_index)
shortcut_layout = QHBoxLayout(self)
shortcut_layout.addWidget(shortcut_label_1)
shortcut_layout.addWidget(self.shortcutComboBox1)
shortcut_layout.addWidget(shortcut_label_2)
shortcut_layout.addWidget(self.shortcutComboBox2)
shortcut_layout.addStretch()
self.shortcutGroupBox.setLayout(shortcut_layout)
checkbox_start_with_windows_label = QLabel("Start eKalappai whenever windows starts")
# if registry entry for auto start with windows for the current user exists, then check the checkbox
if self.registrySettings.contains(qApp.applicationName()):
self.checkboxStartWithWindows.setChecked(True)
else:
self.checkboxStartWithWindows.setChecked(False)
other_settings_layout = QHBoxLayout(self)
other_settings_layout.addWidget(checkbox_start_with_windows_label)
other_settings_layout.addWidget(self.checkboxStartWithWindows)
other_settings_layout.addStretch()
self.otherSettingsGroupBox.setLayout(other_settings_layout)
def set_shortcut_key(self):
"""
Function to change the shortcut key when its changed.
"""
self.shortcutKey = self.shortcutComboBox2.currentText()
self.iniSettings.setValue("shortcut", self.shortcutKey)
self.register_shortcut_listener()
if self.shortcutKey == "ESC":
self.shortcutKeyHex = 0x1B
elif self.shortcutKey == "F1":
self.shortcutKeyHex = 0x70
elif self.shortcutKey == "F2":
self.shortcutKeyHex = 0x71
elif self.shortcutKey == "F3":
self.shortcutKeyHex = 0x72
elif self.shortcutKey == "F4":
self.shortcutKeyHex = 0x73
elif self.shortcutKey == "F5":
self.shortcutKeyHex = 0x74
elif self.shortcutKey == "F6":
self.shortcutKeyHex = 0x75
elif self.shortcutKey == "F7":
self.shortcutKeyHex = 0x76
elif self.shortcutKey == "F8":
self.shortcutKeyHex = 0x77
elif self.shortcutKey == "F9":
self.shortcutKeyHex = 0x78
elif self.shortcutKey == "F10":
self.shortcutKeyHex = 0x79
elif self.shortcutKey == "1":
self.shortcutKeyHex = 0x31
elif self.shortcutKey == "2":
self.shortcutKeyHex = 0x32
elif self.shortcutKey == "3":
self.shortcutKeyHex = 0x33
elif self.shortcutKey == "4":
self.shortcutKeyHex = 0x34
elif self.shortcutKey == "5":
self.shortcutKeyHex = 0x35
elif self.shortcutKey == "6":
self.shortcutKeyHex = 0x36
elif self.shortcutKey == "7":
self.shortcutKeyHex = 0x37
elif self.shortcutKey == "8":
self.shortcutKeyHex = 0x38
elif self.shortcutKey == "9":
self.shortcutKeyHex = 0x39
elif self.shortcutKey == "0":
self.shortcutKeyHex = 0x30
def create_actions(self):
"""
Slot connectors for all right clicking and other actions.
"""
self.minimizeAction.triggered.connect(self.hide)
self.maximizeAction.triggered.connect(self.showMaximized)
self.settingsAction.triggered.connect(self.showNormal)
self.aboutAction.triggered.connect(self.show_about)
self.quitAction.triggered.connect(self.quit)
def quit(self):
self.engine.un_hook()
exit(0)
def create_tray_icon(self):
"""
Tray icon creator and corresponding connectors
"""
self.trayIconMenu.addAction(self.settingsAction)
self.trayIconMenu.addSeparator()
self.trayIconMenu.addAction(self.aboutAction)
self.trayIconMenu.addSeparator()
self.trayIconMenu.addAction(self.quitAction)
self.trayIcon.setContextMenu(self.trayIconMenu)
def setVisible(self, visible):
self.settingsAction.setEnabled(self.isMaximized() or not visible)
super(EKWindow, self).setVisible(visible)
def closeEvent(self, event):
if self.trayIcon.isVisible():
self.hide()
event.ignore()
def load_keyboard(self):
"""
Mapping file loading function
"""
if self.selectedKeyboard == 1:
self.fileName = "tables/Tamil-tamil99.txt.in"
elif self.selectedKeyboard == 2:
self.fileName = "tables/Tamil-phonetic.txt.in"
elif self.selectedKeyboard == 3:
self.fileName = "tables/Tamil-typewriter.txt.in"
elif self.selectedKeyboard == 4:
self.fileName = "tables/Tamil-bamini.txt.in"
elif self.selectedKeyboard == 5:
self.fileName = "tables/Tamil-inscript.txt.in"
else:
pass
def getPath(self, index):
if index == 1:
self.path = "tables/Tamil-tamil99.txt.in"
elif index == 2:
self.path = "tables/Tamil-phonetic.txt.in"
elif index == 3:
self.path = "tables/Tamil-typewriter.txt.in"
elif index == 4:
self.path = "tables/Tamil-bamini.txt.in"
elif index == 5:
self.path = "tables/Tamil-inscript.txt.in"
else:
pass
def change_keyboard(self, index):
"""
Function to change the keyboard based on the index which was sent as a param
"""
if int(index) != 0:
self.iniSettings.setValue("selected_keyboard", index)
self.selectedKeyboard = index
self.iconComboBox.setCurrentIndex(int(index))
icon = self.iconComboBox.itemIcon(int(index))
self.trayIcon.setIcon(icon)
self.setWindowIcon(icon)
self.trayIcon.setToolTip(self.iconComboBox.itemText(int(index)))
self.show_tray_message(index)
self.load_keyboard()
if int(index) != 0:
self.getPath(int(index))
self.engine.file_name = self.path
self.engine.initialize()
self.engine.conv_state = True
else:
try:
self.engine.conv_state = False
except:
pass
def icon_activated(self, reason):
"""
Function to toggle the state when the icon is clicked or shortcut key is pressed
"""
if reason == QSystemTrayIcon.DoubleClick:
pass
elif reason == QSystemTrayIcon.Trigger:
if self.keyboardStatus:
self.keyboardStatus = False
else:
self.keyboardStatus = True
if self.keyboardStatus:
self.change_keyboard(self.selectedKeyboard)
else:
self.change_keyboard(0)
elif reason == QSystemTrayIcon.MiddleClick:
pass
else:
pass
def show_tray_message(self, index):
"""
Tray message generator when there is change in keyboard state
"""
icon = QSystemTrayIcon.MessageIcon(0)
message = self.iconComboBox.itemText(int(index)) + " set"
self.trayIcon.showMessage(qApp.applicationName() + " " + qApp.applicationVersion(), message, icon, 100)
def checkbox_start_with_windows_ticked(self):
"""
Function to add or disable registry entry to auto start ekalappai with windows for the current users
"""
if self.checkboxStartWithWindows.isChecked():
self.registrySettings.setValue(qApp.applicationName(), qApp.applicationFilePath())
else:
self.registrySettings.remove(qApp.applicationName())
def show_about(self):
pass
def set_shortcut_modifier(self, index):
"""
Function to set the shortcut modifier when its changed.
"""
self.iniSettings.setValue("shortcut_modifier", self.shortcutComboBox1.currentText())
self.shortcutModifierKey = self.iniSettings.value("shortcut_modifier")
# if none is selected, the allowed single key shortcuts should change
if index == 0:
self.shortcutComboBox2.clear()
self.shortcutComboBox2.addItem("ESC")
self.shortcutComboBox2.addItem("F1")
self.shortcutComboBox2.addItem("F2")
self.shortcutComboBox2.addItem("F3")
self.shortcutComboBox2.addItem("F4")
self.shortcutComboBox2.addItem("F5")
self.shortcutComboBox2.addItem("F6")
self.shortcutComboBox2.addItem("F7")
self.shortcutComboBox2.addItem("F8")
self.shortcutComboBox2.addItem("F9")
self.shortcutComboBox2.addItem("F10")
else:
self.shortcutComboBox2.clear()
self.shortcutComboBox2.addItem("1")
self.shortcutComboBox2.addItem("2")
self.shortcutComboBox2.addItem("3")
self.shortcutComboBox2.addItem("4")
self.shortcutComboBox2.addItem("5")
self.shortcutComboBox2.addItem("6")
self.shortcutComboBox2.addItem("7")
self.shortcutComboBox2.addItem("8")
self.shortcutComboBox2.addItem("9")
self.shortcutComboBox2.addItem("0")
self.register_shortcut_listener()
def register_shortcut_listener(self):
self.engine.event_queue.remove_all()
if self.iniSettings.value("shortcut_modifier") == "NONE":
self.engine.event_queue.register_event([[self.shortcutKey], self.icon_activated, QSystemTrayIcon.Trigger])
elif self.iniSettings.value("shortcut_modifier") == "CTRL":
self.engine.event_queue.register_event([['Lcontrol', self.shortcutKey], self.icon_activated, QSystemTrayIcon.Trigger])
self.engine.event_queue.register_event([['Rcontrol', self.shortcutKey], self.icon_activated, QSystemTrayIcon.Trigger])
elif self.iniSettings.value("shortcut_modifier") == "ALT":
self.engine.event_queue.register_event([['LMenu', self.shortcutKey], self.icon_activated, QSystemTrayIcon.Trigger])
self.engine.event_queue.register_event([['RMenu', self.shortcutKey], self.icon_activated, QSystemTrayIcon.Trigger])
return True
class ConfigWidget(QWidget):
def __init__(self, plugin):
QWidget.__init__(self)
self.plugin = plugin
self.l = l = QGridLayout()
self.setLayout(l)
self.gb = QGroupBox(_('Downloaded metadata fields'), self)
if plugin.config_help_message:
self.pchm = QLabel(plugin.config_help_message)
self.pchm.setWordWrap(True)
self.pchm.setOpenExternalLinks(True)
l.addWidget(self.pchm, 0, 0, 1, 2)
l.addWidget(self.gb, l.rowCount(), 0, 1, 2)
self.gb.l = QGridLayout()
self.gb.setLayout(self.gb.l)
self.fields_view = v = QListView(self)
self.gb.l.addWidget(v, 0, 0)
v.setFlow(v.LeftToRight)
v.setWrapping(True)
v.setResizeMode(v.Adjust)
self.fields_model = FieldsModel(self.plugin)
self.fields_model.initialize()
v.setModel(self.fields_model)
self.memory = []
self.widgets = []
for opt in plugin.options:
self.create_widgets(opt)
def create_widgets(self, opt):
val = self.plugin.prefs[opt.name]
if opt.type == 'number':
c = QSpinBox if isinstance(opt.default, int) else QDoubleSpinBox
widget = c(self)
widget.setValue(val)
elif opt.type == 'string':
widget = QLineEdit(self)
widget.setText(val if val else '')
elif opt.type == 'bool':
widget = QCheckBox(opt.label, self)
widget.setChecked(bool(val))
elif opt.type == 'choices':
widget = QComboBox(self)
items = list(opt.choices.iteritems())
items.sort(key=lambda (k, v): sort_key(v))
for key, label in items:
widget.addItem(label, (key))
idx = widget.findData((val))
widget.setCurrentIndex(idx)
widget.opt = opt
widget.setToolTip(textwrap.fill(opt.desc))
self.widgets.append(widget)
r = self.l.rowCount()
if opt.type == 'bool':
self.l.addWidget(widget, r, 0, 1, self.l.columnCount())
else:
l = QLabel(opt.label)
l.setToolTip(widget.toolTip())
self.memory.append(l)
l.setBuddy(widget)
self.l.addWidget(l, r, 0, 1, 1)
self.l.addWidget(widget, r, 1, 1, 1)
def commit(self):
self.fields_model.commit()
for w in self.widgets:
if isinstance(w, (QSpinBox, QDoubleSpinBox)):
val = w.value()
elif isinstance(w, QLineEdit):
val = unicode(w.text())
elif isinstance(w, QCheckBox):
val = w.isChecked()
elif isinstance(w, QComboBox):
idx = w.currentIndex()
val = unicode(w.itemData(idx) or '')
self.plugin.prefs[w.opt.name] = val
def do_layout(self):
self.central_widget.clear()
self.tabs = []
self.labels = []
sto = QWidget.setTabOrder
self.on_drag_enter.connect(self.handle_drag_enter)
self.tabs.append(DragTrackingWidget(self, self.on_drag_enter))
self.central_widget.addTab(self.tabs[0], _("&Metadata"))
self.tabs[0].l = QGridLayout()
self.tabs[0].setLayout(self.tabs[0].l)
self.tabs.append(QWidget(self))
self.central_widget.addTab(self.tabs[1], _("&Cover and formats"))
self.tabs[1].l = QGridLayout()
self.tabs[1].setLayout(self.tabs[1].l)
# accept drop events so we can automatically switch to the second tab to
# drop covers and formats
self.tabs[0].setAcceptDrops(True)
# Tab 0
tab0 = self.tabs[0]
tl = QGridLayout()
gb = QGroupBox(_('&Basic metadata'), self.tabs[0])
self.tabs[0].l.addWidget(gb, 0, 0, 1, 1)
gb.setLayout(tl)
self.button_box_layout.insertWidget(1, self.fetch_metadata_button)
self.button_box_layout.insertWidget(2, self.config_metadata_button)
sto(self.button_box, self.fetch_metadata_button)
sto(self.fetch_metadata_button, self.config_metadata_button)
sto(self.config_metadata_button, self.title)
def create_row(row, widget, tab_to, button=None, icon=None, span=1):
ql = BuddyLabel(widget)
tl.addWidget(ql, row, 1, 1, 1)
tl.addWidget(widget, row, 2, 1, 1)
if button is not None:
tl.addWidget(button, row, 3, span, 1)
if icon is not None:
button.setIcon(QIcon(I(icon)))
if tab_to is not None:
if button is not None:
sto(widget, button)
sto(button, tab_to)
else:
sto(widget, tab_to)
tl.addWidget(self.swap_title_author_button, 0, 0, 2, 1)
tl.addWidget(self.manage_authors_button, 2, 0, 1, 1)
tl.addWidget(self.paste_isbn_button, 12, 0, 1, 1)
tl.addWidget(self.tags_editor_button, 6, 0, 1, 1)
create_row(0, self.title, self.title_sort,
button=self.deduce_title_sort_button, span=2,
icon='auto_author_sort.png')
create_row(1, self.title_sort, self.authors)
create_row(2, self.authors, self.author_sort,
button=self.deduce_author_sort_button,
span=2, icon='auto_author_sort.png')
create_row(3, self.author_sort, self.series)
create_row(4, self.series, self.series_index,
button=self.clear_series_button, icon='trash.png')
create_row(5, self.series_index, self.tags)
create_row(6, self.tags, self.rating, button=self.clear_tags_button)
create_row(7, self.rating, self.pubdate, button=self.clear_ratings_button)
create_row(8, self.pubdate, self.publisher,
button=self.pubdate.clear_button, icon='trash.png')
create_row(9, self.publisher, self.languages, button=self.publisher.clear_button, icon='trash.png')
create_row(10, self.languages, self.timestamp)
create_row(11, self.timestamp, self.identifiers,
button=self.timestamp.clear_button, icon='trash.png')
create_row(12, self.identifiers, self.comments,
button=self.clear_identifiers_button, icon='trash.png')
sto(self.clear_identifiers_button, self.swap_title_author_button)
sto(self.swap_title_author_button, self.manage_authors_button)
sto(self.manage_authors_button, self.tags_editor_button)
sto(self.tags_editor_button, self.paste_isbn_button)
tl.addItem(QSpacerItem(1, 1, QSizePolicy.Fixed, QSizePolicy.Expanding),
13, 1, 1 ,1)
w = getattr(self, 'custom_metadata_widgets_parent', None)
if w is not None:
gb = QGroupBox(_('C&ustom metadata'), tab0)
gbl = QVBoxLayout()
gb.setLayout(gbl)
sr = QScrollArea(tab0)
sr.setWidgetResizable(True)
sr.setFrameStyle(QFrame.NoFrame)
sr.setWidget(w)
gbl.addWidget(sr)
self.tabs[0].l.addWidget(gb, 0, 1, 1, 1)
sto(self.identifiers, gb)
w = QGroupBox(_('&Comments'), tab0)
sp = QSizePolicy()
sp.setVerticalStretch(10)
sp.setHorizontalPolicy(QSizePolicy.Expanding)
sp.setVerticalPolicy(QSizePolicy.Expanding)
w.setSizePolicy(sp)
l = QHBoxLayout()
w.setLayout(l)
l.addWidget(self.comments)
tab0.l.addWidget(w, 1, 0, 1, 2)
# Tab 1
tab1 = self.tabs[1]
wsp = QWidget(tab1)
wgl = QVBoxLayout()
wsp.setLayout(wgl)
# right-hand side of splitter
gb = QGroupBox(_('Change cover'), tab1)
l = QGridLayout()
gb.setLayout(l)
for i, b in enumerate(self.cover.buttons[:3]):
l.addWidget(b, 0, i, 1, 1)
sto(b, self.cover.buttons[i+1])
hl = QHBoxLayout()
for b in self.cover.buttons[3:]:
hl.addWidget(b)
sto(self.cover.buttons[-2], self.cover.buttons[-1])
l.addLayout(hl, 1, 0, 1, 3)
wgl.addWidget(gb)
wgl.addItem(QSpacerItem(10, 10, QSizePolicy.Expanding,
QSizePolicy.Expanding))
wgl.addItem(QSpacerItem(10, 10, QSizePolicy.Expanding,
QSizePolicy.Expanding))
wgl.addWidget(self.formats_manager)
self.splitter = QSplitter(Qt.Horizontal, tab1)
tab1.l.addWidget(self.splitter)
self.splitter.addWidget(self.cover)
self.splitter.addWidget(wsp)
self.formats_manager.formats.setMaximumWidth(10000)
self.formats_manager.formats.setIconSize(QSize(64, 64))
class UnpackBook(QDialog):
def __init__(self, parent, book_id, fmts, db):
QDialog.__init__(self, parent)
self.setWindowIcon(QIcon(I('unpack-book.png')))
self.book_id, self.fmts, self.db_ref = book_id, fmts, weakref.ref(db)
self._exploded = None
self._cleanup_dirs = []
self._cleanup_files = []
self.setup_ui()
self.setWindowTitle(_('Unpack Book') + ' - ' + db.title(book_id,
index_is_id=True))
button = self.fmt_choice_buttons[0]
button_map = {unicode(x.text()):x for x in self.fmt_choice_buttons}
of = prefs['output_format'].upper()
df = tweaks.get('default_tweak_format', None)
lf = gprefs.get('last_tweak_format', None)
if df and df.lower() == 'remember' and lf in button_map:
button = button_map[lf]
elif df and df.upper() in button_map:
button = button_map[df.upper()]
elif of in button_map:
button = button_map[of]
button.setChecked(True)
self.init_state()
for button in self.fmt_choice_buttons:
button.toggled.connect(self.init_state)
def init_state(self, *args):
self._exploded = None
self.preview_button.setEnabled(False)
self.rebuild_button.setEnabled(False)
self.explode_button.setEnabled(True)
def setup_ui(self): # {{{
self._g = g = QHBoxLayout(self)
self.setLayout(g)
self._l = l = QVBoxLayout()
g.addLayout(l)
fmts = sorted(x.upper() for x in self.fmts)
self.fmt_choice_box = QGroupBox(_('Choose the format to unpack:'), self)
self._fl = fl = QHBoxLayout()
self.fmt_choice_box.setLayout(self._fl)
self.fmt_choice_buttons = [QRadioButton(y, self) for y in fmts]
for x in self.fmt_choice_buttons:
fl.addWidget(x, stretch=10 if x is self.fmt_choice_buttons[-1] else
0)
l.addWidget(self.fmt_choice_box)
self.fmt_choice_box.setVisible(len(fmts) > 1)
self.help_label = QLabel(_('''\
<h2>About Unpack Book</h2>
<p>Unpack Book allows you to fine tune the appearance of an ebook by
making small changes to its internals. In order to use Unpack Book,
you need to know a little bit about HTML and CSS, technologies that
are used in ebooks. Follow the steps:</p>
<br>
<ol>
<li>Click "Explode Book": This will "explode" the book into its
individual internal components.<br></li>
<li>Right click on any individual file and select "Open with..." to
edit it in your favorite text editor.<br></li>
<li>When you are done: <b>close the file browser window
and the editor windows you used to make your tweaks</b>. Then click
the "Rebuild Book" button, to update the book in your calibre
library.</li>
</ol>'''))
self.help_label.setWordWrap(True)
self._fr = QFrame()
self._fr.setFrameShape(QFrame.VLine)
g.addWidget(self._fr)
g.addWidget(self.help_label)
self._b = b = QGridLayout()
left, top, right, bottom = b.getContentsMargins()
top += top
b.setContentsMargins(left, top, right, bottom)
l.addLayout(b, stretch=10)
self.explode_button = QPushButton(QIcon(I('wizard.png')), _('&Explode Book'))
self.preview_button = QPushButton(QIcon(I('view.png')), _('&Preview Book'))
self.cancel_button = QPushButton(QIcon(I('window-close.png')), _('&Cancel'))
self.rebuild_button = QPushButton(QIcon(I('exec.png')), _('&Rebuild Book'))
self.explode_button.setToolTip(
_('Explode the book to edit its components'))
self.preview_button.setToolTip(
_('Preview the result of your changes'))
self.cancel_button.setToolTip(
_('Abort without saving any changes'))
self.rebuild_button.setToolTip(
_('Save your changes and update the book in the calibre library'))
a = b.addWidget
a(self.explode_button, 0, 0, 1, 1)
a(self.preview_button, 0, 1, 1, 1)
a(self.cancel_button, 1, 0, 1, 1)
a(self.rebuild_button, 1, 1, 1, 1)
for x in ('explode', 'preview', 'cancel', 'rebuild'):
getattr(self, x+'_button').clicked.connect(getattr(self, x))
self.msg = QLabel('dummy', self)
self.msg.setVisible(False)
self.msg.setStyleSheet('''
QLabel {
text-align: center;
background-color: white;
color: black;
border-width: 1px;
border-style: solid;
border-radius: 20px;
font-size: x-large;
font-weight: bold;
}
''')
self.resize(self.sizeHint() + QSize(40, 10))
# }}}
def show_msg(self, msg):
self.msg.setText(msg)
self.msg.resize(self.size() - QSize(50, 25))
self.msg.move((self.width() - self.msg.width())//2,
(self.height() - self.msg.height())//2)
self.msg.setVisible(True)
def hide_msg(self):
self.msg.setVisible(False)
def explode(self):
self.show_msg(_('Exploding, please wait...'))
if len(self.fmt_choice_buttons) > 1:
gprefs.set('last_tweak_format', self.current_format.upper())
QTimer.singleShot(5, self.do_explode)
def ask_question(self, msg):
return question_dialog(self, _('Are you sure?'), msg)
def do_explode(self):
from calibre.ebooks.tweak import get_tools, Error, WorkerError
tdir = PersistentTemporaryDirectory('_tweak_explode')
self._cleanup_dirs.append(tdir)
det_msg = None
try:
src = self.db.format(self.book_id, self.current_format,
index_is_id=True, as_path=True)
self._cleanup_files.append(src)
exploder = get_tools(self.current_format)[0]
opf = exploder(src, tdir, question=self.ask_question)
except WorkerError as e:
det_msg = e.orig_tb
except Error as e:
return error_dialog(self, _('Failed to unpack'),
(_('Could not explode the %s file.')%self.current_format) + ' '
+ as_unicode(e), show=True)
except:
import traceback
det_msg = traceback.format_exc()
finally:
self.hide_msg()
if det_msg is not None:
return error_dialog(self, _('Failed to unpack'),
_('Could not explode the %s file. Click "Show Details" for '
'more information.')%self.current_format, det_msg=det_msg,
show=True)
if opf is None:
# The question was answered with No
return
self._exploded = tdir
self.explode_button.setEnabled(False)
self.preview_button.setEnabled(True)
self.rebuild_button.setEnabled(True)
open_local_file(tdir)
def rebuild_it(self):
from calibre.ebooks.tweak import get_tools, WorkerError
src_dir = self._exploded
det_msg = None
of = PersistentTemporaryFile('_tweak_rebuild.'+self.current_format.lower())
of.close()
of = of.name
self._cleanup_files.append(of)
try:
rebuilder = get_tools(self.current_format)[1]
rebuilder(src_dir, of)
except WorkerError as e:
det_msg = e.orig_tb
except:
import traceback
det_msg = traceback.format_exc()
finally:
self.hide_msg()
if det_msg is not None:
error_dialog(self, _('Failed to rebuild file'),
_('Failed to rebuild %s. For more information, click '
'"Show details".')%self.current_format,
det_msg=det_msg, show=True)
return None
return of
def preview(self):
self.show_msg(_('Rebuilding, please wait...'))
QTimer.singleShot(5, self.do_preview)
def do_preview(self):
rebuilt = self.rebuild_it()
if rebuilt is not None:
self.parent().iactions['View']._view_file(rebuilt)
def rebuild(self):
self.show_msg(_('Rebuilding, please wait...'))
QTimer.singleShot(5, self.do_rebuild)
def do_rebuild(self):
rebuilt = self.rebuild_it()
if rebuilt is not None:
fmt = os.path.splitext(rebuilt)[1][1:].upper()
with open(rebuilt, 'rb') as f:
self.db.add_format(self.book_id, fmt, f, index_is_id=True)
self.accept()
def cancel(self):
self.reject()
def cleanup(self):
if isosx and self._exploded:
try:
import appscript
self.finder = appscript.app('Finder')
self.finder.Finder_windows[os.path.basename(self._exploded)].close()
except:
pass
for f in self._cleanup_files:
try:
os.remove(f)
except:
pass
for d in self._cleanup_dirs:
try:
shutil.rmtree(d)
except:
pass
@property
def db(self):
return self.db_ref()
@property
def current_format(self):
for b in self.fmt_choice_buttons:
if b.isChecked():
return unicode(b.text())
class ConfigWidget(QWidget):
# GUI definition
def __init__(self):
QWidget.__init__(self)
self.l = QVBoxLayout()
self.setLayout(self.l)
self.ll = QHBoxLayout()
self.l.addLayout(self.ll)
self.label_exe = QLabel(_('&Prince executable:'))
self.ll.addWidget(self.label_exe)
self.exe = QLineEdit(self)
self.exe.setText(prefs['prince_exe'])
self.exe.setToolTip(_('<qt>Executable for the Prince program (command-line interface)</qt>'))
self.ll.addWidget(self.exe)
self.label_exe.setBuddy(self.exe)
self.browse = QPushButton(_('&Browse') + '...', self)
self.browse.setToolTip(_('<qt>Search the Prince executable in your computer</qt>'))
self.browse.clicked.connect(self.select_exe)
self.ll.addWidget(self.browse)
self.lll = QHBoxLayout()
self.l.addLayout(self.lll)
self.label_fmts = QLabel(_('Preferred &formats:'))
self.lll.addWidget(self.label_fmts)
self.fmts = QLineEdit(self)
self.fmts.setText(','.join(prefs['formats']))
self.fmts.setToolTip(_('<qt>Comma-separated list of preferred formats to use as source, the first that matches will be used</qt>'))
self.lll.addWidget(self.fmts)
self.label_fmts.setBuddy(self.fmts)
self.add_book = QCheckBox(_('&Add PDF to the book record'))
self.add_book.setToolTip(_('<qt>Add the converted PDF to the selected book record</qt>'))
self.add_book.setChecked(prefs['add_book'])
self.l.addWidget(self.add_book)
self.show_css = QCheckBox(_('&Show CSS in the Convert dialog'))
self.show_css.setToolTip(_('<qt>Show by default the stylesheets in the Convert dialog</qt>'))
self.show_css.setChecked(prefs['show_CSS'])
self.l.addWidget(self.show_css)
self.css_layout = QVBoxLayout()
self.llll = QHBoxLayout()
self.css_layout.addLayout(self.llll)
self.css_list = QComboBox()
self.css_list.setToolTip(_('<qt>List of custom stylesheets defined. Select one to edit</qt>'))
self.css_list.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.CSS_list = prefs['custom_CSS_list'].copy()
self.default_CSS = prefs['default_CSS']
if 'custom_CSS' in prefs:
self.CSS_list[_('old')] = prefs['custom_CSS']
self.default_CSS = _('old')
if self.default_CSS not in self.CSS_list:
self.default_CSS = sorted(self.CSS_list, key=lambda x: x.lower())[0]
for key in sorted(self.CSS_list, key=lambda x: x.lower()):
self.css_list.addItem(key, key)
self.css_list.setCurrentIndex(self.css_list.findText(self.default_CSS))
self.css_list.currentIndexChanged.connect(self.set_css)
self.llll.addWidget(self.css_list)
self.css_rename = QPushButton(_('Re&name'))
self.css_rename.setToolTip(_('<qt>Rename the current stylesheet to the name on the right</qt>'))
self.css_rename.clicked.connect(self.rename_css)
self.css_rename.setEnabled(False)
self.llll.addWidget(self.css_rename)
self.css_name = QLineEdit(self)
self.css_name.setToolTip(_('<qt>Name for the new or renamed stylesheet</qt>'))
self.css_name.setText(self.css_list.currentText())
self.css_name.textChanged.connect(self.check_names)
self.llll.addWidget(self.css_name)
self.css_add = QPushButton(_('A&dd'))
self.css_add.setToolTip(_('<qt>Add a new empty stylesheet with the name on the left</qt>'))
self.css_add.clicked.connect(self.add_css)
self.css_add.setEnabled(False)
self.llll.addWidget(self.css_add)
self.css_remove = QPushButton(_('Re&move'))
self.css_remove.setToolTip(_('<qt>Remove the current stylesheet</qt>'))
self.css_remove.clicked.connect(self.remove_css)
self.llll.addWidget(self.css_remove)
self.css = TextEditWithTooltip()
self.css.setLineWrapMode(TextEditWithTooltip.NoWrap)
self.css.load_text(self.CSS_list[unicode(self.css_list.currentText())],'css')
self.css.setToolTip(_('<qt>Custom stylesheet that will be applied, if selected, to all Prince PDF conversions</qt>'))
self.css_layout.addWidget(self.css)
self.css_templates = QLabel(_('Book metadata can be used in the stylesheet. Anything between %(s1)s and %(s2)s will be processed as a calibre template. For instance, %(s3)s in the stylesheet will be replaced with the book title in the conversion.') % \
{'s1':'<span style="font-family:monospace ; font-weight:bold">@{@</span>', \
's2':'<span style="font-family:monospace ; font-weight:bold">@}@</span>', \
's3':'<span style="font-family:monospace ; font-weight:bold">@{@{title}@}@</span>'})
self.css_templates.setWordWrap(True)
self.css_layout.addWidget(self.css_templates)
self.css_box = QGroupBox(_('&Custom CSS:'))
self.css_box.setLayout(self.css_layout)
self.l.addWidget(self.css_box)
self.lllll = QHBoxLayout()
self.lllll.setAlignment(Qt.AlignLeft)
self.l.addLayout(self.lllll)
self.defaults = QPushButton(_('&Restore defaults'))
self.defaults.setToolTip(_('<qt>Restore the default settings</qt>'))
self.defaults.clicked.connect(self.restore_defaults)
self.lllll.addWidget(self.defaults, alignment=Qt.AlignLeft)
self.warning = QLabel(_('<b>Warning</b>: Deletes modified stylesheets'))
self.lllll.addWidget(self.warning)
self.adjustSize()
def select_exe(self):
'''
Create a dialog to select the Prince executable
'''
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.ExistingFile)
filename = dialog.getOpenFileName(self, _('Select Prince executable'), '', '')
if filename:
try:
self.exe.setText(filename)
except(TypeError):
self.exe.setText(filename[0])
def restore_defaults(self):
'''
Restore the default settings
'''
self.exe.setText(prefs.defaults['prince_exe'])
self.fmts.setText(','.join(prefs.defaults['formats']).lower())
self.show_css.setChecked(prefs.defaults['show_CSS'])
self.add_book.setChecked(prefs.defaults['add_book'])
self.css_list.currentIndexChanged.disconnect()
self.css_list.clear()
self.CSS_list = prefs.defaults['custom_CSS_list'].copy()
self.default_CSS = prefs.defaults['default_CSS']
for key in sorted(self.CSS_list, key=lambda x: x.lower()):
self.css_list.addItem(key, key)
self.css_list.setCurrentIndex(self.css_list.findText(self.default_CSS))
self.css_name.setText(self.default_CSS)
self.css.load_text(self.CSS_list[unicode(self.css_list.currentText())],'css')
self.css_list.currentIndexChanged.connect(self.set_css)
def save_settings(self):
'''
Save the current settings
'''
prefs['prince_exe'] = unicode(self.exe.text())
prefs['formats'] = unicode(self.fmts.text().lower()).split(',')
prefs['show_CSS'] = self.show_css.isChecked()
prefs['add_book'] = self.add_book.isChecked()
self.set_css()
prefs['default_CSS'] = self.default_CSS
prefs['custom_CSS_list'] = self.CSS_list.copy()
if 'custom_CSS' in prefs:
del prefs['custom_CSS']
def set_css(self):
'''
Fill the CSS text box with the selected stylesheet
'''
self.CSS_list[self.default_CSS] = unicode(self.css.toPlainText())
self.default_CSS = unicode(self.css_list.currentText())
self.css.load_text(self.CSS_list[self.default_CSS],'css')
self.css_name.setText(self.css_list.currentText())
def add_css(self):
'''
Add a new stylesheet
'''
from calibre.gui2 import error_dialog
name = unicode(self.css_name.text())
if name in self.CSS_list:
error_dialog(self, _('Cannot add stylesheet'), _('A stylesheet with the name "%s" is already defined, use a different name.') % name, show=True)
else:
self.CSS_list[name] = ''
self.css_list.addItem(name, name)
self.css_list.setCurrentIndex(self.css_list.findText(name))
self.css_add.setEnabled(False)
self.css_rename.setEnabled(False)
def remove_css(self):
'''
Remove an existing stylesheet
'''
from calibre.gui2 import error_dialog
if (self.css_list.count() > 1):
self.css_list.currentIndexChanged.disconnect()
self.css_list.removeItem(self.css_list.currentIndex())
del self.CSS_list[self.default_CSS]
self.default_CSS = unicode(self.css_list.currentText())
self.css.load_text(self.CSS_list[self.default_CSS],'css')
self.css_list.currentIndexChanged.connect(self.set_css)
self.css_name.setText(self.css_list.currentText())
else:
error_dialog(self, _('Cannot delete the last stylesheet'), _('The last stylesheet cannot be removed. You can rename it and/or remove its contents.'), show=True)
def rename_css(self):
'''
Rename a stylesheet
'''
from calibre.gui2 import error_dialog
name = unicode(self.css_name.text())
if name in self.CSS_list:
error_dialog(self, _('Cannot rename stylesheet'), _('A stylesheet with the name "%s" is already defined, use a different name.') % name, show=True)
else:
self.CSS_list[name] = self.CSS_list.pop(self.default_CSS)
self.css_list.setItemText(self.css_list.currentIndex(),name)
self.default_CSS = name
def check_names(self, text):
name = unicode(text)
if name in self.CSS_list:
self.css_add.setEnabled(False)
self.css_rename.setEnabled(False)
else:
self.css_add.setEnabled(True)
self.css_rename.setEnabled(True)
def __init__(self, extra_customization_message, extra_customization_choices, device_settings):
super(ExtraCustomization, self).__init__()
debug_print("ExtraCustomization.__init__ - extra_customization_message=", extra_customization_message)
debug_print("ExtraCustomization.__init__ - extra_customization_choices=", extra_customization_choices)
debug_print("ExtraCustomization.__init__ - device_settings.extra_customization=", device_settings.extra_customization)
debug_print("ExtraCustomization.__init__ - device_settings=", device_settings)
self.extra_customization_message = extra_customization_message
self.l = QVBoxLayout(self)
self.setLayout(self.l)
options_group = QGroupBox(_("Extra driver customization options"), self)
self.l.addWidget(options_group)
self.extra_layout = QGridLayout()
self.extra_layout.setObjectName("extra_layout")
options_group.setLayout(self.extra_layout)
if extra_customization_message:
extra_customization_choices = extra_customization_choices or {}
def parse_msg(m):
msg, _, tt = m.partition(':::') if m else ('', '', '')
return msg.strip(), textwrap.fill(tt.strip(), 100)
if isinstance(extra_customization_message, list):
self.opt_extra_customization = []
if len(extra_customization_message) > 6:
row_func = lambda x, y: ((x/2) * 2) + y
col_func = lambda x: x%2
else:
row_func = lambda x, y: x*2 + y
col_func = lambda x: 0
for i, m in enumerate(extra_customization_message):
label_text, tt = parse_msg(m)
if not label_text:
self.opt_extra_customization.append(None)
continue
if isinstance(device_settings.extra_customization[i], bool):
self.opt_extra_customization.append(QCheckBox(label_text))
self.opt_extra_customization[-1].setToolTip(tt)
self.opt_extra_customization[i].setChecked(bool(device_settings.extra_customization[i]))
elif i in extra_customization_choices:
cb = QComboBox(self)
self.opt_extra_customization.append(cb)
l = QLabel(label_text)
l.setToolTip(tt), cb.setToolTip(tt), l.setBuddy(cb), cb.setToolTip(tt)
for li in sorted(extra_customization_choices[i]):
self.opt_extra_customization[i].addItem(li)
cb.setCurrentIndex(max(0, cb.findText(device_settings.extra_customization[i])))
else:
self.opt_extra_customization.append(QLineEdit(self))
l = QLabel(label_text)
l.setToolTip(tt)
self.opt_extra_customization[i].setToolTip(tt)
l.setBuddy(self.opt_extra_customization[i])
l.setWordWrap(True)
self.opt_extra_customization[i].setText(device_settings.extra_customization[i])
self.opt_extra_customization[i].setCursorPosition(0)
self.extra_layout.addWidget(l, row_func(i + 2, 0), col_func(i))
self.extra_layout.addWidget(self.opt_extra_customization[i],
row_func(i + 2, 1), col_func(i))
spacerItem1 = QSpacerItem(10, 10, QSizePolicy.Minimum, QSizePolicy.Expanding)
self.extra_layout.addItem(spacerItem1, row_func(i + 2 + 2, 1), 0, 1, 2)
self.extra_layout.setRowStretch(row_func(i + 2 + 2, 1), 2)
else:
self.opt_extra_customization = QLineEdit()
label_text, tt = parse_msg(extra_customization_message)
l = QLabel(label_text)
l.setToolTip(tt)
l.setBuddy(self.opt_extra_customization)
l.setWordWrap(True)
if device_settings.extra_customization:
self.opt_extra_customization.setText(device_settings.extra_customization)
self.opt_extra_customization.setCursorPosition(0)
self.opt_extra_customization.setCursorPosition(0)
self.extra_layout.addWidget(l, 0, 0)
self.extra_layout.addWidget(self.opt_extra_customization, 1, 0)
def __init__(self, plugin):
DefaultConfigWidget.__init__(self, plugin)
c = plugin_prefs[STORE_NAME]
all_tags = get_current_db().all_tags()
self.gb.setMaximumHeight(80)
genre_group_box = QGroupBox(_('Ridibooks genre to calibre tag mappings'), self)
self.l.addWidget(genre_group_box, self.l.rowCount(), 0, 1, 2)
genre_group_box_layout = QVBoxLayout()
genre_group_box.setLayout(genre_group_box_layout)
tags_layout = QHBoxLayout()
genre_group_box_layout.addLayout(tags_layout)
self.edit_table = GenreTagMappingsTableWidget(self, all_tags)
tags_layout.addWidget(self.edit_table)
button_layout = QVBoxLayout()
tags_layout.addLayout(button_layout)
add_mapping_button = QtGui.QToolButton(self)
add_mapping_button.setToolTip(_('Add genre mapping'))
add_mapping_button.setIcon(QIcon(I('plus.png')))
add_mapping_button.clicked.connect(self.add_mapping)
button_layout.addWidget(add_mapping_button)
spacerItem1 = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
button_layout.addItem(spacerItem1)
remove_mapping_button = QtGui.QToolButton(self)
remove_mapping_button.setToolTip(_('Delete genre mapping'))
remove_mapping_button.setIcon(QIcon(I('minus.png')))
remove_mapping_button.clicked.connect(self.delete_mapping)
button_layout.addWidget(remove_mapping_button)
spacerItem3 = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
button_layout.addItem(spacerItem3)
rename_genre_button = QtGui.QToolButton(self)
rename_genre_button.setToolTip(_('Rename Goodreads genre'))
rename_genre_button.setIcon(QIcon(I('edit-undo.png')))
rename_genre_button.clicked.connect(self.rename_genre)
button_layout.addWidget(rename_genre_button)
spacerItem2 = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
button_layout.addItem(spacerItem2)
reset_defaults_button = QtGui.QToolButton(self)
reset_defaults_button.setToolTip(_('Reset to plugin default mappings'))
reset_defaults_button.setIcon(QIcon(I('clear_left.png')))
reset_defaults_button.clicked.connect(self.reset_to_defaults)
button_layout.addWidget(reset_defaults_button)
self.l.setRowStretch(self.l.rowCount()-1, 2)
other_group_box = QGroupBox(_('Other options'), self)
self.l.addWidget(other_group_box, self.l.rowCount(), 0, 1, 2)
other_group_box_layout = QVBoxLayout()
other_group_box.setLayout(other_group_box_layout)
self.get_editions_checkbox = QCheckBox('Scan multiple editions for title/author searches (slower)', self)
self.get_editions_checkbox.setToolTip('When checked will perform an additional search to scan the top ranked\n'
'Goodreads editions (if available) to exclude audiobook editions.\n'
'Without this enabled you will get a faster search, using the "best".\n'
'edition ranked by Goodreads which can in some cases be an audiobook.')
self.get_editions_checkbox.setChecked(c[KEY_GET_EDITIONS])
other_group_box_layout.addWidget(self.get_editions_checkbox)
self.all_authors_checkbox = QCheckBox('Get all contributing authors (e.g. illustrators, series editors etc)', self)
self.all_authors_checkbox.setToolTip('Goodreads for some books will list all of the contributing authors and\n'
'the type of contribution like (Editor), (Illustrator) etc.\n\n'
'When this option is checked, all contributing authors are retrieved.\n\n'
'When unchecked (default) only the primary author(s) are returned which\n'
'are those that either have no contribution type specified, or have the\n'
'value of (Goodreads Author).\n\n'
'If there is no primary author then only those with the same contribution\n'
'type as the first author are returned.\n'
'e.g. "A, B (Illustrator)" will return author A\n'
'e.g. "A (Goodreads Author)" will return author A\n'
'e.g. "A (Editor), B (Editor), C (Illustrator)" will return authors A & B\n'
'e.g. "A (Editor), B (Series Editor)" will return author A\n')
self.all_authors_checkbox.setChecked(c[KEY_GET_ALL_AUTHORS])
other_group_box_layout.addWidget(self.all_authors_checkbox)
self.edit_table.populate_table(c[KEY_GENRE_MAPPINGS])
def __init__(self, plugin_action):
QWidget.__init__(self)
self.plugin_action = plugin_action
layout = QVBoxLayout(self)
self.setLayout(layout)
self.help_anchor = "configuration"
title_layout = ImageTitleLayout(self, 'images/icon.png', 'Sony Utilities Options')
layout.addLayout(title_layout)
# c = plugin_prefs[STORE_NAME]
library_config = get_library_config(self.plugin_action.gui.current_db)
custom_column_group = QGroupBox(_('Custom Columns'), self)
layout.addWidget(custom_column_group )
options_layout = QGridLayout()
custom_column_group.setLayout(options_layout)
avail_text_columns = self.get_text_custom_columns()
avail_number_columns = self.get_number_custom_columns()
avail_rating_columns = self.get_rating_custom_columns()
avail_date_columns = self.get_date_custom_columns()
# debug_print("avail_rating_columns=", avail_rating_columns)
# debug_print("default columns=", self.plugin_action.gui.library_view.model().orig_headers)
current_Location_column = library_config.get(KEY_CURRENT_LOCATION_CUSTOM_COLUMN, DEFAULT_LIBRARY_VALUES[KEY_CURRENT_LOCATION_CUSTOM_COLUMN])
precent_read_column = library_config.get(KEY_PERCENT_READ_CUSTOM_COLUMN, DEFAULT_LIBRARY_VALUES[KEY_PERCENT_READ_CUSTOM_COLUMN])
rating_column = library_config.get(KEY_RATING_CUSTOM_COLUMN, DEFAULT_LIBRARY_VALUES[KEY_RATING_CUSTOM_COLUMN])
last_read_column = library_config.get(KEY_LAST_READ_CUSTOM_COLUMN, DEFAULT_LIBRARY_VALUES[KEY_LAST_READ_CUSTOM_COLUMN])
store_on_connect = get_plugin_pref(COMMON_OPTIONS_STORE_NAME, KEY_STORE_ON_CONNECT)
prompt_to_store = get_plugin_pref(COMMON_OPTIONS_STORE_NAME, KEY_PROMPT_TO_STORE)
store_if_more_recent = get_plugin_pref(COMMON_OPTIONS_STORE_NAME, KEY_STORE_IF_MORE_RECENT)
do_not_store_if_reopened = get_plugin_pref(COMMON_OPTIONS_STORE_NAME, KEY_DO_NOT_STORE_IF_REOPENED)
# do_check_for_firmware_updates = get_plugin_pref(UPDATE_OPTIONS_STORE_NAME, KEY_DO_UPDATE_CHECK)
# do_early_firmware_updates = get_plugin_pref(UPDATE_OPTIONS_STORE_NAME, KEY_DO_EARLY_FIRMWARE_CHECK)
# self.update_check_last_time = get_plugin_pref(UPDATE_OPTIONS_STORE_NAME, KEY_LAST_FIRMWARE_CHECK_TIME)
do_daily_backup = get_plugin_pref(BACKUP_OPTIONS_STORE_NAME, KEY_DO_DAILY_BACKUP)
dest_directory = get_plugin_pref(BACKUP_OPTIONS_STORE_NAME, KEY_BACKUP_DEST_DIRECTORY)
copies_to_keep = get_plugin_pref(BACKUP_OPTIONS_STORE_NAME, KEY_BACKUP_COPIES_TO_KEEP)
# debug_print("current_Location_column=%s, precent_read_column=%s, rating_column=%s" % (current_Location_column, precent_read_column, rating_column))
current_Location_label = QLabel(_('Current Reading Location Column:'), self)
current_Location_label.setToolTip(_("Select a custom column to store the current reading location. The column type must be 'text'. Leave this blank if you do not want to store or restore the current reading location."))
self.current_Location_combo = CustomColumnComboBox(self, avail_text_columns, current_Location_column)
current_Location_label.setBuddy(self.current_Location_combo)
options_layout.addWidget(current_Location_label, 0, 0, 1, 1)
options_layout.addWidget(self.current_Location_combo, 0, 1, 1, 1)
percent_read_label = QLabel(_('Percent Read Column:'), self)
percent_read_label.setToolTip(_("Column used to store the current percent read. The column type must be a 'integer'. Leave this blank if you do not want to store or restore the percentage read."))
self.percent_read_combo = CustomColumnComboBox(self, avail_number_columns, precent_read_column)
percent_read_label.setBuddy(self.percent_read_combo)
options_layout.addWidget(percent_read_label, 2, 0, 1, 1)
options_layout.addWidget(self.percent_read_combo, 2, 1, 1, 1)
rating_label = QLabel(_('Rating Column:'), self)
rating_label.setToolTip(_("Column used to store the rating. The column type must be a 'integer'. Leave this blank if you do not want to store or restore the rating."))
self.rating_combo = CustomColumnComboBox(self, avail_rating_columns, rating_column)
rating_label.setBuddy(self.rating_combo)
options_layout.addWidget(rating_label, 3, 0, 1, 1)
options_layout.addWidget(self.rating_combo, 3, 1, 1, 1)
last_read_label = QLabel(_('Last Read Column:'), self)
last_read_label.setToolTip(_("Column used to store when the book was last read. The column type must be a 'Date'. Leave this blank if you do not want to store the last read timestamp."))
self.last_read_combo = CustomColumnComboBox(self, avail_date_columns, last_read_column)
last_read_label.setBuddy(self.last_read_combo)
options_layout.addWidget(last_read_label, 4, 0, 1, 1)
options_layout.addWidget(self.last_read_combo, 4, 1, 1, 1)
auto_store_group = QGroupBox(_('Store on connect'), self)
layout.addWidget(auto_store_group )
options_layout = QGridLayout()
auto_store_group.setLayout(options_layout)
self.store_on_connect_checkbox = QCheckBox(_("Store current bookmarks on connect"), self)
self.store_on_connect_checkbox.setToolTip(_("When this is checked, the library will be updated with the current bookmark for all books on the device."))
self.store_on_connect_checkbox.setCheckState(Qt.Checked if store_on_connect else Qt.Unchecked)
self.store_on_connect_checkbox.clicked.connect(self.store_on_connect_checkbox_clicked)
options_layout.addWidget(self.store_on_connect_checkbox, 0, 0, 1, 3)
self.prompt_to_store_checkbox = QCheckBox(_("Prompt to store any changes"), self)
self.prompt_to_store_checkbox.setToolTip(_("Enable this to be prompted to save the changed bookmarks after an automatic store is done."))
self.prompt_to_store_checkbox.setCheckState(Qt.Checked if prompt_to_store else Qt.Unchecked)
self.prompt_to_store_checkbox.setEnabled(store_on_connect)
options_layout.addWidget(self.prompt_to_store_checkbox, 1, 0, 1, 1)
self.store_if_more_recent_checkbox = QCheckBox(_("Only if more recent"), self)
self.store_if_more_recent_checkbox.setToolTip(_("Only store the reading position if the last read timestamp on the device is more recent than in the library."))
self.store_if_more_recent_checkbox.setCheckState(Qt.Checked if store_if_more_recent else Qt.Unchecked)
self.store_if_more_recent_checkbox.setEnabled(store_on_connect)
options_layout.addWidget(self.store_if_more_recent_checkbox, 1, 1, 1, 1)
self.do_not_store_if_reopened_checkbox = QCheckBox(_("Not if finished in library"), self)
self.do_not_store_if_reopened_checkbox.setToolTip(_("Do not store the reading position if the library has the book as finished. This is if the percent read is 100%."))
self.do_not_store_if_reopened_checkbox.setCheckState(Qt.Checked if do_not_store_if_reopened else Qt.Unchecked)
self.do_not_store_if_reopened_checkbox.setEnabled(store_on_connect)
options_layout.addWidget(self.do_not_store_if_reopened_checkbox, 1, 2, 1, 1)
# update_options_group = QGroupBox(_('Firmware Update Options'), self)
# layout.addWidget(update_options_group)
# options_layout = QGridLayout()
# update_options_group.setLayout(options_layout)
#
# self.do_update_check = QCheckBox(_('Check for Sony firmware updates daily?'), self)
# self.do_update_check.setToolTip(_('If this is selected the plugin will check for Sony firmware updates when your Sony device is plugged in, once per 24-hour period.'))
# self.do_update_check.setCheckState(Qt.Checked if do_check_for_firmware_updates else Qt.Unchecked)
# options_layout.addWidget(self.do_update_check, 0, 0, 1, 1)
#
# self.do_early_firmware_check = QCheckBox(_('Use early firmware adopter affiliate?'), self)
# self.do_early_firmware_check.setToolTip(_('WARNING: THIS OPTION RISKS DOWNLOADING THE WRONG FIRMWARE FOR YOUR DEVICE! YOUR DEVICE MAY NOT FUNCTION PROPERLY IF THIS HAPPENS! Choose this option to attempt to download Sony firmware updates before they are officially available for your device.'))
# self.do_early_firmware_check.setCheckState(Qt.Checked if do_early_firmware_updates else Qt.Unchecked)
# options_layout.addWidget(self.do_early_firmware_check, 0, 1, 1, 1)
backup_options_group = QGroupBox(_('Device Database Backup'), self)
layout.addWidget(backup_options_group)
options_layout = QGridLayout()
backup_options_group.setLayout(options_layout)
self.do_daily_backp_checkbox = QCheckBox(_('Backup the device database daily'), self)
self.do_daily_backp_checkbox.setToolTip(_('If this is selected the plugin will backup the device database the first time it is connected each day.'))
self.do_daily_backp_checkbox.setCheckState(Qt.Checked if do_daily_backup else Qt.Unchecked)
self.do_daily_backp_checkbox.clicked.connect(self.do_daily_backp_checkbox_clicked)
options_layout.addWidget(self.do_daily_backp_checkbox, 0, 0, 1, 3)
self.dest_directory_label = QLabel(_("Destination:"), self)
self.dest_directory_label.setToolTip(_("Select the destination the annotations files are to be backed up in."))
self.dest_directory_edit = QLineEdit(self)
self.dest_directory_edit.setMinimumSize(150, 0)
self.dest_directory_edit.setText(dest_directory)
self.dest_directory_label.setBuddy(self.dest_directory_edit)
self.dest_pick_button = QPushButton(_("..."), self)
self.dest_pick_button.setMaximumSize(24, 20)
self.dest_pick_button.clicked.connect(self._get_dest_directory_name)
options_layout.addWidget(self.dest_directory_label, 1, 0, 1, 1)
options_layout.addWidget(self.dest_directory_edit, 1, 1, 1, 1)
options_layout.addWidget(self.dest_pick_button, 1, 2, 1, 1)
self.copies_to_keep_checkbox = QCheckBox(_('Copies to keep'), self)
self.copies_to_keep_checkbox.setToolTip(_("Select this to limit the number of backup kept. If not set, the backup files must be manually deleted."))
self.copies_to_keep_spin = QSpinBox(self)
self.copies_to_keep_spin.setMinimum(2)
self.copies_to_keep_spin.setToolTip(_("The number of backup copies of the database to keep. The minimum is 2."))
options_layout.addWidget(self.copies_to_keep_checkbox, 1, 3, 1, 1)
options_layout.addWidget(self.copies_to_keep_spin, 1, 4, 1, 1)
self.copies_to_keep_checkbox.clicked.connect(self.copies_to_keep_checkbox_clicked)
if copies_to_keep == -1:
self.copies_to_keep_checkbox.setCheckState(not Qt.Checked)
else:
self.copies_to_keep_checkbox.setCheckState(Qt.Checked)
self.copies_to_keep_spin.setProperty('value', copies_to_keep)
self.do_daily_backp_checkbox_clicked(do_daily_backup)
other_options_group = QGroupBox(_('Other Options'), self)
layout.addWidget(other_options_group )
options_layout = QGridLayout()
other_options_group.setLayout(options_layout)
library_default_label = QLabel(_('&Library Button default:'), self)
library_default_label.setToolTip(_('If plugin is placed as a toolbar button, choose a default action when clicked on'))
self.library_default_combo = KeyComboBox(self, self.plugin_action.library_actions_map, unicode(get_plugin_pref(COMMON_OPTIONS_STORE_NAME, KEY_BUTTON_ACTION_LIBRARY)))
library_default_label.setBuddy(self.library_default_combo)
options_layout.addWidget(library_default_label, 0, 0, 1, 1)
options_layout.addWidget(self.library_default_combo, 0, 1, 1, 2)
device_default_label = QLabel(_('&Device Button default:'), self)
device_default_label.setToolTip(_('If plugin is placed as a toolbar button, choose a default action when clicked on'))
self.device_default_combo = KeyComboBox(self, self.plugin_action.device_actions_map, unicode(get_plugin_pref(COMMON_OPTIONS_STORE_NAME, KEY_BUTTON_ACTION_DEVICE)))
device_default_label.setBuddy(self.device_default_combo)
options_layout.addWidget(device_default_label, 1, 0, 1, 1)
options_layout.addWidget(self.device_default_combo, 1, 1, 1, 2)
keyboard_shortcuts_button = QPushButton(_('Keyboard shortcuts...'), self)
keyboard_shortcuts_button.setToolTip(_('Edit the keyboard shortcuts associated with this plugin'))
keyboard_shortcuts_button.clicked.connect(self.edit_shortcuts)
layout.addWidget(keyboard_shortcuts_button)
layout.addStretch(1)
