self.gui.library_view.apply_state(state)
self.gui.library_view.save_state()
must_restart = False
for c in self.custcols:
if self.custcols[c]['colnum'] is None:
db.create_custom_column(
label=self.custcols[c]['label'],
name=self.custcols[c]['name'],
datatype=self.custcols[c]['datatype'],
is_multiple=self.custcols[c]['is_multiple'],
display=self.custcols[c]['display'])
must_restart = True
elif '*deleteme' in self.custcols[c]:
db.delete_custom_column(label=self.custcols[c]['label'])
must_restart = True
elif '*edited' in self.custcols[c]:
cc = self.custcols[c]
db.set_custom_column_metadata(cc['colnum'], name=cc['name'],
label=cc['label'],
display=self.custcols[c]['display'],
notify=False)
if '*must_restart' in self.custcols[c]:
must_restart = True
return must_restart
if __name__ == '__main__':
app = Application([])
test_widget('Interface', 'Custom Columns')
continue
ops = []
for op in self.current_plugboards[f][d]:
ops.append('([' + op[0] + '] -> ' + op[1] + ')')
txt = '%s:%s = %s\n' % (f, d, ', '.join(ops))
item = QListWidgetItem(txt)
item.setData(Qt.UserRole, (f, d))
if d in self.disabled_devices:
item.setFlags(item.flags() & ~Qt.ItemIsEnabled)
self.existing_plugboards.addItem(item)
self.refilling = False
def restore_defaults(self):
ConfigWidgetBase.restore_defaults(self)
self.current_plugboards = {}
self.refill_all_boxes()
self.changed_signal.emit()
def commit(self):
self.db.new_api.set_pref('plugboards', self.current_plugboards)
return ConfigWidgetBase.commit(self)
def refresh_gui(self, gui):
pass
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Import/Export', 'Plugboard')
lm_in_toolbar = self.models["toolbar-device"][1].has_action("Location Manager")
lm_in_menubar = self.models["menubar-device"][1].has_action("Location Manager")
if not pref_in_toolbar and not pref_in_menubar:
self.models["menubar"][1].add(["Preferences"])
if not lm_in_toolbar and not lm_in_menubar:
m = self.models["toolbar-device"][1]
m.add(["Location Manager"])
m.move(m.index(m.rowCount(None) - 1), 5 - m.rowCount(None))
# Save data.
for am, cm in self.models.values():
cm.commit()
return False
def restore_defaults(self):
for am, cm in self.models.values():
cm.restore_defaults()
am.restore_defaults()
self.changed_signal.emit()
def refresh_gui(self, gui):
gui.bars_manager.init_bars()
gui.bars_manager.update_bars()
if __name__ == "__main__":
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget("Interface", "Toolbar")
def refresh_gui(self, gui):
gui.current_db.new_api.clear_caches()
set_use_primary_find_in_search(prefs['use_primary_find_in_search'])
gui.set_highlight_only_button_icon()
if self.muc_changed:
gui.tags_view.recount()
gui.search.search_as_you_type(config['search_as_you_type'])
gui.search.do_search()
def clear_histories(self, *args):
for key, val in iteritems(config.defaults):
if key.endswith('_search_history') and isinstance(val, list):
config[key] = []
self.gui.search.clear_history()
from calibre.gui2.widgets import history
for key in (
'bulk_edit_search_for',
'bulk_edit_replace_with',
'viewer-highlights-search-panel-expression',
'viewer-search-panel-expression',
):
history.set('lineedit_history_' + key, [])
from calibre.gui2.viewer.config import vprefs
for k in ('search', 'highlights'):
vprefs.set(f'saved-{k}-settings', {})
if __name__ == '__main__':
app = QApplication([])
test_widget('Interface', 'Search')
minimum_calibre_version = (1, 0, 0)
actual_plugin = 'calibre_plugins.annotations.action:AnnotationsAction'
def is_customizable(self):
return True
def config_widget(self):
self.cw = None
if self.actual_plugin_:
from calibre_plugins.annotations.config import ConfigWidget
self.cw = ConfigWidget(self.actual_plugin_)
return self.cw
def save_settings(self, config_widget):
config_widget.save_settings()
if self.actual_plugin_:
self.actual_plugin_.rebuild_menus()
# For testing ConfigWidget, run from command line:
# calibre-debug __init__.py
if __name__ == '__main__':
try:
from PyQt5.Qt import QApplication
except ImportError:
from PyQt4.Qt import QApplication
from calibre.gui2.preferences import test_widget
app = QApplication([])
test_widget('Advanced', 'Plugins')
self.delete_button.setEnabled(True)
self.program.setReadOnly(False)
self.replace_button.setEnabled(False)
def replace_button_clicked(self):
self.delete_button_clicked()
self.create_button_clicked()
def refresh_gui(self, gui):
pass
def commit(self):
# formatter_functions().reset_to_builtins()
pref_value = []
for name, cls in self.funcs.iteritems():
if name not in self.builtins:
pref_value.append(
(cls.name, cls.doc, cls.arg_count, cls.program_text))
self.db.new_api.set_pref('user_template_functions', pref_value)
funcs = compile_user_template_functions(pref_value)
self.db.new_api.set_user_template_functions(funcs)
self.gui.library_view.model().refresh()
load_user_template_functions(self.db.library_id, [], funcs)
return False
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Advanced', 'TemplateFunctions')
class InputOptions(Base):
def load_conversion_widgets(self):
self.conversion_widgets = []
for plugin in input_format_plugins():
pw = config_widget_for_input_plugin(plugin)
if pw is not None:
self.conversion_widgets.append(pw)
class OutputOptions(Base):
def load_conversion_widgets(self):
self.conversion_widgets = []
for plugin in output_format_plugins():
name = plugin.name.lower().replace(' ', '_')
try:
output_widget = importlib.import_module(
'calibre.gui2.convert.'+name)
pw = output_widget.PluginWidget
self.conversion_widgets.append(pw)
except ImportError:
continue
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
# test_widget('Conversion', 'Input Options')
# test_widget('Conversion', 'Common Options')
test_widget('Conversion', 'Output Options')
prefs['filename_pattern'] = pattern
fmts = self.current_blocked_auto_formats
old = gprefs['blocked_auto_formats']
changed = set(fmts) != set(old)
if changed:
gprefs['blocked_auto_formats'] = self.current_blocked_auto_formats
if self.tag_map_rules is not None:
if self.tag_map_rules:
gprefs['tag_map_on_add_rules'] = self.tag_map_rules
else:
gprefs.pop('tag_map_on_add_rules', None)
if self.add_filter_rules is not None:
if self.add_filter_rules:
gprefs['add_filter_rules'] = self.add_filter_rules
else:
gprefs.pop('add_filter_rules', None)
ret = ConfigWidgetBase.commit(self)
return changed or ret
def refresh_gui(self, gui):
# Ensure worker process reads updated settings
gui.spare_pool().shutdown()
# Update rules used int he auto adder
gui.auto_adder.read_rules()
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Import/Export', 'Adding')
self.db.field_metadata.add_grouped_search_terms(self.gst)
self.db.new_api.set_pref('similar_authors_search_key',
unicode(self.similar_authors_search_key.currentText()))
self.db.new_api.set_pref('similar_tags_search_key',
unicode(self.similar_tags_search_key.currentText()))
self.db.new_api.set_pref('similar_series_search_key',
unicode(self.similar_series_search_key.currentText()))
self.db.new_api.set_pref('similar_publisher_search_key',
unicode(self.similar_publisher_search_key.currentText()))
return ConfigWidgetBase.commit(self)
def refresh_gui(self, gui):
gui.current_db.new_api.clear_caches()
set_use_primary_find_in_search(prefs['use_primary_find_in_search'])
gui.set_highlight_only_button_icon()
if self.muc_changed:
gui.tags_view.recount()
gui.search.search_as_you_type(config['search_as_you_type'])
gui.search.do_search()
def clear_histories(self, *args):
for key, val in config.defaults.iteritems():
if key.endswith('_search_history') and isinstance(val, list):
config[key] = []
self.gui.search.clear_history()
if __name__ == '__main__':
app = QApplication([])
test_widget('Interface', 'Search')
"""
Print location, args to console
"""
if not self.verbose:
return
arg1 = arg2 = ""
if len(args) > 0:
arg1 = args[0]
if len(args) > 1:
arg2 = args[1]
debug_print(
self.LOCATION_TEMPLATE.format(
cls=self.__class__.__name__, func=sys._getframe(1).f_code.co_name, arg1=arg1, arg2=arg2
)
)
# For testing ConfigWidget, run from command line:
# cd ~/Documents/calibredev/iOS_reader_applications
# calibre-debug config.py
# Search 'iOS Reader Apps'
if __name__ == "__main__":
from PyQt4.Qt import QApplication
from calibre.gui2.preferences import test_widget
app = QApplication([])
test_widget("Advanced", "Plugins")
must_restart = False
for c in self.custcols:
if self.custcols[c]["colnum"] is None:
db.create_custom_column(
label=self.custcols[c]["label"],
name=self.custcols[c]["name"],
datatype=self.custcols[c]["datatype"],
is_multiple=self.custcols[c]["is_multiple"],
display=self.custcols[c]["display"],
)
must_restart = True
elif "*deleteme" in self.custcols[c]:
db.delete_custom_column(label=self.custcols[c]["label"])
must_restart = True
elif "*edited" in self.custcols[c]:
cc = self.custcols[c]
db.set_custom_column_metadata(
cc["colnum"], name=cc["name"], label=cc["label"], display=self.custcols[c]["display"], notify=False
)
if "*must_restart" in self.custcols[c]:
must_restart = True
return must_restart
if __name__ == "__main__":
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget("Interface", "Custom Columns")
self.save_template.changed_signal.connect(self.changed_signal.emit)
def initialize(self):
ConfigWidgetBase.initialize(self)
self.save_template.blockSignals(True)
self.save_template.initialize('save_to_disk', self.proxy['template'],
self.proxy.help('template'),
self.gui.library_view.model().db.field_metadata)
self.save_template.blockSignals(False)
def restore_defaults(self):
ConfigWidgetBase.restore_defaults(self)
self.save_template.set_value(self.proxy.defaults['template'])
def commit(self):
if not self.save_template.validate():
raise AbortCommit('abort')
self.save_template.save_settings(self.proxy, 'template')
return ConfigWidgetBase.commit(self)
def refresh_gui(self, gui):
gui.iactions['Save To Disk'].reread_prefs()
# Ensure worker process reads updated settings
gui.spare_pool().shutdown()
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Import/Export', 'Saving')
if d not in self.current_plugboards[f]:
continue
ops = []
for op in self.current_plugboards[f][d]:
ops.append("([" + op[0] + "] -> " + op[1] + ")")
txt = "%s:%s = %s\n" % (f, d, ", ".join(ops))
item = QListWidgetItem(txt)
item.setData(Qt.UserRole, (f, d))
self.existing_plugboards.addItem(item)
self.refilling = False
def restore_defaults(self):
ConfigWidgetBase.restore_defaults(self)
self.current_plugboards = {}
self.refill_all_boxes()
self.changed_signal.emit()
def commit(self):
self.db.prefs.set("plugboards", self.current_plugboards)
return ConfigWidgetBase.commit(self)
def refresh_gui(self, gui):
pass
if __name__ == "__main__":
from PyQt4.Qt import QApplication
app = QApplication([])
test_widget("Import/Export", "Plugboard")
layout.addWidget(al)
try:
al.setPlainText(open(log_access_file, 'rb').read().decode('utf8', 'replace'))
except IOError:
al.setPlainText('No access log found')
bx = QDialogButtonBox(QDialogButtonBox.Ok)
layout.addWidget(bx)
bx.accepted.connect(d.accept)
d.show()
def commit(self):
ConfigWidgetBase.commit(self)
warning_dialog(self, _('Restart needed'),
_('You need to restart the server for changes to'
' take effect'), show=True)
return False
def refresh_gui(self, gui):
gui.content_server = self.server
if gui.content_server is not None:
gui.content_server.state_callback = \
Dispatcher(gui.iactions['Connect Share'].content_server_state_changed)
gui.content_server.state_callback(gui.content_server.is_running)
if __name__ == '__main__':
from PyQt4.Qt import QApplication
app = QApplication([])
test_widget('Sharing', 'Server')
fmts = self.current_blocked_auto_formats
old = gprefs["blocked_auto_formats"]
changed = set(fmts) != set(old)
if changed:
gprefs["blocked_auto_formats"] = self.current_blocked_auto_formats
if self.tag_map_rules is not None:
if self.tag_map_rules:
gprefs["tag_map_on_add_rules"] = self.tag_map_rules
else:
gprefs.pop("tag_map_on_add_rules", None)
if self.add_filter_rules is not None:
if self.add_filter_rules:
gprefs["add_filter_rules"] = self.add_filter_rules
else:
gprefs.pop("add_filter_rules", None)
ret = ConfigWidgetBase.commit(self)
return changed or ret
def refresh_gui(self, gui):
# Ensure worker process reads updated settings
gui.spare_pool().shutdown()
# Update rules used int he auto adder
gui.auto_adder.read_rules()
if __name__ == "__main__":
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget("Import/Export", "Adding")
self.devices.clear()
def commit(self):
devs = {}
for i in range(0, self.devices.count()):
e = self.devices.item(i)
dev, uid = e.data(Qt.ItemDataRole.UserRole)
if dev not in devs:
devs[dev] = []
if e.checkState() == Qt.CheckState.Checked:
devs[dev].append(uid)
for dev, bl in iteritems(devs):
dev.set_user_blacklisted_devices(bl)
for i in range(self.device_plugins.count()):
e = self.device_plugins.item(i)
dev = e.data(Qt.ItemDataRole.UserRole)
if e.checkState() == Qt.CheckState.Unchecked:
enable_plugin(dev)
if self.confirms_reset:
gprefs['ask_to_manage_device'] = []
return True # Restart required
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
test_widget('Sharing', 'Ignored Devices')
def commit(self, *args):
rr = ConfigWidgetBase.commit(self, *args)
if self.current_font != self.initial_font:
gprefs["font"] = self.current_font[:4] if self.current_font else None
gprefs["font_stretch"] = self.current_font[4] if self.current_font is not None else QFont.Unstretched
QApplication.setFont(self.font_display.font())
rr = True
self.display_model.commit()
self.edit_rules.commit(self.gui.current_db.prefs)
self.icon_rules.commit(self.gui.current_db.prefs)
gprefs["cover_grid_color"] = tuple(self.cover_grid_color_label.palette().color(QPalette.Window).getRgb())[:3]
return rr
def refresh_gui(self, gui):
gui.library_view.model().reset()
self.update_font_display()
gui.tags_view.reread_collapse_parameters()
gui.library_view.refresh_book_details()
if hasattr(gui.cover_flow, "setShowReflections"):
gui.cover_flow.setShowReflections(gprefs["cover_browser_reflections"])
gui.library_view.refresh_row_sizing()
gui.grid_view.refresh_settings()
if __name__ == "__main__":
from calibre.gui2 import Application
app = Application([])
test_widget("Interface", "Look & Feel")
gprefs['font_stretch'] = (self.current_font[4] if self.current_font
is not None else QFont.Unstretched)
QApplication.setFont(self.font_display.font())
rr = True
self.display_model.commit()
self.edit_rules.commit(self.gui.current_db.prefs)
self.icon_rules.commit(self.gui.current_db.prefs)
self.grid_rules.commit(self.gui.current_db.prefs)
gprefs['cover_grid_color'] = tuple(self.cg_bg_widget.bcol.getRgb())[:3]
gprefs['cover_grid_texture'] = self.cg_bg_widget.btex
return rr
def refresh_gui(self, gui):
m = gui.library_view.model()
m.beginResetModel(), m.endResetModel()
self.update_font_display()
gui.tags_view.reread_collapse_parameters()
gui.library_view.refresh_book_details()
if hasattr(gui.cover_flow, 'setShowReflections'):
gui.cover_flow.setShowReflections(gprefs['cover_browser_reflections'])
gui.cover_flow.setPreserveAspectRatio(gprefs['cb_preserve_aspect_ratio'])
gui.library_view.refresh_row_sizing()
gui.grid_view.refresh_settings()
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
test_widget('Interface', 'Look & Feel')
class InputOptions(Base):
def load_conversion_widgets(self):
self.conversion_widgets = []
for plugin in input_format_plugins():
pw = config_widget_for_input_plugin(plugin)
if pw is not None:
self.conversion_widgets.append(pw)
class OutputOptions(Base):
def load_conversion_widgets(self):
self.conversion_widgets = []
for plugin in output_format_plugins():
name = plugin.name.lower().replace(' ', '_')
try:
output_widget = importlib.import_module(
'calibre.gui2.convert.' + name)
pw = output_widget.PluginWidget
self.conversion_widgets.append(pw)
except ImportError:
continue
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
#test_widget('Conversion', 'Input Options')
#test_widget('Conversion', 'Common Options')
test_widget('Conversion', 'Output Options')
return a tuple of two strings (message, details), these will be
displayed as a warning dialog to the user and the process will be
aborted.
The base class implementation of this method raises NotImplementedError
so by default no user configuration is possible.
'''
if self.actual_plugin_:
from calibre_plugins.manage_series.config import ConfigWidget
return ConfigWidget(self.actual_plugin_)
def save_settings(self, config_widget):
'''
Save the settings specified by the user with config_widget.
:param config_widget: The widget returned by :meth:`config_widget`.
'''
config_widget.save_settings()
# For testing, run from command line with this:
# calibre-debug -e __init__.py
if __name__ == '__main__':
try:
from PyQt5.Qt import QApplication
except ImportError as e:
from PyQt4.Qt import QApplication
from calibre.gui2.preferences import test_widget
app = QApplication([])
test_widget('Advanced', 'Plugins')
txt = _('No proxies used')
if proxies:
lines = ['<br><code>%s: %s</code>'%(t, p) for t, p in
proxies.iteritems()]
txt = _('<b>Using proxies:</b>') + ''.join(lines)
self.proxies.setText(txt)
def create_icon_theme(self):
from calibre.gui2.icon_theme import create_theme
create_theme(parent=self)
def debug_device_detection(self, *args):
from calibre.gui2.preferences.device_debug import DebugDevice
d = DebugDevice(self.gui, self)
d.exec_()
def user_defined_device(self, *args):
from calibre.gui2.preferences.device_user_defined import UserDefinedDevice
d = UserDefinedDevice(self)
d.exec_()
def open_config_dir(self, *args):
from calibre.utils.config import config_dir
open_local_file(config_dir)
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Advanced', 'Misc')
try:
self.pc.finished.diconnect()
except:
pass
self.stack.setCurrentIndex(0)
self.stack.removeWidget(self.pc)
self.pc = None
def initialize(self):
ConfigWidgetBase.initialize(self)
self.sources_model.initialize()
self.sources_view.resizeColumnsToContents()
self.fields_model.initialize()
def restore_defaults(self):
ConfigWidgetBase.restore_defaults(self)
self.sources_model.restore_defaults()
self.fields_model.restore_defaults()
self.changed_signal.emit()
def commit(self):
self.sources_model.commit()
self.fields_model.commit()
return ConfigWidgetBase.commit(self)
if __name__ == '__main__':
from PyQt4.Qt import QApplication
app = QApplication([])
test_widget('Sharing', 'Metadata download')
self.proxy['aliases'] = self._email_accounts.aliases
self.proxy['tags'] = self._email_accounts.tags
return ConfigWidgetBase.commit(self)
def make_default(self, *args):
self._email_accounts.make_default(self.email_view.currentIndex())
self.changed_signal.emit()
def add_email_account(self, *args):
index = self._email_accounts.add()
self.email_view.setCurrentIndex(index)
self.email_view.resizeColumnsToContents()
self.email_view.edit(index)
self.changed_signal.emit()
def remove_email_account(self, *args):
idx = self.email_view.currentIndex()
self._email_accounts.remove(idx)
self.changed_signal.emit()
def refresh_gui(self, gui):
from calibre.gui2.email import gui_sendmail
gui_sendmail.calculate_rate_limit()
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
test_widget('Sharing', 'Email')
def restore_defaults(self):
if self.devices.count() > 0:
self.devices.clear()
def commit(self):
devs = {}
for i in xrange(0, self.devices.count()):
e = self.devices.item(i)
dev, uid = e.data(Qt.UserRole)
if dev not in devs:
devs[dev] = []
if e.checkState() == Qt.Checked:
devs[dev].append(uid)
for dev, bl in devs.iteritems():
dev.set_user_blacklisted_devices(bl)
for i in xrange(self.device_plugins.count()):
e = self.device_plugins.item(i)
dev = e.data(Qt.UserRole)
if e.checkState() == Qt.Unchecked:
enable_plugin(dev)
return True # Restart required
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Sharing', 'Ignored Devices')
self.gui = gui
self.conf_widget = ShortcutConfig(self)
self.conf_widget.changed_signal.connect(self.changed_signal)
self._layout = l = QVBoxLayout()
self.setLayout(l)
l.addWidget(self.conf_widget)
def initialize(self):
ConfigWidgetBase.initialize(self)
self.conf_widget.initialize(self.gui.keyboard)
def restore_defaults(self):
ConfigWidgetBase.restore_defaults(self)
self.conf_widget.restore_defaults()
def commit(self):
self.conf_widget.commit()
return ConfigWidgetBase.commit(self)
def refresh_gui(self, gui):
gui.keyboard.finalize()
def highlight_group(self, group_name):
self.conf_widget.highlight_group(group_name)
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Advanced', 'Keyboard')
lines = [
'<br><code>%s: %s</code>' % (t, p)
for t, p in proxies.iteritems()
]
txt = _('<b>Using proxies:</b>') + ''.join(lines)
self.proxies.setText(txt)
def create_icon_theme(self):
from calibre.gui2.icon_theme import create_theme
create_theme(parent=self)
def debug_device_detection(self, *args):
from calibre.gui2.preferences.device_debug import DebugDevice
d = DebugDevice(self.gui, self)
d.exec_()
def user_defined_device(self, *args):
from calibre.gui2.preferences.device_user_defined import UserDefinedDevice
d = UserDefinedDevice(self)
d.exec_()
def open_config_dir(self, *args):
from calibre.utils.config import config_dir
open_local_file(config_dir)
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Advanced', 'Misc')
if not self.search_net_tab.commit():
return False
ConfigWidgetBase.commit(self)
change_settings(**settings)
UserManager().user_data = users
return True
def commit(self):
if not self.save_changes():
raise AbortCommit()
warning_dialog(
self,
_('Restart needed'),
_('You need to restart the server for changes to'
' take effect'),
show=True
)
return False
def refresh_gui(self, gui):
if self.server:
self.server.user_manager.refresh()
self.server.ctx.custom_list_template = custom_list_template()
self.server.ctx.search_the_net_urls = search_the_net_urls()
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
test_widget('Sharing', 'Server')
def initialize(self):
ConfigWidgetBase.initialize(self)
self.save_template.blockSignals(True)
self.save_template.initialize(
'save_to_disk', self.proxy['template'],
self.proxy.help('template'),
self.gui.library_view.model().db.field_metadata)
self.save_template.blockSignals(False)
def restore_defaults(self):
ConfigWidgetBase.restore_defaults(self)
self.save_template.set_value(self.proxy.defaults['template'])
def commit(self):
if not self.save_template.validate():
raise AbortCommit('abort')
self.save_template.save_settings(self.proxy, 'template')
return ConfigWidgetBase.commit(self)
def refresh_gui(self, gui):
gui.iactions['Save To Disk'].reread_prefs()
# Ensure worker process reads updated settings
gui.spare_pool().shutdown()
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Import/Export', 'Saving')
must_restart = False
for c in self.custcols:
if self.custcols[c]['colnum'] is None:
db.create_custom_column(
label=self.custcols[c]['label'],
name=self.custcols[c]['name'],
datatype=self.custcols[c]['datatype'],
is_multiple=self.custcols[c]['is_multiple'],
display=self.custcols[c]['display'])
must_restart = True
elif '*deleteme' in self.custcols[c]:
db.delete_custom_column(label=self.custcols[c]['label'])
must_restart = True
elif '*edited' in self.custcols[c]:
cc = self.custcols[c]
db.set_custom_column_metadata(
cc['colnum'],
name=cc['name'],
label=cc['label'],
display=self.custcols[c]['display'],
notify=False)
if '*must_restart' in self.custcols[c]:
must_restart = True
return must_restart
if __name__ == '__main__':
app = Application([])
test_widget('Interface', 'Custom Columns')
def load_conversion_widgets(self):
self.conversion_widgets = []
for plugin in input_format_plugins():
pw = config_widget_for_input_plugin(plugin)
if pw is not None:
pw.conv_plugin = plugin
self.conversion_widgets.append(pw)
class OutputOptions(Base):
def load_conversion_widgets(self):
self.conversion_widgets = []
for plugin in output_format_plugins():
name = plugin.name.lower().replace(' ', '_')
try:
output_widget = importlib.import_module(
'calibre.gui2.convert.' + name)
pw = output_widget.PluginWidget
pw.conv_plugin = plugin
self.conversion_widgets.append(pw)
except ImportError:
continue
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
# test_widget('Conversion', 'Input Options')
test_widget('Conversion', 'Common Options')
# test_widget('Conversion', 'Output Options')
self.opt_manage_device_metadata.setToolTip(
_('Cannot change metadata management while a device is connected'))
self.mm_label.setText(_('Metadata management (disabled while '
'device connected)'))
self.send_template.changed_signal.connect(self.changed_signal.emit)
def initialize(self):
ConfigWidgetBase.initialize(self)
self.send_template.blockSignals(True)
self.send_template.initialize('send_to_device', self.proxy['send_template'],
self.proxy.help('send_template'),
self.gui.library_view.model().db.field_metadata)
self.send_template.blockSignals(False)
def restore_defaults(self):
ConfigWidgetBase.restore_defaults(self)
self.send_template.set_value(self.proxy.defaults['send_template'])
def commit(self):
if not self.send_template.validate():
raise AbortCommit('abort')
self.send_template.save_settings(self.proxy, 'send_template')
return ConfigWidgetBase.commit(self)
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Import/Export', 'Sending')
self.mm_label.setText(
_('Metadata management (disabled while '
'device connected)'))
self.send_template.changed_signal.connect(self.changed_signal.emit)
def initialize(self):
ConfigWidgetBase.initialize(self)
self.send_template.blockSignals(True)
self.send_template.initialize(
'send_to_device', self.proxy['send_template'],
self.proxy.help('send_template'),
self.gui.library_view.model().db.field_metadata)
self.send_template.blockSignals(False)
def restore_defaults(self):
ConfigWidgetBase.restore_defaults(self)
self.send_template.set_value(self.proxy.defaults['send_template'])
def commit(self):
if not self.send_template.validate():
raise AbortCommit('abort')
self.send_template.save_settings(self.proxy, 'send_template')
return ConfigWidgetBase.commit(self)
if __name__ == '__main__':
from qt.core import QApplication
app = QApplication([])
test_widget('Import/Export', 'Sending')
def highlight_index(self, idx):
if not idx.isValid():
return
self.view.scrollTo(idx)
self.view.selectionModel().select(idx,
self.view.selectionModel().ClearAndSelect)
self.view.setCurrentIndex(idx)
def find_next(self, *args):
idx = self.view.currentIndex()
if not idx.isValid():
idx = self._model.index(0)
idx = self._model.find_next(idx,
unicode(self.search.currentText()))
self.highlight_index(idx)
def find_previous(self, *args):
idx = self.view.currentIndex()
if not idx.isValid():
idx = self._model.index(0)
idx = self._model.find_next(idx,
unicode(self.search.currentText()), backwards=True)
self.highlight_index(idx)
if __name__ == '__main__':
app = QApplication([])
# Tweaks()
# test_widget
test_widget('Advanced', 'Tweaks')
self.program.setReadOnly(True)
self.delete_button.setEnabled(False)
else:
self.program.setPlainText(func.program_text)
self.delete_button.setEnabled(True)
self.program.setReadOnly(False)
self.replace_button.setEnabled(False)
def replace_button_clicked(self):
self.delete_button_clicked()
self.create_button_clicked()
def refresh_gui(self, gui):
pass
def commit(self):
# formatter_functions().reset_to_builtins()
pref_value = []
for name, cls in self.funcs.iteritems():
if name not in self.builtins:
pref_value.append((cls.name, cls.doc, cls.arg_count, cls.program_text))
self.db.new_api.set_pref('user_template_functions', pref_value)
load_user_template_functions(self.db.library_id, pref_value)
return False
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Advanced', 'TemplateFunctions')
ops = []
for op in self.current_plugboards[f][d]:
ops.append('([' + op[0] + '] -> ' + op[1] + ')')
txt = '%s:%s = %s\n'%(f, d, ', '.join(ops))
item = QListWidgetItem(txt)
item.setData(Qt.UserRole, (f, d))
if d in self.disabled_devices:
item.setFlags(item.flags() & ~Qt.ItemIsEnabled)
self.existing_plugboards.addItem(item)
self.refilling = False
def restore_defaults(self):
ConfigWidgetBase.restore_defaults(self)
self.current_plugboards = {}
self.refill_all_boxes()
self.changed_signal.emit()
def commit(self):
self.db.new_api.set_pref('plugboards', self.current_plugboards)
return ConfigWidgetBase.commit(self)
def refresh_gui(self, gui):
pass
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Import/Export', 'Plugboard')
gui.book_details.book_info.refresh_css()
m = gui.library_view.model()
m.beginResetModel(), m.endResetModel()
self.update_font_display()
gui.tags_view.set_look_and_feel()
gui.tags_view.reread_collapse_parameters()
gui.library_view.refresh_book_details(force=True)
gui.library_view.refresh_grid()
gui.library_view.set_row_header_visibility()
gui.cover_flow.setShowReflections(gprefs['cover_browser_reflections'])
gui.cover_flow.setPreserveAspectRatio(
gprefs['cb_preserve_aspect_ratio'])
gui.cover_flow.setActivateOnDoubleClick(
gprefs['cb_double_click_to_activate'])
gui.update_cover_flow_subtitle_font()
gui.cover_flow.template_inited = False
for view in 'library memory card_a card_b'.split():
getattr(gui, view + '_view').set_row_header_visibility()
gui.library_view.refresh_row_sizing()
gui.grid_view.refresh_settings()
gui.update_auto_scroll_timeout()
qv = get_quickview_action_plugin()
if qv:
qv.refill_quickview()
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
test_widget('Interface', 'Look & Feel')
self.opt_input_order.insertItem(idx - 1,
self.opt_input_order.takeItem(idx))
self.opt_input_order.setCurrentRow(idx - 1)
self.changed_signal.emit()
def down_input(self, *args):
idx = self.opt_input_order.currentRow()
if idx < self.opt_input_order.count() - 1:
self.opt_input_order.insertItem(idx + 1,
self.opt_input_order.takeItem(idx))
self.opt_input_order.setCurrentRow(idx + 1)
self.changed_signal.emit()
# }}}
def reset_confirmation_dialogs(self, *args):
for key in dynamic.keys():
if key.endswith('_again') and dynamic[key] is False:
dynamic[key] = True
gprefs['questions_to_auto_skip'] = []
info_dialog(self,
_('Done'),
_('Confirmation dialogs have all been reset'),
show=True)
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Interface', 'Behavior')
self.gui = gui
self.conf_widget = ShortcutConfig(self)
self.conf_widget.changed_signal.connect(self.changed_signal)
self._layout = l = QVBoxLayout()
self.setLayout(l)
l.addWidget(self.conf_widget)
def initialize(self):
ConfigWidgetBase.initialize(self)
self.conf_widget.initialize(self.gui.keyboard)
def restore_defaults(self):
ConfigWidgetBase.restore_defaults(self)
self.conf_widget.restore_defaults()
def commit(self):
self.conf_widget.commit()
return ConfigWidgetBase.commit(self)
def refresh_gui(self, gui):
gui.keyboard.finalize()
def highlight_group(self, group_name):
self.conf_widget.highlight_group(group_name)
if __name__ == '__main__':
from PyQt4.Qt import QApplication
app = QApplication([])
test_widget('Advanced', 'Keyboard')
pref_in_menubar = self.models['menubar'][1].has_action('Preferences')
lm_in_toolbar = self.models['toolbar-device'][1].has_action('Location Manager')
lm_in_menubar = self.models['menubar-device'][1].has_action('Location Manager')
if not pref_in_toolbar and not pref_in_menubar:
self.models['menubar'][1].add(['Preferences'])
if not lm_in_toolbar and not lm_in_menubar:
m = self.models['toolbar-device'][1]
m.add(['Location Manager'])
m.move(m.index(m.rowCount(None)-1), 5-m.rowCount(None))
# Save data.
for am, cm in self.models.values():
cm.commit()
return False
def restore_defaults(self):
for am, cm in self.models.values():
cm.restore_defaults()
am.restore_defaults()
self.changed_signal.emit()
def refresh_gui(self, gui):
gui.bars_manager.init_bars()
gui.bars_manager.update_bars()
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Interface', 'Toolbar')
raise AbortCommit()
if not lm_in_toolbar and not lm_in_menubar:
error_dialog(
self,
_('Location manager missing'),
_('The Location manager must be in either the main toolbar or the menubar when a device is connected.'
),
show=True)
raise AbortCommit()
# Save data.
for am, cm in self.models.values():
cm.commit()
return False
def restore_defaults(self):
for am, cm in self.models.values():
cm.restore_defaults()
am.restore_defaults()
self.changed_signal.emit()
def refresh_gui(self, gui):
gui.bars_manager.init_bars()
gui.bars_manager.update_bars()
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
test_widget('Interface', 'Toolbar')
error_dialog(self, _('Invalid folder'),
_('You must specify an existing folder as your '
'auto-add folder. %s does not exist.')%path,
show=True)
raise AbortCommit('invalid auto-add folder')
if not os.access(path, os.R_OK|os.W_OK):
error_dialog(self, _('Invalid folder'),
_('You do not have read/write permissions for '
'the folder: %s')%path, show=True)
raise AbortCommit('invalid auto-add folder')
if not question_dialog(self, _('Are you sure?'),
_('<b>WARNING:</b> Any files you place in %s will be '
'automatically deleted after being added to '
'calibre. Are you sure?')%path):
return
pattern = self.filename_pattern.commit()
prefs['filename_pattern'] = pattern
fmts = self.current_blocked_auto_formats
old = gprefs['blocked_auto_formats']
changed = set(fmts) != set(old)
if changed:
gprefs['blocked_auto_formats'] = self.current_blocked_auto_formats
ret = ConfigWidgetBase.commit(self)
return changed or ret
if __name__ == '__main__':
from PyQt4.Qt import QApplication
app = QApplication([])
test_widget('Import/Export', 'Adding')
return
self.view.scrollTo(idx)
self.view.selectionModel().select(
idx,
self.view.selectionModel().ClearAndSelect)
self.view.setCurrentIndex(idx)
def find_next(self, *args):
idx = self.view.currentIndex()
if not idx.isValid():
idx = self._model.index(0)
idx = self._model.find_next(idx, unicode(self.search.currentText()))
self.highlight_index(idx)
def find_previous(self, *args):
idx = self.view.currentIndex()
if not idx.isValid():
idx = self._model.index(0)
idx = self._model.find_next(idx,
unicode(self.search.currentText()),
backwards=True)
self.highlight_index(idx)
if __name__ == '__main__':
print(Qt.CustomContextMenu)
app = QApplication([])
# Tweaks()
# test_widget
test_widget('Advanced', 'Tweaks')
def up_input(self, *args):
idx = self.opt_input_order.currentRow()
if idx > 0:
self.opt_input_order.insertItem(idx-1, self.opt_input_order.takeItem(idx))
self.opt_input_order.setCurrentRow(idx-1)
self.changed_signal.emit()
def down_input(self, *args):
idx = self.opt_input_order.currentRow()
if idx < self.opt_input_order.count()-1:
self.opt_input_order.insertItem(idx+1, self.opt_input_order.takeItem(idx))
self.opt_input_order.setCurrentRow(idx+1)
self.changed_signal.emit()
# }}}
def reset_confirmation_dialogs(self, *args):
for key in dynamic.keys():
if key.endswith('_again') and dynamic[key] is False:
dynamic[key] = True
gprefs['questions_to_auto_skip'] = []
info_dialog(self, _('Done'),
_('Confirmation dialogs have all been reset'), show=True)
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Interface', 'Behavior')
return ConfigWidgetBase.commit(self)
def make_default(self, *args):
self._email_accounts.make_default(self.email_view.currentIndex())
self.changed_signal.emit()
def add_email_account(self, *args):
index = self._email_accounts.add()
self.email_view.setCurrentIndex(index)
self.email_view.resizeColumnsToContents()
self.email_view.edit(index)
self.changed_signal.emit()
def remove_email_account(self, *args):
idx = self.email_view.currentIndex()
self._email_accounts.remove(idx)
self.changed_signal.emit()
def refresh_gui(self, gui):
from calibre.gui2.email import gui_sendmail
gui_sendmail.calculate_rate_limit()
if __name__ == "__main__":
from PyQt4.Qt import QApplication
app = QApplication([])
test_widget("Sharing", "Email")
try:
self.pc.finished.diconnect()
except:
pass
self.stack.setCurrentIndex(0)
self.stack.removeWidget(self.pc)
self.pc = None
def initialize(self):
ConfigWidgetBase.initialize(self)
self.sources_model.initialize()
self.sources_view.resizeColumnsToContents()
self.fields_model.initialize()
def restore_defaults(self):
ConfigWidgetBase.restore_defaults(self)
self.sources_model.restore_defaults()
self.fields_model.restore_defaults()
self.changed_signal.emit()
def commit(self):
self.sources_model.commit()
self.fields_model.commit()
return ConfigWidgetBase.commit(self)
if __name__ == '__main__':
from PyQt4.Qt import QApplication
app = QApplication([])
test_widget('Sharing', 'Metadata download')
self.proxy['aliases'] = self._email_accounts.aliases
self.proxy['tags'] = self._email_accounts.tags
return ConfigWidgetBase.commit(self)
def make_default(self, *args):
self._email_accounts.make_default(self.email_view.currentIndex())
self.changed_signal.emit()
def add_email_account(self, *args):
index = self._email_accounts.add()
self.email_view.setCurrentIndex(index)
self.email_view.resizeColumnsToContents()
self.email_view.edit(index)
self.changed_signal.emit()
def remove_email_account(self, *args):
idx = self.email_view.currentIndex()
self._email_accounts.remove(idx)
self.changed_signal.emit()
def refresh_gui(self, gui):
from calibre.gui2.email import gui_sendmail
gui_sendmail.calculate_rate_limit()
if __name__ == '__main__':
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget('Sharing', 'Email')
al = QPlainTextEdit(d)
layout.addWidget(al)
try:
al.setPlainText(open(log_access_file, "rb").read().decode("utf8", "replace"))
except IOError:
al.setPlainText("No access log found")
bx = QDialogButtonBox(QDialogButtonBox.Ok)
layout.addWidget(bx)
bx.accepted.connect(d.accept)
d.show()
def commit(self):
ConfigWidgetBase.commit(self)
warning_dialog(
self, _("Restart needed"), _("You need to restart the server for changes to" " take effect"), show=True
)
return False
def refresh_gui(self, gui):
gui.content_server = self.server
if gui.content_server is not None:
gui.content_server.state_callback = Dispatcher(gui.iactions["Connect Share"].content_server_state_changed)
gui.content_server.state_callback(gui.content_server.is_running)
if __name__ == "__main__":
from PyQt5.Qt import QApplication
app = QApplication([])
test_widget("Sharing", "Server")
