def addColumnCategory(self, name, columns, visible=True):
qa = QAction(name, self)
qa.setCheckable(True)
qa.setChecked(visible)
if not visible:
self._showColumnCategory(columns, False)
qa.toggled[bool].connect(
self._currier.curry(self._showColumnCategory, columns))
self._column_views.append((name, qa, columns))
def _createEncodingAction(self, codecName, activeCodecName, menu):
'''
@param: codecName QString
@param: activeCodecName QString
@param: menu QMenu
'''
action = QAction(codecName, menu)
action.setData(codecName)
action.setCheckable(True)
action.triggered.connect(self._changeEncoding)
if activeCodecName.lower() == codecName.lower():
action.setChecked(True)
return action
def _init(self):
menu = self._interface.getMaViewerIndicatorParentMenu()
maIndicatorMenu = menu.addMenu('均线视图指标')
# OHLC
openAction = QAction('开盘价', maIndicatorMenu)
openAction.triggered.connect(self._act)
openAction.setCheckable(True)
maIndicatorMenu.addAction(openAction)
highAction = QAction('最高价', maIndicatorMenu)
highAction.triggered.connect(self._act)
highAction.setCheckable(True)
maIndicatorMenu.addAction(highAction)
lowAction = QAction('最低价', maIndicatorMenu)
lowAction.triggered.connect(self._act)
lowAction.setCheckable(True)
maIndicatorMenu.addAction(lowAction)
closeAction = QAction('收盘价', maIndicatorMenu)
closeAction.triggered.connect(self._act)
closeAction.setCheckable(True)
maIndicatorMenu.addAction(closeAction)
self._actions = [(openAction, 'open'), (highAction, 'high'), (lowAction, 'low'), (closeAction, 'close')]
closeAction.setChecked(True)
self._checkedAction = closeAction
self._checkedIndicator = 'close'
def _init(self):
menu = self._interface.getMaViewerIndicatorParentMenu()
maIndicatorMenu = menu.addMenu('均线视图指标')
# OHLC
openAction = QAction('开盘价', maIndicatorMenu)
openAction.triggered.connect(self._act)
openAction.setCheckable(True)
maIndicatorMenu.addAction(openAction)
highAction = QAction('最高价', maIndicatorMenu)
highAction.triggered.connect(self._act)
highAction.setCheckable(True)
maIndicatorMenu.addAction(highAction)
lowAction = QAction('最低价', maIndicatorMenu)
lowAction.triggered.connect(self._act)
lowAction.setCheckable(True)
maIndicatorMenu.addAction(lowAction)
closeAction = QAction('收盘价', maIndicatorMenu)
closeAction.triggered.connect(self._act)
closeAction.setCheckable(True)
maIndicatorMenu.addAction(closeAction)
self._actions = [(openAction, 'open'), (highAction, 'high'),
(lowAction, 'low'), (closeAction, 'close')]
closeAction.setChecked(True)
self._checkedAction = closeAction
self._checkedIndicator = 'close'
def _createAction(self, actionid, icon, text,
tooltip, slot, toggled=False):
"""
Creates the new internal action with given identifier.
"""
action = QAction(icon, text, self)
action.setToolTip(text)
action.setStatusTip(tooltip)
action.setCheckable(toggled)
if slot is not None:
if action.isCheckable():
action.toggled.connect(slot)
else:
action.triggered.connect(slot)
self._actions[actionid] = action
return action
def contextMenuEvent(self, event):
'''
@param: event QContextMenuEvent
'''
if not self._menu:
self._menu = QMenu(self)
for idx in range(self.count()):
act = QAction(self.model().headerData(idx, Qt.Horizontal),
self._menu)
act.setCheckable(True)
act.setData(idx)
act.triggered.connect(self._toggleSectionVisibility)
self._menu.addAction(act)
for idx, act in enumerate(self._menu.actions()):
act.setEnabled(idx > 0)
act.setChecked(not self.isSectionHidden(idx))
self._menu.popup(event.globalPos())
def __init__(self, parent=None):
QTextEdit.__init__(self, parent)
self.setTabChangesFocus(True)
self.document().setDefaultStyleSheet(css())
font = self.font()
f = QFontInfo(font)
delta = tweaks['change_book_details_font_size_by'] + 1
if delta:
font.setPixelSize(f.pixelSize() + delta)
self.setFont(font)
f = QFontMetrics(self.font())
self.em_size = f.horizontalAdvance('m')
self.base_url = None
self._parent = weakref.ref(parent)
self.comments_pat = re.compile(r'<!--.*?-->', re.DOTALL)
extra_shortcuts = {
'bold': 'Bold',
'italic': 'Italic',
'underline': 'Underline',
}
for rec in (
('bold', 'format-text-bold', _('Bold'), True),
('italic', 'format-text-italic', _('Italic'), True),
('underline', 'format-text-underline', _('Underline'), True),
('strikethrough', 'format-text-strikethrough', _('Strikethrough'), True),
('superscript', 'format-text-superscript', _('Superscript'), True),
('subscript', 'format-text-subscript', _('Subscript'), True),
('ordered_list', 'format-list-ordered', _('Ordered list'), True),
('unordered_list', 'format-list-unordered', _('Unordered list'), True),
('align_left', 'format-justify-left', _('Align left'), True),
('align_center', 'format-justify-center', _('Align center'), True),
('align_right', 'format-justify-right', _('Align right'), True),
('align_justified', 'format-justify-fill', _('Align justified'), True),
('undo', 'edit-undo', _('Undo'), ),
('redo', 'edit-redo', _('Redo'), ),
('remove_format', 'edit-clear', _('Remove formatting'), ),
('copy', 'edit-copy', _('Copy'), ),
('paste', 'edit-paste', _('Paste'), ),
('paste_and_match_style', 'edit-paste', _('Paste and match style'), ),
('cut', 'edit-cut', _('Cut'), ),
('indent', 'format-indent-more', _('Increase indentation'), ),
('outdent', 'format-indent-less', _('Decrease indentation'), ),
('select_all', 'edit-select-all', _('Select all'), ),
('color', 'format-text-color', _('Foreground color')),
('background', 'format-fill-color', _('Background color')),
('insert_link', 'insert-link', _('Insert link or image'),),
('insert_hr', 'format-text-hr', _('Insert separator'),),
('clear', 'trash', _('Clear')),
):
name, icon, text = rec[:3]
checkable = len(rec) == 4
ac = QAction(QIcon(I(icon + '.png')), text, self)
if checkable:
ac.setCheckable(checkable)
setattr(self, 'action_'+name, ac)
ss = extra_shortcuts.get(name)
if ss is not None:
ac.setShortcut(QKeySequence(getattr(QKeySequence, ss)))
ac.triggered.connect(getattr(self, 'do_' + name))
self.action_block_style = QAction(QIcon(I('format-text-heading.png')),
_('Style text block'), self)
self.action_block_style.setToolTip(
_('Style the selected text block'))
self.block_style_menu = QMenu(self)
self.action_block_style.setMenu(self.block_style_menu)
self.block_style_actions = []
h = _('Heading {0}')
for text, name in (
(_('Normal'), 'p'),
(h.format(1), 'h1'),
(h.format(2), 'h2'),
(h.format(3), 'h3'),
(h.format(4), 'h4'),
(h.format(5), 'h5'),
(h.format(6), 'h6'),
(_('Blockquote'), 'blockquote'),
):
ac = QAction(text, self)
self.block_style_menu.addAction(ac)
ac.block_name = name
ac.setCheckable(True)
self.block_style_actions.append(ac)
ac.triggered.connect(self.do_format_block)
self.setHtml('')
self.copyAvailable.connect(self.update_clipboard_actions)
self.update_clipboard_actions(False)
self.selectionChanged.connect(self.update_selection_based_actions)
self.update_selection_based_actions()
connect_lambda(self.undoAvailable, self, lambda self, yes: self.action_undo.setEnabled(yes))
connect_lambda(self.redoAvailable, self, lambda self, yes: self.action_redo.setEnabled(yes))
self.action_undo.setEnabled(False), self.action_redo.setEnabled(False)
self.textChanged.connect(self.update_cursor_position_actions)
self.cursorPositionChanged.connect(self.update_cursor_position_actions)
self.textChanged.connect(self.data_changed)
self.update_cursor_position_actions()
class EbookViewer(MainWindow):
STATE_VERSION = 2
FLOW_MODE_TT = _('Switch to paged mode - where the text is broken up '
'into pages like a paper book')
PAGED_MODE_TT = _('Switch to flow mode - where the text is not broken up '
'into pages')
def __init__(self, pathtoebook=None, debug_javascript=False, open_at=None,
start_in_fullscreen=False):
MainWindow.__init__(self, debug_javascript)
self.view.magnification_changed.connect(self.magnification_changed)
self.show_toc_on_open = False
self.current_book_has_toc = False
self.iterator = None
self.current_page = None
self.pending_search = None
self.pending_search_dir= None
self.pending_anchor = None
self.pending_reference = None
self.pending_bookmark = None
self.pending_restore = False
self.cursor_hidden = False
self.existing_bookmarks= []
self.selected_text = None
self.was_maximized = False
self.page_position_on_footnote_toggle = []
self.read_settings()
self.pos.value_changed.connect(self.update_pos_label)
self.pos.setMinimumWidth(150)
self.setFocusPolicy(Qt.StrongFocus)
self.view.set_manager(self)
self.pi = ProgressIndicator(self)
self.action_quit = QAction(_('&Quit'), self)
self.addAction(self.action_quit)
self.view_resized_timer = QTimer(self)
self.view_resized_timer.timeout.connect(self.viewport_resize_finished)
self.view_resized_timer.setSingleShot(True)
self.resize_in_progress = False
self.action_reload = QAction(_('&Reload book'), self)
self.action_reload.triggered.connect(self.reload_book)
self.action_quit.triggered.connect(self.quit)
self.action_reference_mode.triggered[bool].connect(self.view.reference_mode)
self.action_metadata.triggered[bool].connect(self.metadata.setVisible)
self.action_table_of_contents.toggled[bool].connect(self.set_toc_visible)
self.action_copy.triggered[bool].connect(self.copy)
self.action_font_size_larger.triggered.connect(self.font_size_larger)
self.action_font_size_smaller.triggered.connect(self.font_size_smaller)
self.action_open_ebook.triggered[bool].connect(self.open_ebook)
self.action_next_page.triggered.connect(self.view.next_page)
self.action_previous_page.triggered.connect(self.view.previous_page)
self.action_find_next.triggered.connect(self.find_next)
self.action_find_previous.triggered.connect(self.find_previous)
self.action_full_screen.triggered[bool].connect(self.toggle_fullscreen)
self.action_back.triggered[bool].connect(self.back)
self.action_forward.triggered[bool].connect(self.forward)
self.action_preferences.triggered.connect(self.do_config)
self.pos.editingFinished.connect(self.goto_page_num)
self.vertical_scrollbar.valueChanged[int].connect(lambda
x:self.goto_page(x/100.))
self.search.search.connect(self.find)
self.search.focus_to_library.connect(lambda: self.view.setFocus(Qt.OtherFocusReason))
self.toc.pressed[QModelIndex].connect(self.toc_clicked)
self.toc.searched.connect(partial(self.toc_clicked, force=True))
self.reference.goto.connect(self.goto)
self.bookmarks.edited.connect(self.bookmarks_edited)
self.bookmarks.activated.connect(self.goto_bookmark)
self.bookmarks.create_requested.connect(self.bookmark)
self.set_bookmarks([])
self.load_theme_menu()
if pathtoebook is not None:
f = functools.partial(self.load_ebook, pathtoebook, open_at=open_at)
QTimer.singleShot(50, f)
self.window_mode_changed = None
self.toggle_toolbar_action = QAction(_('Show/hide controls'), self)
self.toggle_toolbar_action.setCheckable(True)
self.toggle_toolbar_action.triggered.connect(self.toggle_toolbars)
self.toolbar_hidden = None
self.addAction(self.toggle_toolbar_action)
self.full_screen_label_anim = QPropertyAnimation(
self.full_screen_label, 'size')
self.clock_timer = QTimer(self)
self.clock_timer.timeout.connect(self.update_clock)
self.action_print.triggered.connect(self.print_book)
self.print_menu.actions()[0].triggered.connect(self.print_preview)
self.clear_recent_history_action = QAction(
_('Clear list of recently opened books'), self)
self.clear_recent_history_action.triggered.connect(self.clear_recent_history)
self.build_recent_menu()
self.open_history_menu.triggered.connect(self.open_recent)
for x in ('tool_bar', 'tool_bar2'):
x = getattr(self, x)
for action in x.actions():
# So that the keyboard shortcuts for these actions will
# continue to function even when the toolbars are hidden
self.addAction(action)
for plugin in self.view.document.all_viewer_plugins:
plugin.customize_ui(self)
self.view.document.settings_changed.connect(self.settings_changed)
self.restore_state()
self.settings_changed()
self.action_toggle_paged_mode.toggled[bool].connect(self.toggle_paged_mode)
if (start_in_fullscreen or self.view.document.start_in_fullscreen):
self.action_full_screen.trigger()
self.hide_cursor_timer = t = QTimer(self)
t.setSingleShot(True), t.setInterval(3000)
t.timeout.connect(self.hide_cursor)
t.start()
def eventFilter(self, obj, ev):
if ev.type() == ev.MouseMove:
if self.cursor_hidden:
self.cursor_hidden = False
QApplication.instance().restoreOverrideCursor()
self.hide_cursor_timer.start()
return False
def hide_cursor(self):
self.cursor_hidden = True
QApplication.instance().setOverrideCursor(Qt.BlankCursor)
def toggle_paged_mode(self, checked, at_start=False):
in_paged_mode = not self.action_toggle_paged_mode.isChecked()
self.view.document.in_paged_mode = in_paged_mode
self.action_toggle_paged_mode.setToolTip(self.FLOW_MODE_TT if
self.action_toggle_paged_mode.isChecked() else
self.PAGED_MODE_TT)
if at_start:
return
self.reload()
def settings_changed(self):
for x in ('', '2'):
x = getattr(self, 'tool_bar'+x)
x.setVisible(self.view.document.show_controls)
def reload(self):
if hasattr(self, 'current_index') and self.current_index > -1:
self.view.document.page_position.save(overwrite=False)
self.pending_restore = True
self.load_path(self.view.last_loaded_path)
def set_toc_visible(self, yes):
self.toc_dock.setVisible(yes)
if not yes:
self.show_toc_on_open = False
def clear_recent_history(self, *args):
vprefs.set('viewer_open_history', [])
self.build_recent_menu()
def build_recent_menu(self):
m = self.open_history_menu
m.clear()
recent = vprefs.get('viewer_open_history', [])
if recent:
m.addAction(self.clear_recent_history_action)
m.addSeparator()
count = 0
for path in recent:
if count > 9:
break
if os.path.exists(path):
m.addAction(RecentAction(path, m))
count += 1
def shutdown(self):
if self.isFullScreen() and not self.view.document.start_in_fullscreen:
self.action_full_screen.trigger()
return False
self.save_state()
return True
def quit(self):
if self.shutdown():
QApplication.instance().quit()
def closeEvent(self, e):
if self.shutdown():
return MainWindow.closeEvent(self, e)
else:
e.ignore()
def toggle_toolbars(self):
for x in ('tool_bar', 'tool_bar2'):
x = getattr(self, x)
x.setVisible(not x.isVisible())
def save_state(self):
state = bytearray(self.saveState(self.STATE_VERSION))
vprefs['main_window_state'] = state
if not self.isFullScreen():
vprefs.set('viewer_window_geometry', bytearray(self.saveGeometry()))
if self.current_book_has_toc:
vprefs.set('viewer_toc_isvisible', self.show_toc_on_open or bool(self.toc_dock.isVisible()))
vprefs['multiplier'] = self.view.multiplier
vprefs['in_paged_mode'] = not self.action_toggle_paged_mode.isChecked()
def restore_state(self):
state = vprefs.get('main_window_state', None)
if state is not None:
try:
state = QByteArray(state)
self.restoreState(state, self.STATE_VERSION)
except:
pass
self.initialize_dock_state()
mult = vprefs.get('multiplier', None)
if mult:
self.view.multiplier = mult
# On windows Qt lets the user hide toolbars via a right click in a very
# specific location, ensure they are visible.
self.tool_bar.setVisible(True)
self.tool_bar2.setVisible(True)
self.toc_dock.close() # This will be opened on book open, if the book has a toc and it was previously opened
self.action_toggle_paged_mode.setChecked(not vprefs.get('in_paged_mode',
True))
self.toggle_paged_mode(self.action_toggle_paged_mode.isChecked(),
at_start=True)
def lookup(self, word):
from urllib import quote
word = quote(word.encode('utf-8'))
try:
url = lookup_website(canonicalize_lang(self.view.current_language) or 'en').format(word=word)
except Exception:
traceback.print_exc()
url = default_lookup_website(canonicalize_lang(self.view.current_language) or 'en').format(word=word)
open_url(url)
def print_book(self):
p = Printing(self.iterator, self)
p.start_print()
def print_preview(self):
p = Printing(self.iterator, self)
p.start_preview()
def toggle_fullscreen(self):
if self.isFullScreen():
self.showNormal()
else:
self.showFullScreen()
def showFullScreen(self):
self.view.document.page_position.save()
self.window_mode_changed = 'fullscreen'
self.tool_bar.setVisible(False)
self.tool_bar2.setVisible(False)
self.was_maximized = self.isMaximized()
if not self.view.document.fullscreen_scrollbar:
self.vertical_scrollbar.setVisible(False)
super(EbookViewer, self).showFullScreen()
def show_full_screen_label(self):
f = self.full_screen_label
height = f.final_height
width = int(0.7*self.view.width())
f.resize(width, height)
if self.view.document.show_fullscreen_help:
f.setVisible(True)
a = self.full_screen_label_anim
a.setDuration(500)
a.setStartValue(QSize(width, 0))
a.setEndValue(QSize(width, height))
a.start()
QTimer.singleShot(3500, self.full_screen_label.hide)
self.view.document.switch_to_fullscreen_mode()
if self.view.document.fullscreen_clock:
self.show_clock()
if self.view.document.fullscreen_pos:
self.show_pos_label()
self.relayout_fullscreen_labels()
def show_clock(self):
self.clock_label.setVisible(True)
self.clock_label.setText(QTime(22, 33,
33).toString(Qt.SystemLocaleShortDate))
self.clock_timer.start(1000)
self.clock_label.setStyleSheet(self.info_label_style%(
'rgba(0, 0, 0, 0)', self.view.document.colors()[1]))
self.clock_label.resize(self.clock_label.sizeHint())
self.update_clock()
def show_pos_label(self):
self.pos_label.setVisible(True)
self.pos_label.setStyleSheet(self.info_label_style%(
'rgba(0, 0, 0, 0)', self.view.document.colors()[1]))
self.update_pos_label()
def relayout_fullscreen_labels(self):
vswidth = (self.vertical_scrollbar.width() if
self.vertical_scrollbar.isVisible() else 0)
p = self.pos_label
p.move(15, p.parent().height() - p.height()-10)
c = self.clock_label
c.move(c.parent().width() - vswidth - 15 - c.width(), c.parent().height() - c.height() - 10)
f = self.full_screen_label
f.move((f.parent().width() - f.width())//2, (f.parent().height() - f.final_height)//2)
def update_clock(self):
self.clock_label.setText(QTime.currentTime().toString(Qt.SystemLocaleShortDate))
def update_pos_label(self, *args):
if self.pos_label.isVisible():
try:
value, maximum = args
except:
value, maximum = self.pos.value(), self.pos.maximum()
text = '%g/%g'%(value, maximum)
self.pos_label.setText(text)
self.pos_label.resize(self.pos_label.sizeHint())
def showNormal(self):
self.view.document.page_position.save()
self.clock_label.setVisible(False)
self.pos_label.setVisible(False)
self.clock_timer.stop()
self.vertical_scrollbar.setVisible(True)
self.window_mode_changed = 'normal'
self.settings_changed()
self.full_screen_label.setVisible(False)
if self.was_maximized:
super(EbookViewer, self).showMaximized()
else:
super(EbookViewer, self).showNormal()
def handle_window_mode_toggle(self):
if self.window_mode_changed:
fs = self.window_mode_changed == 'fullscreen'
self.window_mode_changed = None
if fs:
self.show_full_screen_label()
else:
self.view.document.switch_to_window_mode()
self.view.document.page_position.restore()
self.scrolled(self.view.scroll_fraction)
def goto(self, ref):
if ref:
tokens = ref.split('.')
if len(tokens) > 1:
spine_index = int(tokens[0]) -1
if spine_index == self.current_index:
self.view.goto(ref)
else:
self.pending_reference = ref
self.load_path(self.iterator.spine[spine_index])
def goto_bookmark(self, bm):
spine_index = bm['spine']
if spine_index > -1 and self.current_index == spine_index:
if self.resize_in_progress:
self.view.document.page_position.set_pos(bm['pos'])
else:
self.view.goto_bookmark(bm)
# Going to a bookmark does not call scrolled() so we update the
# page position explicitly. Use a timer to ensure it is
# accurate.
QTimer.singleShot(100, self.update_page_number)
else:
self.pending_bookmark = bm
if spine_index < 0 or spine_index >= len(self.iterator.spine):
spine_index = 0
self.pending_bookmark = None
self.load_path(self.iterator.spine[spine_index])
def toc_clicked(self, index, force=False):
if force or QApplication.mouseButtons() & Qt.LeftButton:
item = self.toc_model.itemFromIndex(index)
if item.abspath is not None:
if not os.path.exists(item.abspath):
return error_dialog(self, _('No such location'),
_('The location pointed to by this item'
' does not exist.'), det_msg=item.abspath, show=True)
url = QUrl.fromLocalFile(item.abspath)
if item.fragment:
url.setFragment(item.fragment)
self.link_clicked(url)
self.view.setFocus(Qt.OtherFocusReason)
def selection_changed(self, selected_text):
self.selected_text = selected_text.strip()
self.action_copy.setEnabled(bool(self.selected_text))
def copy(self, x):
if self.selected_text:
QApplication.clipboard().setText(self.selected_text)
def back(self, x):
pos = self.history.back(self.pos.value())
if pos is not None:
self.goto_page(pos)
def goto_page_num(self):
num = self.pos.value()
self.goto_page(num)
def forward(self, x):
pos = self.history.forward(self.pos.value())
if pos is not None:
self.goto_page(pos)
def goto_start(self):
self.goto_page(1)
def goto_end(self):
self.goto_page(self.pos.maximum())
def goto_page(self, new_page, loaded_check=True):
if self.current_page is not None or not loaded_check:
for page in self.iterator.spine:
if new_page >= page.start_page and new_page <= page.max_page:
try:
frac = float(new_page-page.start_page)/(page.pages-1)
except ZeroDivisionError:
frac = 0
if page == self.current_page:
self.view.scroll_to(frac)
else:
self.load_path(page, pos=frac)
def open_ebook(self, checked):
files = choose_files(self, 'ebook viewer open dialog',
_('Choose ebook'),
[(_('Ebooks'), available_input_formats())],
all_files=False,
select_only_single_file=True)
if files:
self.load_ebook(files[0])
def open_recent(self, action):
self.load_ebook(action.path)
def font_size_larger(self):
self.view.magnify_fonts()
def font_size_smaller(self):
self.view.shrink_fonts()
def magnification_changed(self, val):
tt = '%(action)s [%(sc)s]\n'+_('Current magnification: %(mag).1f')
sc = _(' or ').join(self.view.shortcuts.get_shortcuts('Font larger'))
self.action_font_size_larger.setToolTip(
tt %dict(action=unicode(self.action_font_size_larger.text()),
mag=val, sc=sc))
sc = _(' or ').join(self.view.shortcuts.get_shortcuts('Font smaller'))
self.action_font_size_smaller.setToolTip(
tt %dict(action=unicode(self.action_font_size_smaller.text()),
mag=val, sc=sc))
self.action_font_size_larger.setEnabled(self.view.multiplier < 3)
self.action_font_size_smaller.setEnabled(self.view.multiplier > 0.2)
def find(self, text, repeat=False, backwards=False):
if not text:
self.view.search('')
return self.search.search_done(False)
if self.view.search(text, backwards=backwards):
self.scrolled(self.view.scroll_fraction)
return self.search.search_done(True)
index = self.iterator.search(text, self.current_index,
backwards=backwards)
if index is None:
if self.current_index > 0:
index = self.iterator.search(text, 0)
if index is None:
info_dialog(self, _('No matches found'),
_('No matches found for: %s')%text).exec_()
return self.search.search_done(True)
return self.search.search_done(True)
self.pending_search = text
self.pending_search_dir = 'backwards' if backwards else 'forwards'
self.load_path(self.iterator.spine[index])
def find_next(self):
self.find(unicode(self.search.text()), repeat=True)
def find_previous(self):
self.find(unicode(self.search.text()), repeat=True, backwards=True)
def do_search(self, text, backwards):
self.pending_search = None
self.pending_search_dir = None
if self.view.search(text, backwards=backwards):
self.scrolled(self.view.scroll_fraction)
def internal_link_clicked(self, prev_pos):
self.history.add(prev_pos)
def link_clicked(self, url):
path = os.path.abspath(unicode(url.toLocalFile()))
frag = None
if path in self.iterator.spine:
self.update_page_number() # Ensure page number is accurate as it is used for history
self.history.add(self.pos.value())
path = self.iterator.spine[self.iterator.spine.index(path)]
if url.hasFragment():
frag = unicode(url.fragment())
if path != self.current_page:
self.pending_anchor = frag
self.load_path(path)
else:
oldpos = self.view.document.ypos
if frag:
self.view.scroll_to(frag)
else:
# Scroll to top
self.view.scroll_to(0)
if self.view.document.ypos == oldpos:
# If we are coming from goto_next_section() call this will
# cause another goto next section call with the next toc
# entry, since this one did not cause any scrolling at all.
QTimer.singleShot(10, self.update_indexing_state)
else:
open_url(url)
def load_started(self):
self.open_progress_indicator(_('Loading flow...'))
def load_finished(self, ok):
self.close_progress_indicator()
path = self.view.path()
try:
index = self.iterator.spine.index(path)
except (ValueError, AttributeError):
return -1
self.current_page = self.iterator.spine[index]
self.current_index = index
self.set_page_number(self.view.scroll_fraction)
QTimer.singleShot(100, self.update_indexing_state)
if self.pending_search is not None:
self.do_search(self.pending_search,
self.pending_search_dir=='backwards')
self.pending_search = None
self.pending_search_dir = None
if self.pending_anchor is not None:
self.view.scroll_to(self.pending_anchor)
self.pending_anchor = None
if self.pending_reference is not None:
self.view.goto(self.pending_reference)
self.pending_reference = None
if self.pending_bookmark is not None:
self.goto_bookmark(self.pending_bookmark)
self.pending_bookmark = None
if self.pending_restore:
self.view.document.page_position.restore()
return self.current_index
def goto_next_section(self):
if hasattr(self, 'current_index'):
entry = self.toc_model.next_entry(self.current_index,
self.view.document.read_anchor_positions(),
self.view.viewport_rect, self.view.document.in_paged_mode)
if entry is not None:
self.pending_goto_next_section = (
self.toc_model.currently_viewed_entry, entry, False)
self.toc_clicked(entry.index(), force=True)
def goto_previous_section(self):
if hasattr(self, 'current_index'):
entry = self.toc_model.next_entry(self.current_index,
self.view.document.read_anchor_positions(),
self.view.viewport_rect, self.view.document.in_paged_mode,
backwards=True)
if entry is not None:
self.pending_goto_next_section = (
self.toc_model.currently_viewed_entry, entry, True)
self.toc_clicked(entry.index(), force=True)
def update_indexing_state(self, anchor_positions=None):
pgns = getattr(self, 'pending_goto_next_section', None)
if hasattr(self, 'current_index'):
if anchor_positions is None:
anchor_positions = self.view.document.read_anchor_positions()
items = self.toc_model.update_indexing_state(self.current_index,
self.view.viewport_rect, anchor_positions,
self.view.document.in_paged_mode)
if items:
self.toc.scrollTo(items[-1].index())
if pgns is not None:
self.pending_goto_next_section = None
# Check that we actually progressed
if pgns[0] is self.toc_model.currently_viewed_entry:
entry = self.toc_model.next_entry(self.current_index,
self.view.document.read_anchor_positions(),
self.view.viewport_rect,
self.view.document.in_paged_mode,
backwards=pgns[2], current_entry=pgns[1])
if entry is not None:
self.pending_goto_next_section = (
self.toc_model.currently_viewed_entry, entry,
pgns[2])
self.toc_clicked(entry.index(), force=True)
def load_path(self, path, pos=0.0):
self.open_progress_indicator(_('Laying out %s')%self.current_title)
self.view.load_path(path, pos=pos)
def footnote_visibility_changed(self, is_visible):
if self.view.document.in_paged_mode:
pp = namedtuple('PagePosition', 'time is_visible page_dimensions multiplier last_loaded_path page_number after_resize_page_number')
self.page_position_on_footnote_toggle.append(pp(
time.time(), is_visible, self.view.document.page_dimensions, self.view.multiplier,
self.view.last_loaded_path, self.view.document.page_number, None))
def pre_footnote_toggle_position(self):
num = len(self.page_position_on_footnote_toggle)
if self.view.document.in_paged_mode and num > 1 and num % 2 == 0:
two, one = self.page_position_on_footnote_toggle.pop(), self.page_position_on_footnote_toggle.pop()
if (
time.time() - two.time < 1 and not two.is_visible and one.is_visible and
one.last_loaded_path == two.last_loaded_path and two.last_loaded_path == self.view.last_loaded_path and
one.page_dimensions == self.view.document.page_dimensions and one.multiplier == self.view.multiplier and
one.after_resize_page_number == self.view.document.page_number
):
return one.page_number
def viewport_resize_started(self, event):
if not self.resize_in_progress:
# First resize, so save the current page position
self.resize_in_progress = True
if not self.window_mode_changed:
# The special handling for window mode changed will already
# have saved page position, so only save it if this is not a
# mode change
self.view.document.page_position.save()
if self.resize_in_progress:
self.view_resized_timer.start(75)
def viewport_resize_finished(self):
# There hasn't been a resize event for some time
# restore the current page position.
self.resize_in_progress = False
wmc = self.window_mode_changed
if self.window_mode_changed:
# This resize is part of a window mode change, special case it
self.handle_window_mode_toggle()
else:
if self.isFullScreen():
self.relayout_fullscreen_labels()
self.view.document.after_resize()
if not wmc:
pre_footnote_pos = self.pre_footnote_toggle_position()
if pre_footnote_pos is not None:
self.view.document.page_number = pre_footnote_pos
else:
self.view.document.page_position.restore()
self.update_page_number()
if len(self.page_position_on_footnote_toggle) % 2 == 1:
self.page_position_on_footnote_toggle[-1] = self.page_position_on_footnote_toggle[-1]._replace(
after_resize_page_number=self.view.document.page_number)
def update_page_number(self):
self.set_page_number(self.view.document.scroll_fraction)
return self.pos.value()
def close_progress_indicator(self):
self.pi.stop()
for o in ('tool_bar', 'tool_bar2', 'view', 'horizontal_scrollbar', 'vertical_scrollbar'):
getattr(self, o).setEnabled(True)
self.unsetCursor()
self.view.setFocus(Qt.PopupFocusReason)
def open_progress_indicator(self, msg=''):
self.pi.start(msg)
for o in ('tool_bar', 'tool_bar2', 'view', 'horizontal_scrollbar', 'vertical_scrollbar'):
getattr(self, o).setEnabled(False)
self.setCursor(Qt.BusyCursor)
def load_theme_menu(self):
from calibre.gui2.viewer.config import load_themes
self.themes_menu.clear()
for key in load_themes():
title = key[len('theme_'):]
self.themes_menu.addAction(title, partial(self.load_theme,
key))
def load_theme(self, theme_id):
self.view.load_theme(theme_id)
def do_config(self):
self.view.config(self)
self.load_theme_menu()
if self.iterator is not None:
self.iterator.copy_bookmarks_to_file = self.view.document.copy_bookmarks_to_file
from calibre.gui2 import config
if not config['viewer_search_history']:
self.search.clear_history()
def bookmark(self, *args):
num = 1
bm = None
while True:
bm = _('Bookmark #%d')%num
if bm not in self.existing_bookmarks:
break
num += 1
title, ok = QInputDialog.getText(self, _('Add bookmark'),
_('Enter title for bookmark:'), text=bm)
title = unicode(title).strip()
if ok and title:
bm = self.view.bookmark()
bm['spine'] = self.current_index
bm['title'] = title
self.iterator.add_bookmark(bm)
self.set_bookmarks(self.iterator.bookmarks)
self.bookmarks.set_current_bookmark(bm)
def bookmarks_edited(self, bookmarks):
self.build_bookmarks_menu(bookmarks)
self.iterator.set_bookmarks(bookmarks)
self.iterator.save_bookmarks()
def build_bookmarks_menu(self, bookmarks):
self.bookmarks_menu.clear()
sc = _(' or ').join(self.view.shortcuts.get_shortcuts('Bookmark'))
self.bookmarks_menu.addAction(_("Bookmark this location [%s]") % sc, self.bookmark)
self.bookmarks_menu.addAction(_("Show/hide Bookmarks"), self.bookmarks_dock.toggleViewAction().trigger)
self.bookmarks_menu.addSeparator()
current_page = None
self.existing_bookmarks = []
for bm in bookmarks:
if bm['title'] == 'calibre_current_page_bookmark':
if self.view.document.remember_current_page:
current_page = bm
else:
self.existing_bookmarks.append(bm['title'])
self.bookmarks_menu.addAction(bm['title'], partial(self.goto_bookmark, bm))
return current_page
def set_bookmarks(self, bookmarks):
self.bookmarks.set_bookmarks(bookmarks)
return self.build_bookmarks_menu(bookmarks)
@property
def current_page_bookmark(self):
bm = self.view.bookmark()
bm['spine'] = self.current_index
bm['title'] = 'calibre_current_page_bookmark'
return bm
def save_current_position(self):
if not self.view.document.remember_current_page:
return
if hasattr(self, 'current_index'):
try:
self.iterator.add_bookmark(self.current_page_bookmark)
except:
traceback.print_exc()
def load_ebook(self, pathtoebook, open_at=None, reopen_at=None):
if self.iterator is not None:
self.save_current_position()
self.iterator.__exit__()
self.iterator = EbookIterator(pathtoebook, copy_bookmarks_to_file=self.view.document.copy_bookmarks_to_file)
self.history.clear()
self.open_progress_indicator(_('Loading ebook...'))
worker = Worker(target=partial(self.iterator.__enter__, view_kepub=True))
worker.start()
while worker.isAlive():
worker.join(0.1)
QApplication.processEvents()
if worker.exception is not None:
if isinstance(worker.exception, DRMError):
from calibre.gui2.dialogs.drm_error import DRMErrorMessage
DRMErrorMessage(self).exec_()
else:
r = getattr(worker.exception, 'reason', worker.exception)
error_dialog(self, _('Could not open ebook'),
as_unicode(r) or _('Unknown error'),
det_msg=worker.traceback, show=True)
self.close_progress_indicator()
else:
self.metadata.show_opf(self.iterator.opf,
self.iterator.book_format)
self.view.current_language = self.iterator.language
title = self.iterator.opf.title
if not title:
title = os.path.splitext(os.path.basename(pathtoebook))[0]
if self.iterator.toc:
self.toc_model = TOC(self.iterator.spine, self.iterator.toc)
self.toc.setModel(self.toc_model)
if self.show_toc_on_open:
self.action_table_of_contents.setChecked(True)
else:
self.toc_model = TOC(self.iterator.spine)
self.toc.setModel(self.toc_model)
self.action_table_of_contents.setChecked(False)
if isbytestring(pathtoebook):
pathtoebook = force_unicode(pathtoebook, filesystem_encoding)
vh = vprefs.get('viewer_open_history', [])
try:
vh.remove(pathtoebook)
except:
pass
vh.insert(0, pathtoebook)
vprefs.set('viewer_open_history', vh[:50])
self.build_recent_menu()
self.footnotes_dock.close()
self.action_table_of_contents.setDisabled(not self.iterator.toc)
self.current_book_has_toc = bool(self.iterator.toc)
self.current_title = title
self.setWindowTitle(title + ' [%s]'%self.iterator.book_format + ' - ' + self.base_window_title)
self.pos.setMaximum(sum(self.iterator.pages))
self.pos.setSuffix(' / %d'%sum(self.iterator.pages))
self.vertical_scrollbar.setMinimum(100)
self.vertical_scrollbar.setMaximum(100*sum(self.iterator.pages))
self.vertical_scrollbar.setSingleStep(10)
self.vertical_scrollbar.setPageStep(100)
self.set_vscrollbar_value(1)
self.current_index = -1
QApplication.instance().alert(self, 5000)
previous = self.set_bookmarks(self.iterator.bookmarks)
if reopen_at is not None:
previous = reopen_at
if open_at is None and previous is not None:
self.goto_bookmark(previous)
else:
if open_at is None:
self.next_document()
else:
if open_at > self.pos.maximum():
open_at = self.pos.maximum()
if open_at < self.pos.minimum():
open_at = self.pos.minimum()
self.goto_page(open_at, loaded_check=False)
def set_vscrollbar_value(self, pagenum):
self.vertical_scrollbar.blockSignals(True)
self.vertical_scrollbar.setValue(int(pagenum*100))
self.vertical_scrollbar.blockSignals(False)
def set_page_number(self, frac):
if getattr(self, 'current_page', None) is not None:
page = self.current_page.start_page + frac*float(self.current_page.pages-1)
self.pos.set_value(page)
self.set_vscrollbar_value(page)
def scrolled(self, frac, onload=False):
self.set_page_number(frac)
if not onload:
ap = self.view.document.read_anchor_positions()
self.update_indexing_state(ap)
def next_document(self):
if (hasattr(self, 'current_index') and self.current_index <
len(self.iterator.spine) - 1):
self.load_path(self.iterator.spine[self.current_index+1])
def previous_document(self):
if hasattr(self, 'current_index') and self.current_index > 0:
self.load_path(self.iterator.spine[self.current_index-1], pos=1.0)
def keyPressEvent(self, event):
if event.key() == Qt.Key_Escape:
if self.metadata.isVisible():
self.metadata.setVisible(False)
event.accept()
return
if self.isFullScreen():
self.action_full_screen.trigger()
event.accept()
return
try:
key = self.view.shortcuts.get_match(event)
except AttributeError:
return MainWindow.keyPressEvent(self, event)
try:
bac = self.bookmarks_menu.actions()[0]
except (AttributeError, TypeError, IndexError, KeyError):
bac = None
action = {
'Quit':self.action_quit,
'Show metadata':self.action_metadata,
'Copy':self.view.copy_action,
'Font larger': self.action_font_size_larger,
'Font smaller': self.action_font_size_smaller,
'Fullscreen': self.action_full_screen,
'Find next': self.action_find_next,
'Find previous': self.action_find_previous,
'Search online': self.view.search_online_action,
'Lookup word': self.view.dictionary_action,
'Next occurrence': self.view.search_action,
'Bookmark': bac,
'Reload': self.action_reload,
'Table of Contents': self.action_table_of_contents,
}.get(key, None)
if action is not None:
event.accept()
action.trigger()
return
if key == 'Focus Search':
self.search.setFocus(Qt.OtherFocusReason)
return
if not self.view.handle_key_press(event):
event.ignore()
def reload_book(self):
if getattr(self.iterator, 'pathtoebook', None):
try:
reopen_at = self.current_page_bookmark
except Exception:
reopen_at = None
self.history.clear()
self.load_ebook(self.iterator.pathtoebook, reopen_at=reopen_at)
return
def __enter__(self):
return self
def __exit__(self, *args):
if self.iterator is not None:
self.save_current_position()
self.iterator.__exit__(*args)
def read_settings(self):
c = config().parse()
if c.remember_window_size:
wg = vprefs.get('viewer_window_geometry', None)
if wg is not None:
self.restoreGeometry(wg)
self.show_toc_on_open = vprefs.get('viewer_toc_isvisible', False)
desktop = QApplication.instance().desktop()
av = desktop.availableGeometry(self).height() - 30
if self.height() > av:
self.resize(self.width(), av)
def show_footnote_view(self):
self.footnotes_dock.show()
class EbookViewer(MainWindow):
STATE_VERSION = 2
FLOW_MODE_TT = _('Switch to paged mode - where the text is broken up '
'into pages like a paper book')
PAGED_MODE_TT = _('Switch to flow mode - where the text is not broken up '
'into pages')
AUTOSAVE_INTERVAL = 10 # seconds
msg_from_anotherinstance = pyqtSignal(object)
def __init__(self, pathtoebook=None, debug_javascript=False, open_at=None,
start_in_fullscreen=False, continue_reading=False, listener=None):
MainWindow.__init__(self, debug_javascript)
self.view.magnification_changed.connect(self.magnification_changed)
self.closed = False
self.show_toc_on_open = False
self.listener = listener
if listener is not None:
t = Thread(name='ConnListener', target=listen, args=(self,))
t.daemon = True
t.start()
self.msg_from_anotherinstance.connect(self.another_instance_wants_to_talk, type=Qt.QueuedConnection)
self.current_book_has_toc = False
self.iterator = None
self.current_page = None
self.pending_search = None
self.pending_search_dir= None
self.pending_anchor = None
self.pending_reference = None
self.pending_bookmark = None
self.pending_restore = False
self.pending_goto_page = None
self.cursor_hidden = False
self.existing_bookmarks= []
self.selected_text = None
self.was_maximized = False
self.page_position_on_footnote_toggle = []
self.read_settings()
self.autosave_timer = t = QTimer(self)
t.setInterval(self.AUTOSAVE_INTERVAL * 1000), t.setSingleShot(True)
t.timeout.connect(self.autosave)
self.pos.value_changed.connect(self.update_pos_label)
self.pos.value_changed.connect(self.autosave_timer.start)
self.pos.setMinimumWidth(150)
self.setFocusPolicy(Qt.StrongFocus)
self.view.set_manager(self)
self.pi = ProgressIndicator(self)
self.action_quit = QAction(_('&Quit'), self)
self.addAction(self.action_quit)
self.view_resized_timer = QTimer(self)
self.view_resized_timer.timeout.connect(self.viewport_resize_finished)
self.view_resized_timer.setSingleShot(True)
self.resize_in_progress = False
self.action_reload = QAction(_('&Reload book'), self)
self.action_reload.triggered.connect(self.reload_book)
self.action_quit.triggered.connect(self.quit)
self.action_reference_mode.triggered[bool].connect(self.view.reference_mode)
self.action_metadata.triggered[bool].connect(self.metadata.setVisible)
self.action_table_of_contents.toggled[bool].connect(self.set_toc_visible)
self.action_copy.triggered[bool].connect(self.copy)
self.action_font_size_larger.triggered.connect(self.font_size_larger)
self.action_font_size_smaller.triggered.connect(self.font_size_smaller)
self.action_open_ebook.triggered[bool].connect(self.open_ebook)
self.action_next_page.triggered.connect(self.view.next_page)
self.action_previous_page.triggered.connect(self.view.previous_page)
self.action_find_next.triggered.connect(self.find_next)
self.action_find_previous.triggered.connect(self.find_previous)
self.action_full_screen.triggered[bool].connect(self.toggle_fullscreen)
self.action_back.triggered[bool].connect(self.back)
self.action_forward.triggered[bool].connect(self.forward)
self.action_preferences.triggered.connect(self.do_config)
self.pos.editingFinished.connect(self.goto_page_num)
self.vertical_scrollbar.valueChanged[int].connect(lambda
x:self.goto_page(x/100.))
self.search.search.connect(self.find)
self.search.focus_to_library.connect(lambda: self.view.setFocus(Qt.OtherFocusReason))
self.toc.pressed[QModelIndex].connect(self.toc_clicked)
self.toc.searched.connect(partial(self.toc_clicked, force=True))
def toggle_toc(ev):
try:
key = self.view.shortcuts.get_match(ev)
except AttributeError:
pass
if key == 'Table of Contents':
ev.accept()
self.action_table_of_contents.trigger()
return True
return False
self.toc.handle_shortcuts = toggle_toc
self.reference.goto.connect(self.goto)
self.bookmarks.edited.connect(self.bookmarks_edited)
self.bookmarks.activated.connect(self.goto_bookmark)
self.bookmarks.create_requested.connect(self.bookmark)
self.set_bookmarks([])
self.load_theme_menu()
if pathtoebook is not None:
f = functools.partial(self.load_ebook, pathtoebook, open_at=open_at)
QTimer.singleShot(50, f)
elif continue_reading:
QTimer.singleShot(50, self.continue_reading)
self.window_mode_changed = None
self.toggle_toolbar_action = QAction(_('Show/hide controls'), self)
self.toggle_toolbar_action.setCheckable(True)
self.toggle_toolbar_action.triggered.connect(self.toggle_toolbars)
self.toolbar_hidden = None
self.addAction(self.toggle_toolbar_action)
self.full_screen_label_anim = QPropertyAnimation(
self.full_screen_label, b'size')
self.clock_timer = QTimer(self)
self.clock_timer.timeout.connect(self.update_clock)
self.action_print.triggered.connect(self.print_book)
self.clear_recent_history_action = QAction(
_('Clear list of recently opened books'), self)
self.clear_recent_history_action.triggered.connect(self.clear_recent_history)
self.build_recent_menu()
self.open_history_menu.triggered.connect(self.open_recent)
for x in ('tool_bar', 'tool_bar2'):
x = getattr(self, x)
for action in x.actions():
# So that the keyboard shortcuts for these actions will
# continue to function even when the toolbars are hidden
self.addAction(action)
for plugin in self.view.document.all_viewer_plugins:
plugin.customize_ui(self)
self.view.document.settings_changed.connect(self.settings_changed)
self.restore_state()
self.settings_changed()
self.action_toggle_paged_mode.toggled[bool].connect(self.toggle_paged_mode)
if (start_in_fullscreen or self.view.document.start_in_fullscreen):
self.action_full_screen.trigger()
self.hide_cursor_timer = t = QTimer(self)
t.setSingleShot(True), t.setInterval(3000)
t.timeout.connect(self.hide_cursor)
t.start()
def eventFilter(self, obj, ev):
if ev.type() == ev.MouseMove:
if self.cursor_hidden:
self.cursor_hidden = False
QApplication.instance().restoreOverrideCursor()
self.hide_cursor_timer.start()
return False
def hide_cursor(self):
self.cursor_hidden = True
QApplication.instance().setOverrideCursor(Qt.BlankCursor)
def toggle_paged_mode(self, checked, at_start=False):
in_paged_mode = not self.action_toggle_paged_mode.isChecked()
self.view.document.in_paged_mode = in_paged_mode
self.action_toggle_paged_mode.setToolTip(self.FLOW_MODE_TT if
self.action_toggle_paged_mode.isChecked() else
self.PAGED_MODE_TT)
if at_start:
return
self.reload()
def settings_changed(self):
for x in ('', '2'):
x = getattr(self, 'tool_bar'+x)
x.setVisible(self.view.document.show_controls)
def reload(self):
if hasattr(self, 'current_index') and self.current_index > -1:
self.view.document.page_position.save(overwrite=False)
self.pending_restore = True
self.load_path(self.view.last_loaded_path)
def set_toc_visible(self, yes):
self.toc_dock.setVisible(yes)
if not yes:
self.show_toc_on_open = False
def clear_recent_history(self, *args):
vprefs.set('viewer_open_history', [])
self.build_recent_menu()
def build_recent_menu(self):
m = self.open_history_menu
m.clear()
recent = vprefs.get('viewer_open_history', [])
if recent:
m.addAction(self.clear_recent_history_action)
m.addSeparator()
count = 0
for path in recent:
if count > 9:
break
if os.path.exists(path):
m.addAction(RecentAction(path, m))
count += 1
def continue_reading(self):
actions = self.open_history_menu.actions()[2:]
if actions:
actions[0].trigger()
def shutdown(self):
if self.isFullScreen() and not self.view.document.start_in_fullscreen:
self.action_full_screen.trigger()
return False
self.save_state()
if self.listener is not None:
self.listener.close()
return True
def quit(self):
if self.shutdown():
QApplication.instance().quit()
def closeEvent(self, e):
if self.closed:
e.ignore()
return
if self.shutdown():
self.closed = True
return MainWindow.closeEvent(self, e)
else:
e.ignore()
def toggle_toolbars(self):
for x in ('tool_bar', 'tool_bar2'):
x = getattr(self, x)
x.setVisible(not x.isVisible())
def save_state(self):
state = bytearray(self.saveState(self.STATE_VERSION))
vprefs['main_window_state'] = state
if not self.isFullScreen():
vprefs.set('viewer_window_geometry', bytearray(self.saveGeometry()))
if self.current_book_has_toc:
vprefs.set('viewer_toc_isvisible', self.show_toc_on_open or bool(self.toc_dock.isVisible()))
vprefs['multiplier'] = self.view.multiplier
vprefs['in_paged_mode'] = not self.action_toggle_paged_mode.isChecked()
def restore_state(self):
state = vprefs.get('main_window_state', None)
if state is not None:
try:
state = QByteArray(state)
self.restoreState(state, self.STATE_VERSION)
except:
pass
self.initialize_dock_state()
mult = vprefs.get('multiplier', None)
if mult:
self.view.multiplier = mult
# On windows Qt lets the user hide toolbars via a right click in a very
# specific location, ensure they are visible.
self.tool_bar.setVisible(True)
self.tool_bar2.setVisible(True)
self.toc_dock.close() # This will be opened on book open, if the book has a toc and it was previously opened
self.action_toggle_paged_mode.setChecked(not vprefs.get('in_paged_mode',
True))
self.toggle_paged_mode(self.action_toggle_paged_mode.isChecked(),
at_start=True)
def lookup(self, word):
from urllib import quote
word = quote(word.encode('utf-8'))
try:
url = lookup_website(canonicalize_lang(self.view.current_language) or 'en').format(word=word)
except Exception:
traceback.print_exc()
url = default_lookup_website(canonicalize_lang(self.view.current_language) or 'en').format(word=word)
open_url(url)
def print_book(self):
if self.iterator is None:
return error_dialog(self, _('No book opened'), _(
'Cannot print as no book is opened'), show=True)
from calibre.gui2.viewer.printing import print_book
print_book(self.iterator.pathtoebook, self, self.current_title)
def toggle_fullscreen(self):
if self.isFullScreen():
self.showNormal()
else:
self.showFullScreen()
def showFullScreen(self):
self.view.document.page_position.save()
self.window_mode_changed = 'fullscreen'
self.tool_bar.setVisible(False)
self.tool_bar2.setVisible(False)
self.was_maximized = self.isMaximized()
if not self.view.document.fullscreen_scrollbar:
self.vertical_scrollbar.setVisible(False)
super(EbookViewer, self).showFullScreen()
def show_full_screen_label(self):
f = self.full_screen_label
height = f.final_height
width = int(0.7*self.view.width())
f.resize(width, height)
if self.view.document.show_fullscreen_help:
f.setVisible(True)
a = self.full_screen_label_anim
a.setDuration(500)
a.setStartValue(QSize(width, 0))
a.setEndValue(QSize(width, height))
a.start()
QTimer.singleShot(3500, self.full_screen_label.hide)
if self.view.document.fullscreen_clock:
self.show_clock()
if self.view.document.fullscreen_pos:
self.show_pos_label()
self.relayout_fullscreen_labels()
def show_clock(self):
self.clock_label.setVisible(True)
self.clock_label.setText(QTime(22, 33,
33).toString(Qt.SystemLocaleShortDate))
self.clock_timer.start(1000)
self.clock_label.setStyleSheet(self.info_label_style%(
'rgba(0, 0, 0, 0)', self.view.document.colors()[1]))
self.clock_label.resize(self.clock_label.sizeHint())
self.update_clock()
def show_pos_label(self):
self.pos_label.setVisible(True)
self.pos_label.setStyleSheet(self.info_label_style%(
'rgba(0, 0, 0, 0)', self.view.document.colors()[1]))
self.update_pos_label()
def relayout_fullscreen_labels(self):
vswidth = (self.vertical_scrollbar.width() if
self.vertical_scrollbar.isVisible() else 0)
p = self.pos_label
p.move(15, p.parent().height() - p.height()-10)
c = self.clock_label
c.move(c.parent().width() - vswidth - 15 - c.width(), c.parent().height() - c.height() - 10)
f = self.full_screen_label
f.move((f.parent().width() - f.width())//2, (f.parent().height() - f.final_height)//2)
def update_clock(self):
self.clock_label.setText(QTime.currentTime().toString(Qt.SystemLocaleShortDate))
def update_pos_label(self, *args):
if self.pos_label.isVisible():
try:
value, maximum = args
except:
value, maximum = self.pos.value(), self.pos.maximum()
text = '%g/%g'%(value, maximum)
self.pos_label.setText(text)
self.pos_label.resize(self.pos_label.sizeHint())
def showNormal(self):
self.view.document.page_position.save()
self.clock_label.setVisible(False)
self.pos_label.setVisible(False)
self.clock_timer.stop()
self.vertical_scrollbar.setVisible(True)
self.window_mode_changed = 'normal'
self.settings_changed()
self.full_screen_label.setVisible(False)
if self.was_maximized:
super(EbookViewer, self).showMaximized()
else:
super(EbookViewer, self).showNormal()
def goto(self, ref):
if ref:
tokens = ref.split('.')
if len(tokens) > 1:
spine_index = int(tokens[0]) -1
if spine_index == self.current_index:
self.view.goto(ref)
else:
self.pending_reference = ref
self.load_path(self.iterator.spine[spine_index])
def goto_bookmark(self, bm):
spine_index = bm['spine']
if spine_index > -1 and self.current_index == spine_index:
if self.resize_in_progress:
self.view.document.page_position.set_pos(bm['pos'])
else:
self.view.goto_bookmark(bm)
# Going to a bookmark does not call scrolled() so we update the
# page position explicitly. Use a timer to ensure it is
# accurate.
QTimer.singleShot(100, self.update_page_number)
else:
self.pending_bookmark = bm
if spine_index < 0 or spine_index >= len(self.iterator.spine):
spine_index = 0
self.pending_bookmark = None
self.load_path(self.iterator.spine[spine_index])
def toc_clicked(self, index, force=False):
if force or QApplication.mouseButtons() & Qt.LeftButton:
item = self.toc_model.itemFromIndex(index)
if item.abspath is not None:
if not os.path.exists(item.abspath):
return error_dialog(self, _('No such location'),
_('The location pointed to by this item'
' does not exist.'), det_msg=item.abspath, show=True)
url = QUrl.fromLocalFile(item.abspath)
if item.fragment:
url.setFragment(item.fragment)
self.link_clicked(url)
self.view.setFocus(Qt.OtherFocusReason)
def selection_changed(self, selected_text):
self.selected_text = selected_text.strip()
self.action_copy.setEnabled(bool(self.selected_text))
def copy(self, x):
if self.selected_text:
QApplication.clipboard().setText(self.selected_text)
def back(self, x):
pos = self.history.back(self.pos.value())
if pos is not None:
self.goto_page(pos)
def goto_page_num(self):
num = self.pos.value()
self.goto_page(num)
def forward(self, x):
pos = self.history.forward(self.pos.value())
if pos is not None:
self.goto_page(pos)
def goto_start(self):
self.goto_page(1)
def goto_end(self):
self.goto_page(self.pos.maximum())
def goto_page(self, new_page, loaded_check=True):
if self.current_page is not None or not loaded_check:
for page in self.iterator.spine:
if new_page >= page.start_page and new_page <= page.max_page:
try:
frac = float(new_page-page.start_page)/(page.pages-1)
except ZeroDivisionError:
frac = 0
if page == self.current_page:
self.view.scroll_to(frac)
else:
self.load_path(page, pos=frac)
def open_ebook(self, checked):
files = choose_files(self, 'ebook viewer open dialog',
_('Choose ebook'),
[(_('Ebooks'), available_input_formats())],
all_files=False,
select_only_single_file=True)
if files:
self.load_ebook(files[0])
def open_recent(self, action):
self.load_ebook(action.path)
def font_size_larger(self):
self.view.magnify_fonts()
def font_size_smaller(self):
self.view.shrink_fonts()
def magnification_changed(self, val):
tt = '%(action)s [%(sc)s]\n'+_('Current magnification: %(mag).1f')
sc = _(' or ').join(self.view.shortcuts.get_shortcuts('Font larger'))
self.action_font_size_larger.setToolTip(
tt %dict(action=unicode(self.action_font_size_larger.text()),
mag=val, sc=sc))
sc = _(' or ').join(self.view.shortcuts.get_shortcuts('Font smaller'))
self.action_font_size_smaller.setToolTip(
tt %dict(action=unicode(self.action_font_size_smaller.text()),
mag=val, sc=sc))
self.action_font_size_larger.setEnabled(self.view.multiplier < 3)
self.action_font_size_smaller.setEnabled(self.view.multiplier > 0.2)
def find(self, text, repeat=False, backwards=False):
if not text:
self.view.search('')
return self.search.search_done(False)
if self.view.search(text, backwards=backwards):
self.scrolled(self.view.scroll_fraction)
return self.search.search_done(True)
index = self.iterator.search(text, self.current_index,
backwards=backwards)
if index is None:
if self.current_index > 0:
index = self.iterator.search(text, 0)
if index is None:
info_dialog(self, _('No matches found'),
_('No matches found for: %s')%text).exec_()
return self.search.search_done(True)
return self.search.search_done(True)
self.pending_search = text
self.pending_search_dir = 'backwards' if backwards else 'forwards'
self.load_path(self.iterator.spine[index])
def find_next(self):
self.find(unicode(self.search.text()), repeat=True)
def find_previous(self):
self.find(unicode(self.search.text()), repeat=True, backwards=True)
def do_search(self, text, backwards):
self.pending_search = None
self.pending_search_dir = None
if self.view.search(text, backwards=backwards):
self.scrolled(self.view.scroll_fraction)
def internal_link_clicked(self, prev_pos):
self.history.add(prev_pos)
def link_clicked(self, url):
path = os.path.abspath(unicode(url.toLocalFile()))
frag = None
if path in self.iterator.spine:
self.update_page_number() # Ensure page number is accurate as it is used for history
self.history.add(self.pos.value())
path = self.iterator.spine[self.iterator.spine.index(path)]
if url.hasFragment():
frag = unicode(url.fragment())
if path != self.current_page:
self.pending_anchor = frag
self.load_path(path)
else:
oldpos = self.view.document.ypos
if frag:
self.view.scroll_to(frag)
else:
# Scroll to top
self.view.scroll_to(0)
if self.view.document.ypos == oldpos:
# If we are coming from goto_next_section() call this will
# cause another goto next section call with the next toc
# entry, since this one did not cause any scrolling at all.
QTimer.singleShot(10, self.update_indexing_state)
else:
open_url(url)
def load_started(self):
self.open_progress_indicator(_('Loading flow...'))
def load_finished(self, ok):
self.close_progress_indicator()
path = self.view.path()
try:
index = self.iterator.spine.index(path)
except (ValueError, AttributeError):
return -1
self.current_page = self.iterator.spine[index]
self.current_index = index
self.set_page_number(self.view.scroll_fraction)
QTimer.singleShot(100, self.update_indexing_state)
if self.pending_search is not None:
self.do_search(self.pending_search,
self.pending_search_dir=='backwards')
self.pending_search = None
self.pending_search_dir = None
if self.pending_anchor is not None:
self.view.scroll_to(self.pending_anchor)
self.pending_anchor = None
if self.pending_reference is not None:
self.view.goto(self.pending_reference)
self.pending_reference = None
if self.pending_bookmark is not None:
self.goto_bookmark(self.pending_bookmark)
self.pending_bookmark = None
if self.pending_restore:
self.view.document.page_position.restore()
return self.current_index
def goto_next_section(self):
if hasattr(self, 'current_index'):
entry = self.toc_model.next_entry(self.current_index,
self.view.document.read_anchor_positions(),
self.view.viewport_rect, self.view.document.in_paged_mode)
if entry is not None:
self.pending_goto_next_section = (
self.toc_model.currently_viewed_entry, entry, False)
self.toc_clicked(entry.index(), force=True)
def goto_previous_section(self):
if hasattr(self, 'current_index'):
entry = self.toc_model.next_entry(self.current_index,
self.view.document.read_anchor_positions(),
self.view.viewport_rect, self.view.document.in_paged_mode,
backwards=True)
if entry is not None:
self.pending_goto_next_section = (
self.toc_model.currently_viewed_entry, entry, True)
self.toc_clicked(entry.index(), force=True)
def update_indexing_state(self, anchor_positions=None):
pgns = getattr(self, 'pending_goto_next_section', None)
if hasattr(self, 'current_index'):
if anchor_positions is None:
anchor_positions = self.view.document.read_anchor_positions()
items = self.toc_model.update_indexing_state(self.current_index,
self.view.viewport_rect, anchor_positions,
self.view.document.in_paged_mode)
if items:
self.toc.scrollTo(items[-1].index())
if pgns is not None:
self.pending_goto_next_section = None
# Check that we actually progressed
if pgns[0] is self.toc_model.currently_viewed_entry:
entry = self.toc_model.next_entry(self.current_index,
self.view.document.read_anchor_positions(),
self.view.viewport_rect,
self.view.document.in_paged_mode,
backwards=pgns[2], current_entry=pgns[1])
if entry is not None:
self.pending_goto_next_section = (
self.toc_model.currently_viewed_entry, entry,
pgns[2])
self.toc_clicked(entry.index(), force=True)
def load_path(self, path, pos=0.0):
self.open_progress_indicator(_('Laying out %s')%self.current_title)
self.view.load_path(path, pos=pos)
def footnote_visibility_changed(self, is_visible):
if self.view.document.in_paged_mode:
pp = namedtuple('PagePosition', 'time is_visible page_dimensions multiplier last_loaded_path page_number after_resize_page_number')
self.page_position_on_footnote_toggle.append(pp(
time.time(), is_visible, self.view.document.page_dimensions, self.view.multiplier,
self.view.last_loaded_path, self.view.document.page_number, None))
def pre_footnote_toggle_position(self):
num = len(self.page_position_on_footnote_toggle)
if self.view.document.in_paged_mode and num > 1 and num % 2 == 0:
two, one = self.page_position_on_footnote_toggle.pop(), self.page_position_on_footnote_toggle.pop()
if (
time.time() - two.time < 1 and not two.is_visible and one.is_visible and
one.last_loaded_path == two.last_loaded_path and two.last_loaded_path == self.view.last_loaded_path and
one.page_dimensions == self.view.document.page_dimensions and one.multiplier == self.view.multiplier and
one.after_resize_page_number == self.view.document.page_number
):
return one.page_number
def viewport_resize_started(self, event):
if not self.resize_in_progress:
# First resize, so save the current page position
self.resize_in_progress = True
if not self.window_mode_changed:
# The special handling for window mode changed will already
# have saved page position, so only save it if this is not a
# mode change
self.view.document.page_position.save()
if self.resize_in_progress:
self.view_resized_timer.start(75)
def viewport_resize_finished(self):
# There hasn't been a resize event for some time
# restore the current page position.
self.resize_in_progress = False
wmc, self.window_mode_changed = self.window_mode_changed, None
fs = wmc == 'fullscreen'
if wmc:
# Sets up body text margins, which can be limited in fs mode by a
# separate config option, so must be done before relayout of text
(self.view.document.switch_to_fullscreen_mode if fs else self.view.document.switch_to_window_mode)()
# Re-layout text, must be done before restoring page position
self.view.document.after_resize()
if wmc:
# This resize is part of a window mode change, special case it
if fs:
self.show_full_screen_label()
self.view.document.page_position.restore()
self.scrolled(self.view.scroll_fraction)
else:
if self.isFullScreen():
self.relayout_fullscreen_labels()
pre_footnote_pos = self.pre_footnote_toggle_position()
if pre_footnote_pos is not None:
self.view.document.page_number = pre_footnote_pos
else:
self.view.document.page_position.restore()
self.update_page_number()
if len(self.page_position_on_footnote_toggle) % 2 == 1:
self.page_position_on_footnote_toggle[-1] = self.page_position_on_footnote_toggle[-1]._replace(
after_resize_page_number=self.view.document.page_number)
if self.pending_goto_page is not None:
pos, self.pending_goto_page = self.pending_goto_page, None
self.goto_page(pos, loaded_check=False)
def update_page_number(self):
self.set_page_number(self.view.document.scroll_fraction)
return self.pos.value()
def close_progress_indicator(self):
self.pi.stop()
for o in ('tool_bar', 'tool_bar2', 'view', 'horizontal_scrollbar', 'vertical_scrollbar'):
getattr(self, o).setEnabled(True)
self.unsetCursor()
self.view.setFocus(Qt.PopupFocusReason)
def open_progress_indicator(self, msg=''):
self.pi.start(msg)
for o in ('tool_bar', 'tool_bar2', 'view', 'horizontal_scrollbar', 'vertical_scrollbar'):
getattr(self, o).setEnabled(False)
self.setCursor(Qt.BusyCursor)
def load_theme_menu(self):
from calibre.gui2.viewer.config import load_themes
self.themes_menu.clear()
for key in load_themes():
title = key[len('theme_'):]
self.themes_menu.addAction(title, partial(self.load_theme,
key))
def load_theme(self, theme_id):
self.view.load_theme(theme_id)
def do_config(self):
self.view.config(self)
self.load_theme_menu()
if self.iterator is not None:
self.iterator.copy_bookmarks_to_file = self.view.document.copy_bookmarks_to_file
from calibre.gui2 import config
if not config['viewer_search_history']:
self.search.clear_history()
def bookmark(self, *args):
num = 1
bm = None
while True:
bm = _('Bookmark #%d')%num
if bm not in self.existing_bookmarks:
break
num += 1
title, ok = QInputDialog.getText(self, _('Add bookmark'),
_('Enter title for bookmark:'), text=bm)
title = unicode(title).strip()
if ok and title:
bm = self.view.bookmark()
bm['spine'] = self.current_index
bm['title'] = title
self.iterator.add_bookmark(bm)
self.set_bookmarks(self.iterator.bookmarks)
self.bookmarks.set_current_bookmark(bm)
def autosave(self):
self.save_current_position(no_copy_to_file=True)
def bookmarks_edited(self, bookmarks):
self.build_bookmarks_menu(bookmarks)
self.iterator.set_bookmarks(bookmarks)
self.iterator.save_bookmarks()
def build_bookmarks_menu(self, bookmarks):
self.bookmarks_menu.clear()
sc = _(' or ').join(self.view.shortcuts.get_shortcuts('Bookmark'))
self.bookmarks_menu.addAction(_("Bookmark this location [%s]") % sc, self.bookmark)
self.bookmarks_menu.addAction(_("Show/hide Bookmarks"), self.bookmarks_dock.toggleViewAction().trigger)
self.bookmarks_menu.addSeparator()
current_page = None
self.existing_bookmarks = []
for bm in bookmarks:
if bm['title'] == 'calibre_current_page_bookmark':
if self.view.document.remember_current_page:
current_page = bm
else:
self.existing_bookmarks.append(bm['title'])
self.bookmarks_menu.addAction(bm['title'], partial(self.goto_bookmark, bm))
return current_page
def set_bookmarks(self, bookmarks):
self.bookmarks.set_bookmarks(bookmarks)
return self.build_bookmarks_menu(bookmarks)
@property
def current_page_bookmark(self):
bm = self.view.bookmark()
bm['spine'] = self.current_index
bm['title'] = 'calibre_current_page_bookmark'
return bm
def save_current_position(self, no_copy_to_file=False):
if not self.view.document.remember_current_page:
return
if hasattr(self, 'current_index'):
try:
self.iterator.add_bookmark(self.current_page_bookmark, no_copy_to_file=no_copy_to_file)
except:
traceback.print_exc()
def another_instance_wants_to_talk(self, msg):
try:
path, open_at = msg
except Exception:
return
self.load_ebook(path, open_at=open_at)
self.raise_()
def load_ebook(self, pathtoebook, open_at=None, reopen_at=None):
if self.iterator is not None:
self.save_current_position()
self.iterator.__exit__()
self.iterator = EbookIterator(pathtoebook, copy_bookmarks_to_file=self.view.document.copy_bookmarks_to_file)
self.history.clear()
self.open_progress_indicator(_('Loading ebook...'))
worker = Worker(target=partial(self.iterator.__enter__, view_kepub=True))
worker.path_to_ebook = pathtoebook
worker.start()
while worker.isAlive():
worker.join(0.1)
QApplication.processEvents()
if worker.exception is not None:
tb = worker.traceback.strip()
if tb and tb.splitlines()[-1].startswith('DRMError:'):
from calibre.gui2.dialogs.drm_error import DRMErrorMessage
DRMErrorMessage(self).exec_()
else:
r = getattr(worker.exception, 'reason', worker.exception)
error_dialog(self, _('Could not open ebook'),
as_unicode(r) or _('Unknown error'),
det_msg=tb, show=True)
self.close_progress_indicator()
else:
self.metadata.show_opf(self.iterator.opf,
self.iterator.book_format)
self.view.current_language = self.iterator.language
title = self.iterator.opf.title
if not title:
title = os.path.splitext(os.path.basename(pathtoebook))[0]
if self.iterator.toc:
self.toc_model = TOC(self.iterator.spine, self.iterator.toc)
self.toc.setModel(self.toc_model)
if self.show_toc_on_open:
self.action_table_of_contents.setChecked(True)
else:
self.toc_model = TOC(self.iterator.spine)
self.toc.setModel(self.toc_model)
self.action_table_of_contents.setChecked(False)
if isbytestring(pathtoebook):
pathtoebook = force_unicode(pathtoebook, filesystem_encoding)
vh = vprefs.get('viewer_open_history', [])
try:
vh.remove(pathtoebook)
except:
pass
vh.insert(0, pathtoebook)
vprefs.set('viewer_open_history', vh[:50])
self.build_recent_menu()
self.footnotes_dock.close()
self.action_table_of_contents.setDisabled(not self.iterator.toc)
self.current_book_has_toc = bool(self.iterator.toc)
self.current_title = title
self.setWindowTitle(title + ' [%s]'%self.iterator.book_format + ' - ' + self.base_window_title)
self.pos.setMaximum(sum(self.iterator.pages))
self.pos.setSuffix(' / %d'%sum(self.iterator.pages))
self.vertical_scrollbar.setMinimum(100)
self.vertical_scrollbar.setMaximum(100*sum(self.iterator.pages))
self.vertical_scrollbar.setSingleStep(10)
self.vertical_scrollbar.setPageStep(100)
self.set_vscrollbar_value(1)
self.current_index = -1
QApplication.instance().alert(self, 5000)
previous = self.set_bookmarks(self.iterator.bookmarks)
if reopen_at is not None:
previous = reopen_at
if open_at is None and previous is not None:
self.goto_bookmark(previous)
else:
if open_at is None:
self.next_document()
else:
if open_at > self.pos.maximum():
open_at = self.pos.maximum()
if open_at < self.pos.minimum():
open_at = self.pos.minimum()
if self.resize_in_progress:
self.pending_goto_page = open_at
else:
self.goto_page(open_at, loaded_check=False)
def set_vscrollbar_value(self, pagenum):
self.vertical_scrollbar.blockSignals(True)
self.vertical_scrollbar.setValue(int(pagenum*100))
self.vertical_scrollbar.blockSignals(False)
def set_page_number(self, frac):
if getattr(self, 'current_page', None) is not None:
page = self.current_page.start_page + frac*float(self.current_page.pages-1)
self.pos.set_value(page)
self.set_vscrollbar_value(page)
def scrolled(self, frac, onload=False):
self.set_page_number(frac)
if not onload:
ap = self.view.document.read_anchor_positions()
self.update_indexing_state(ap)
def next_document(self):
if (hasattr(self, 'current_index') and self.current_index <
len(self.iterator.spine) - 1):
self.load_path(self.iterator.spine[self.current_index+1])
def previous_document(self):
if hasattr(self, 'current_index') and self.current_index > 0:
self.load_path(self.iterator.spine[self.current_index-1], pos=1.0)
def keyPressEvent(self, event):
if event.key() == Qt.Key_Escape:
if self.metadata.isVisible():
self.metadata.setVisible(False)
event.accept()
return
if self.isFullScreen():
self.action_full_screen.trigger()
event.accept()
return
try:
key = self.view.shortcuts.get_match(event)
except AttributeError:
return MainWindow.keyPressEvent(self, event)
try:
bac = self.bookmarks_menu.actions()[0]
except (AttributeError, TypeError, IndexError, KeyError):
bac = None
action = {
'Quit':self.action_quit,
'Show metadata':self.action_metadata,
'Copy':self.view.copy_action,
'Font larger': self.action_font_size_larger,
'Font smaller': self.action_font_size_smaller,
'Fullscreen': self.action_full_screen,
'Find next': self.action_find_next,
'Find previous': self.action_find_previous,
'Search online': self.view.search_online_action,
'Lookup word': self.view.dictionary_action,
'Next occurrence': self.view.search_action,
'Bookmark': bac,
'Reload': self.action_reload,
'Table of Contents': self.action_table_of_contents,
'Print': self.action_print,
}.get(key, None)
if action is not None:
event.accept()
action.trigger()
return
if key == 'Focus Search':
self.search.setFocus(Qt.OtherFocusReason)
return
if not self.view.handle_key_press(event):
event.ignore()
def reload_book(self):
if getattr(self.iterator, 'pathtoebook', None):
try:
reopen_at = self.current_page_bookmark
except Exception:
reopen_at = None
self.history.clear()
self.load_ebook(self.iterator.pathtoebook, reopen_at=reopen_at)
return
def __enter__(self):
return self
def __exit__(self, *args):
if self.iterator is not None:
self.save_current_position()
self.iterator.__exit__(*args)
def read_settings(self):
c = config().parse()
if c.remember_window_size:
wg = vprefs.get('viewer_window_geometry', None)
if wg is not None:
self.restoreGeometry(wg)
self.show_toc_on_open = vprefs.get('viewer_toc_isvisible', False)
desktop = QApplication.instance().desktop()
av = desktop.availableGeometry(self).height() - 30
if self.height() > av:
self.resize(self.width(), av)
def show_footnote_view(self):
self.footnotes_dock.show()
class MainWindow(QMainWindow):
def __init__(self, app):
super(MainWindow, self).__init__()
self.app = app
print('window created')
self.setWindowIcon(QIcon('img/icon.png'))
self.setWindowTitle('Kasino')
self.setPalette(QPalette(Qt.darkGreen))
self.setup_music()
self.statusbar = QStatusBar(self)
self.statusbar.setStyleSheet('background: white')
self.setStatusBar(self.statusbar)
self.statusbar.showMessage('Welcome to the Cassino game!')
self.menubar = QMenuBar(self)
self.optionsMenu = self.menubar.addMenu('Options')
self.music_toggle = QAction()
self.music_toggle.setText('Music')
self.music_toggle.setShortcut('Ctrl+m')
self.music_toggle.setCheckable(True)
self.music_toggle.setChecked(True)
self.optionsMenu.addAction(self.music_toggle)
self.music_toggle.triggered.connect(self.toggle_music)
self.speedGroup = QActionGroup(self)
self.speedGroup.triggered.connect(self.set_speed)
self.slow_speed = QAction('Slow', self.speedGroup)
self.slow_speed.setCheckable(True)
self.normal_speed = QAction('Normal', self.speedGroup)
self.normal_speed.setCheckable(True)
self.fast_speed = QAction('Fast', self.speedGroup)
self.fast_speed.setCheckable(True)
self.vfast_speed = QAction('Very Fast', self.speedGroup)
self.vfast_speed.setCheckable(True)
self.normal_speed.setChecked(True)
self.speed_menu = self.optionsMenu.addMenu('Speed')
self.speed_menu.addActions(self.speedGroup.actions())
self.menubar.setMouseTracking(False)
self.setMenuBar(self.menubar)
self.play_widget = PlayWidget(self)
self.main_menu = MainMenu(self)
self.start_menu = StartMenu(self)
self.widgets = QStackedWidget(self)
self.widgets.addWidget(self.play_widget)
self.widgets.addWidget(self.main_menu)
self.widgets.addWidget(self.start_menu)
self.widgets.setCurrentWidget(self.main_menu)
self.setCentralWidget(self.widgets)
self.setGeometry(25, 50, 1028, 720)
self.main_menu.startbutton.clicked.connect(self.init_game)
self.main_menu.loadbutton.clicked.connect(self.load_game)
self.main_menu.quitbutton.clicked.connect(self.quit)
self.play_widget.quit_button.clicked.connect(self.quit_to_menu)
self.play_widget.save_button.clicked.connect(self.save_game)
self.start_menu.startbutton.clicked.connect(self.start_game)
def setup_music(self):
self.music = QMediaPlayer()
self.playlist = QMediaPlaylist()
self.playlist.setPlaybackMode(QMediaPlaylist.Loop)
file_name = "sound/bg.mp3"
self.media = QMediaContent(QUrl.fromLocalFile(file_name))
self.playlist.addMedia(self.media)
self.music.setPlaylist(self.playlist)
self.music.setVolume(20)
self.music.play()
def toggle_music(self):
if self.music.isMuted():
self.music.setMuted(False)
self.statusbar.showMessage('Music on', 5000)
else:
self.music.setMuted(True)
self.statusbar.showMessage('Music off', 5000)
def set_speed(self, action):
if action == self.slow_speed:
self.play_widget.speed = 1
elif action == self.normal_speed:
self.play_widget.speed = 3
elif action == self.fast_speed:
self.play_widget.speed = 4
else:
self.play_widget.speed = 6
def start_game(self):
self.play_widget.init_game(
self.start_menu.extract_info_and_init_game())
self.widgets.setCurrentWidget(self.play_widget)
self.statusbar.showMessage('Game launched', 2000)
def load_game(self):
path = QFileDialog.getOpenFileName(self, 'Open save file',
QDir.currentPath() + '/sav')[0]
if path != '':
game, msg, count = load(path)
self.play_widget.resume_from_save(game, msg, count)
self.widgets.setCurrentWidget(self.play_widget)
self.statusbar.showMessage('Loaded save file', 5000)
def save_game(self):
path = QFileDialog.getSaveFileName(self, 'Create save file',
QDir.currentPath() + '/sav')[0]
if path != '':
save(path, self.play_widget.game, self.play_widget.export_log(),
self.play_widget.move_count)
self.statusbar.showMessage('Game saved', 5000)
def init_game(self):
self.widgets.setCurrentWidget(self.start_menu)
self.statusbar.showMessage('Starting new game')
def quit_to_menu(self):
#Reset playwidget
self.widgets.removeWidget(self.play_widget)
speed = self.play_widget.speed
self.play_widget.setParent(None)
self.play_widget = PlayWidget(self)
self.play_widget.speed = speed
self.widgets.addWidget(self.play_widget)
self.play_widget.quit_button.clicked.connect(self.quit_to_menu)
self.play_widget.save_button.clicked.connect(self.save_game)
self.widgets.setCurrentWidget(self.main_menu)
def closeEvent(self, *args,
**kwargs): #for handling closing from 'x' button
self.quit()
def quit(self):
print('Exited game. Thanks for playing!\n')
self.app.exit()
class TextToSpeechPlugin(ViewerPlugin):
'''
'''
name = 'TTS Ebook Viewer'
description = 'adds TTS capability to ebook-viewer'
supported_platforms = ['windows']
author = 'Christine Ye'
version = (0, 0, 2)
minimum_calibre_version = (0, 7, 53)
def customize_ui(self, ui):
self.ebookViewer = ui
self.tts_speaker = TTSSpeaker(ui)
self.ebookViewer.tts_speaker = self.tts_speaker
ui.tool_bar.addSeparator()
self.speak_button = QAction('play / pause', ui)
ui.tool_bar.addAction(self.speak_button)
self.speak_button.triggered.connect(self.tts_speaker.playOrPause)
self.tts_speaker.toolbarButton = self.speak_button
self.select_mode_button = QAction('select mode', ui)
ui.tool_bar.addAction(self.select_mode_button)
self.select_mode_button.triggered.connect(
self.tts_speaker.toggleSelectMode)
self.select_mode_button.setCheckable(True)
self.select_mode_button.setChecked(False)
self.tts_speaker.toggleSelectModeButton = self.select_mode_button
self.stop_button = QAction('stop', ui)
ui.tool_bar.addAction(self.stop_button)
self.stop_button.triggered.connect(self.tts_speaker.stop)
# HACK?
# append a callback to the javaScriptWindowObjectCleared
# signal receiver. If you don't do this, the `py_annotator`
# object will be empty (has no python functions callable)
# from js
ui.view.document.mainFrame().javaScriptWindowObjectCleared.connect(
self.add_window_objects)
# print ("finished customizing ")
def add_window_objects(self):
self.ebookViewer.view.document.mainFrame().addToJavaScriptWindowObject(
'tts_speaker', Responder(self.ebookViewer.view.document))
# this function is by far the slowest, and is what causes pauses in the render
def run_javascript(self, evaljs):
'''
this gets called after load_javascript.
'''
# inject css
evaljs('''
$("<style>.tts_reading { background-color: yellow !important;} p.tts_selectMode:hover { background-color: #e7eaa4; } </style>").appendTo(document.head)
''')
self.evaljs = evaljs
self.tts_speaker.evaljs = evaljs
def jsbool(pyBool):
return unicode(pyBool).lower()
from calibre_plugins.tts_ebook_viewer.config import prefs
if prefs['pause_hotkey_enabled'] or prefs[
'stop_hotkey_enabled'] or prefs['select_hotkey_enabled']:
hotkeyjs = '''
$(document).keydown(function(event)
{
if (%s &&
event.ctrlKey == %s &&
event.altKey == %s &&
event.shiftKey == %s &&
event.which == %i)
{
tts_speaker.playOrPause()
}
else if (%s &&
event.ctrlKey == %s &&
event.altKey == %s &&
event.shiftKey == %s &&
event.which == %i)
{
tts_speaker.stop()
}
else if (%s &&
event.ctrlKey == %s &&
event.altKey == %s &&
event.shiftKey == %s &&
event.which == %i)
{
tts_speaker.toggleSelectMode()
}
})
'''
hotkeyArgs = []
for hotkey in ['pause', 'stop', 'select']:
hotkeyArgs.append(jsbool(prefs[hotkey + '_hotkey_enabled']))
hotkeyArgs.append(jsbool(prefs[hotkey + '_hotkey_ctrl']))
hotkeyArgs.append(jsbool(prefs[hotkey + '_hotkey_alt']))
hotkeyArgs.append(jsbool(prefs[hotkey + '_hotkey_shift']))
hotkeyArgs.append(prefs[hotkey + '_hotkey_keycode'])
self.evaljs(hotkeyjs % tuple(hotkeyArgs))
if self.tts_speaker.isPlaying:
print("TTS: Start reading automatically")
evaljs('''
$currentReading = getFirstParagraphInView().addClass("tts_reading")
tts_speaker.readText($currentReading.text());
''')
def load_javascript(self, evaljs):
'''
from calibre docs:
This method is called every time a new HTML document is
loaded in the viewer. Use it to load javascript libraries
into the viewer.
'''
evaljs('''
function getFirstParagraphInView()
{
$p = $("body").find(":visible")
if (window.paged_display != null && window.paged_display.in_paged_mode)
{
var columnLeft = window.paged_display.current_column_location()
$p.each(function(index, element)
{
var br = element.getBoundingClientRect()
var pos = calibre_utils.viewport_to_document(br.left, br.top, element.ownerDocument)
if (pos[0] >= columnLeft && pos[0] < columnLeft + window.paged_display.page_width)
{
$currentReading = $(element);
$currentReading.addClass("tts_reading")
return false;
}
})
}
else
{
var $window = $(window);
var docViewTop = $window.scrollTop();
var docViewBottom = docViewTop + $window.height();
$p.each(function(index, element)
{
$elem = $(element)
var elemTop = $elem.offset().top;
var elemBottom = elemTop + $elem.height();
if ((elemTop <= docViewBottom) && (elemTop >= docViewTop))
{
$currentReading = $elem;
$currentReading.addClass("tts_reading")
return false;
}
})
}
return $currentReading
}
''')
def is_customizable(self):
'''
This method must return True to enable customization via
Preferences->Plugins
'''
return True
def config_widget(self):
'''
Implement this method and :meth:`save_settings` in your plugin to
use a custom configuration dialog.
This method, if implemented, must return a QWidget. The widget can have
an optional method validate() that takes no arguments and is called
immediately after the user clicks OK. Changes are applied if and only
if the method returns True.
If for some reason you cannot perform the configuration at this time,
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.
'''
# It is important to put this import statement here rather than at the
# top of the module as importing the config class will also cause the
# GUI libraries to be loaded, which we do not want when using calibre
# from the command line
from calibre_plugins.tts_ebook_viewer.config import ConfigWidget
# print('config config')
return ConfigWidget()
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()
class ParameterPanel(EditionWidget, WidgetController):
"""Edition Panel implementation."""
def __init__(self, astergui, parent=None):
"""
Create panel.
Arguments:
astergui (AsterGui): AsterGui instance.
parent (Optional[QWidget]): Parent widget.
"""
super(ParameterPanel,
self).__init__(parent=parent,
name=translate("ParameterPanel", "Edit command"),
astergui=astergui)
self.setPixmap(load_pixmap("as_pic_edit_command.png"))
self._files_model = astergui.study().dataFilesModel()
self._unit_model = None
self._command = None
self.title = ParameterTitle(self)
self.title.installEventFilter(self)
self._name = QLineEdit(self)
self.views = QStackedWidget(self)
v_layout = QVBoxLayout(self)
v_layout.setContentsMargins(0, 0, 0, 0)
v_layout.setSpacing(5)
v_layout.addWidget(self.title)
v_layout.addWidget(HLine(self))
n_layout = QHBoxLayout()
v_layout.addLayout(n_layout)
n_layout.addWidget(QLabel(translate("ParameterPanel", "Name"), self))
n_layout.addWidget(self._name)
# force to be a valid identifier + length <= 8
self._name.setValidator(QRegExpValidator(QRegExp(r"[a-zA-Z]\w{1,7}")))
# create toolbar
tbar = QToolBar(self)
tbar.setToolButtonStyle(Qt.ToolButtonIconOnly)
# - Edit comment
edit_comment = QAction(translate("AsterStudy", "Edit &Comment"), self)
edit_comment.setToolTip(translate("AsterStudy", "Edit comment"))
edit_comment.setStatusTip(
translate("AsterStudy", "Edit comment for the "
"selected object"))
edit_comment.setIcon(load_icon("as_pic_edit_comment.png"))
connect(edit_comment.triggered, self._editComment)
tbar.addAction(edit_comment)
# - Switch on/off business-translations
title = translate("AsterStudy", "Use Business-Oriented Translations")
self.use_translations = QAction(title, self)
title = translate("AsterStudy", "Use business-oriented translations")
self.use_translations.setToolTip(title)
self.use_translations.setStatusTip(title)
self.use_translations.setIcon(load_icon("as_pic_use_translations.png"))
self.use_translations.setCheckable(True)
if behavior().forced_native_names:
force = behavior().force_native_names
self.use_translations.setDisabled(True)
is_on = not force
else:
is_on = behavior().use_business_translations
Options.use_translations = is_on
self.use_translations.setChecked(is_on)
connect(self.use_translations.toggled, self.updateTranslations)
tbar.addAction(self.use_translations)
# - Hide unused
hide_unused = astergui.action(ActionType.HideUnused)
connect(hide_unused.toggled, self._unusedVisibility)
tbar.addAction(hide_unused)
# - What's this
whats_this = QWhatsThis.createAction(tbar)
whats_this.setToolTip(translate("AsterStudy", "What's this?"))
whats_this.setStatusTip(
translate("AsterStudy", "Show element's description"))
whats_this.setIcon(load_icon("as_pic_whats_this.png"))
tbar.addAction(whats_this)
# - Link to doc
tbar.addAction(astergui.action(ActionType.LinkToDoc))
n_layout.addWidget(tbar)
v_layout.addWidget(self.views)
self._updateState()
def unitModel(self):
"""
Method that get unit model.
Returns:
UnitModel: Unit model.
"""
return self._unit_model
def command(self):
"""
Get command being edited.
Returns:
Command: Command being edited.
"""
return self._command
def setCommand(self, command):
"""
Set command to edit.
Arguments:
command (Command): Command to edit.
"""
self.clear()
self._command = command
if self._command is None:
self._name.setText("")
else:
self._name.setText(self._command.name)
self._unit_model = UnitModel(command.stage)
pview = self._createParameterView(ParameterPath(self._command), '')
pview.view().setItemValue(command.storage)
hide_unused = self.astergui().action(ActionType.HideUnused)
pview.setUnusedVisibile(not hide_unused.isChecked())
self.views.setCurrentWidget(pview)
self._updateState()
def currentPath(self):
"""
Get currently edited parameter path.
Returns:
str: currently edited parameter path.
"""
path = ""
wid = self.currentParameterView()
if wid is not None:
path = wid.path()
return path
def isCurrentCommand(self):
"""
Get true if the currently edited view contains command.
Returns:
bool: Current edited command flag
"""
curpath = self.currentPath()
return ParameterPath(self.command()).isEqual(curpath)
def currentParameterView(self):
"""
Get current parameter view.
Returns:
ParameterView: current view.
"""
return self.views.currentWidget()
def clear(self):
"""Remove all parameter views."""
while self.views.count() > 0:
wid = self.views.widget(0)
if wid is not None:
self.views.removeWidget(wid)
wid.deleteLater()
def store(self):
"""
Save data from all parameter views.
"""
cmd = self.command()
if cmd is not None:
with auto_dupl_on(self.astergui().study().activeCase):
cmd.rename(self._name.text())
wid = self._viewByPath(ParameterPath(cmd))
if wid is not None:
cmd.init(wid.view().itemValue())
def requiredButtons(self):
"""
Return the combination of standard button flags required for this
widget.
Returns:
int: button flags for buttons required for this widget
(combination of QDialogButtonBox.StandardButton flags).
"""
if self.isCurrentCommand():
return QDialogButtonBox.Ok | QDialogButtonBox.Apply | \
QDialogButtonBox.Close
else:
return QDialogButtonBox.Ok | QDialogButtonBox.Cancel | \
QDialogButtonBox.Abort
def isButtonEnabled(self, button):
"""
Return True if a particular button is enabled.
Arguments:
button (QDialogButtonBox.StandardButton): button flag.
Returns:
True: that means that all buttons should be enabled.
"""
return True
def perform(self, button):
"""
Perform action on button click. Redefined method from the base class.
Arguments:
button (QDialogButtonBox.StandardButton): clicked button flag.
"""
if button == QDialogButtonBox.Ok:
self.performOk()
elif button == QDialogButtonBox.Apply:
self.performApply()
elif button == QDialogButtonBox.Abort:
self.performAbort()
elif button == QDialogButtonBox.Close or \
button == QDialogButtonBox.Cancel:
self.performClose()
def performOk(self):
"""Called when `Ok` button is clicked in Edition panel."""
self.performChanges(True)
def performApply(self):
"""Called when `Apply` button is clicked in Edition panel."""
self.performChanges(False)
def performAbort(self):
"""Called when `Abort` button is clicked in Edition panel."""
pref_mgr = self.astergui().preferencesMgr()
msg = translate(
"ParameterPanel", "Command edition will be aborted and "
"all made changes will be lost. "
"Do you want to continue?")
noshow = "parampanel_abort"
ask = MessageBox.question(self.astergui().mainWindow(),
translate("ParameterPanel", "Abort"),
msg,
QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes,
noshow=noshow,
prefmgr=pref_mgr)
if ask == QMessageBox.Yes:
self.close()
self.astergui().study().revert()
def performClose(self):
"""Called when `Cancel` button is clicked in Edition panel."""
has_modif = self._hasModifications()
if has_modif:
pref_mgr = self.astergui().preferencesMgr()
msg = translate(
"ParameterPanel",
"There are some unsaved modifications will be "
"lost. Do you want to continue?")
noshow = "parampanel_close"
ask = MessageBox.question(self.astergui().mainWindow(),
translate("ParameterPanel", "Close"),
msg,
QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes,
noshow=noshow,
prefmgr=pref_mgr)
has_modif = ask != QMessageBox.Yes
if not has_modif:
self.performDissmis(True)
def performChanges(self, close=True):
"""
Validate and store the command into data model.
"""
wid = self.currentParameterView()
if wid is not None:
view = wid.view()
if view.validate():
cur_path = self.currentPath()
if self.isCurrentCommand():
self.store()
self._files_model.update()
if self.astergui() is not None:
opname = translate("ParameterPanel", "Edit command")
self.astergui().study().commit(opname)
self.astergui().update()
if close:
self.performDissmis(False)
msg = translate("ParameterPanel",
"Command '{}' successfully stored")
msg = msg.format(self._name.text())
self.astergui().showMessage(msg)
else:
child_val = view.itemValue()
self._removeCurrentView()
curview = self.currentParameterView()
subitem = curview.view().findItemByPath(cur_path)
if subitem is not None:
subitem.setItemValue(child_val)
self._updateState()
self.updateButtonStatus()
def performDissmis(self, revert=True):
"""
Cancel changes and revert the command changes.
"""
if self.isCurrentCommand():
self.close()
if revert:
self.astergui().study().revert()
else:
self._removeCurrentView()
self._updateState()
self.updateButtonStatus()
def showEvent(self, event):
"""
Reimplemented for internal reason: updates the title
depending on read only state, etc.
"""
title = translate("ParameterPanel", "View command") \
if self.isReadOnly() else \
translate("ParameterPanel", "Edit command")
self.setWindowTitle(title)
hide_unused = self.astergui().action(ActionType.HideUnused)
hide_unused.setVisible(True)
hide_unused.setChecked(self.isReadOnly())
# update meshview
meshes = avail_meshes_in_cmd(self.command())
for i, mesh in enumerate(meshes):
filename, meshname = get_cmd_mesh(mesh)
if filename:
if i > 0:
self.meshview().displayMEDFileName(filename, meshname, 1.0,
False)
else:
self.meshview().displayMEDFileName(filename, meshname, 1.0,
True)
super(ParameterPanel, self).showEvent(event)
def hideEvent(self, event):
"""
Reimplemented for internal reason: hides "Hide unused" action.
"""
hide_unused = self.astergui().action(ActionType.HideUnused)
hide_unused.setVisible(False)
super(ParameterPanel, self).hideEvent(event)
def updateTranslations(self):
"""
Update translations in GUI elements.
"""
Options.use_translations = self.use_translations.isChecked()
self._updateState()
for i in xrange(self.views.count()):
view = self.views.widget(i)
view.updateTranslations()
def eventFilter(self, receiver, event):
"""
Event filter; processes clicking ln links in What's This window.
"""
if receiver == self.title and event.type() == QEvent.WhatsThisClicked:
QDesktopServices.openUrl(QUrl(event.href()))
return super(ParameterPanel, self).eventFilter(receiver, event)
def _hasModifications(self):
curview = self.currentParameterView().view() \
if self.currentParameterView() is not None else None
return curview.hasModifications() \
if curview is not None else False
def _updateState(self):
"""Update state and current title label."""
disabled = self.command() is None
self.setDisabled(disabled)
if not disabled:
disabled = self.command().gettype(ConversionLevel.NoFail) is None
self._name.setDisabled(disabled)
txt = []
pview = self.currentParameterView()
if pview is not None:
txt = pview.path().names()
ppath = None
txt_list = []
tooltip = ""
whats_this = ""
while len(txt) > 0:
name = txt.pop(0)
if ppath is None:
ppath = ParameterPath(self.command(), name=name)
else:
ppath = ppath.absolutePath(name)
if ppath.isInSequence():
txt_list.append("[" + name + "]")
elif get_cata_typeid(ppath.keyword()) in (IDS.simp, IDS.fact):
# translate keyword
kwtext = Options.translate_command(ppath.command().title, name)
txt_list.append(kwtext)
elif get_cata_typeid(ppath.keyword()) == IDS.command:
# translate command
translation = Options.translate_command(name)
txt_list.append(translation)
if translation != name:
wttext = italic(translation) + " ({})".format(bold(name))
else:
wttext = bold(name)
tooltip = preformat(wttext)
url = self.astergui().doc_url(name)
if url:
wttext += " "
wttext += href(
image(CFG.rcfile("as_pic_help.png"),
width=20,
height=20), url)
wttext = preformat(wttext)
docs = CATA.get_command_docstring(name)
if docs:
wttext += "<hr>"
wttext += docs
whats_this = wttext
self.title.setTitle(txt_list)
self.title.setToolTip(tooltip)
self.title.setWhatsThis(whats_this)
def _removeCurrentView(self):
"""
Remove the parameter view for given object.
Arguments:
obj (Parameter): Command's parameter.
"""
curview = self.currentParameterView()
if curview is not None:
master = curview.view().masterItem()
if master is not None and master.slaveItem() == curview.view():
master.setSlaveItem(None)
curview.view().setMasterItem(None)
view = self._parentView(curview)
if view is not None:
self.views.setCurrentWidget(view)
hide_unused = self.astergui().action(ActionType.HideUnused)
view.setUnusedVisibile(not hide_unused.isChecked())
self.views.removeWidget(curview)
curview.deleteLater()
self._updateState()
def _viewByPath(self, path):
view = None
for i in xrange(self.views.count()):
the_view = self.views.widget(i)
if the_view.path().isEqual(path):
view = the_view
break
return view
def _parentView(self, curview):
view = None
path = curview.path()
while path is not None and view is None:
path = path.parentPath()
view = self._viewByPath(path)
return view
def _gotoParameter(self, path, link):
"""
Activate the parameter view for object with given id.
Arguments:
uid (int): Object's UID.
"""
curview = self.currentParameterView()
act_item = curview.view().findItemByPath(path)
child_val = None
wid = self._createParameterView(path, link)
if act_item is not None:
child_val = act_item.itemValue()
act_item.setSlaveItem(wid.view())
wid.view().setMasterItem(act_item)
hide_unused = self.astergui().action(ActionType.HideUnused)
wid.setUnusedVisibile(not hide_unused.isChecked())
self.views.setCurrentWidget(wid)
wid.view().setItemValue(child_val)
self._updateState()
self.updateButtonStatus()
def _createParameterView(self, path, link):
"""
Create parameter view for given object.
Arguments:
path (ParameterPath): Path of parameter to edit.
Returns:
ParameterWindow: Parameter view for parameter path.
"""
# pragma pylint: disable=redefined-variable-type
pview = None
if link == EditorLink.Table:
pview = ParameterTableWindow(path, self, self.views)
elif link == EditorLink.List:
pview = ParameterListWindow(path, self, self.views)
elif link == EditorLink.GrMa:
pview = ParameterMeshGroupWindow(path, self, self.views)
else:
pview = ParameterFactWindow(path, self, self.views)
connect(pview.gotoParameter, self._gotoParameter)
self.views.addWidget(pview)
return pview
def _unusedVisibility(self, ison):
"""
Invoked when 'Hide unused' button toggled
"""
curview = self.currentParameterView()
curview.setUnusedVisibile(not ison)
def meshview(self):
"""
Returns the central *MeshView* object
"""
return self.astergui().workSpace().panels[Panel.View]
def _editComment(self):
"""
Invoked when 'Edit comment' button is clicked
"""
panel = CommentPanel(self.astergui(), owner=self)
panel.node = self.command()
self.astergui().workSpace().panel(Panel.Edit).setEditor(panel)
def pendingStorage(self):
"""
Dictionnary being filled as this command is edited.
"""
wid = self._viewByPath(ParameterPath(self.command()))
if wid is not None:
return wid.view().itemValue()
return None
class MainWindow(QMainWindow):
opts = read_config()
profiles = read_profiles()
urls = []
def __init__(self, debug=False):
super().__init__()
self.debug = debug
self.icon_paths()
self.init_UI()
def icon_paths(self):
self.defaultIconTheme = QIcon.themeName()
iconPaths = QIcon.themeSearchPaths()
iconPaths.append(icon_path())
QIcon.setThemeSearchPaths(iconPaths)
QIcon.setFallbackSearchPaths([icon_path("default")])
QIcon.setFallbackThemeName("default")
#QIcon.setThemeName( "default" )
def init_UI(self):
## Set the theme
self.set_stylesheet(self.opts["theme"])
self.profiles = read_profiles()
self.mainWidget = MainWidget(self)
self.statusBar()
self.build_menu_bar()
self.setCentralWidget(self.mainWidget)
self.resize(WINDOW_WIDTH, WINDOW_HEIGHT)
self.center_window()
self.setWindowTitle("qYoutube-DL")
self.show()
def center_window(self):
f = self.frameGeometry()
center = QDesktopWidget().availableGeometry().center()
f.moveCenter(center)
self.move(f.topLeft())
def build_menu_bar(self):
get_icon = Icons().get_icon
## Is this a system install?
sysInstall = (os.path.expanduser('~') in sys.argv[0])
######## Actions
## Save
saveAction = QAction(
QIcon(get_icon("document-save-symbolic", sysInstall)),
"&Save Settings", self)
saveAction.setShortcut("Ctrl+S")
saveAction.setStatusTip("Save current settings")
saveAction.triggered.connect(self.save_settings)
## Import playlist
importAction = QAction(
QIcon(get_icon("document-open-symbolic", sysInstall)),
"&Import URLs", self)
importAction.setShortcut("Ctrl+I")
importAction.setStatusTip("Import a saved list of URLs")
importAction.triggered.connect(self.import_urls)
## Export playlist
exportAction = QAction(
QIcon(get_icon("document-save-symbolic", sysInstall)),
"&Export URLs", self)
exportAction.setShortcut("Ctrl+E")
exportAction.setStatusTip("Export URLs to a text file")
exportAction.triggered.connect(self.export_urls)
## Exit
exitAction = QAction(
QIcon(get_icon("application-exit-symbolic", sysInstall)), "&Exit",
self)
exitAction.setShortcut("Ctrl+Q")
exitAction.setStatusTip("Exit the application")
exitAction.triggered.connect(qApp.quit)
## Go
goAction = QAction(QIcon(get_icon("go-next-symbolic", sysInstall)),
"Download URLs", self)
goAction.setShortcut("Return")
goAction.setStatusTip("Download current URL list")
goAction.triggered.connect(self.mainWidget.start_download)
## Paste
pasteAction = QAction(
QIcon(get_icon("edit-paste-symbolic", sysInstall)), "&Paste", self)
pasteAction.setShortcut("Ctrl+V")
pasteAction.setStatusTip("Add URL from clipboard")
pasteAction.triggered.connect(self.mainWidget.quick_add_item)
## Set destination
setDestAction = QAction(
QIcon(get_icon("document-open-symbolic", sysInstall)),
"Set &Download directory", self)
setDestAction.setShortcut("Ctrl+D")
setDestAction.setStatusTip("Choose your download directory")
setDestAction.triggered.connect(self.mainWidget.set_destination)
## Allow duplicates
self.dupeAction = QAction("Allow duplicates", self)
self.dupeAction.setStatusTip("Allow duplicate URLs in queue")
self.dupeAction.setCheckable(True)
if self.opts["duplicates"] == "true":
self.dupeAction.setChecked(True)
self.dupeAction.triggered.connect(self.check_dupe_box)
## New folder for playlists
self.playlistFolderAction = QAction("New folder for playlists", self)
self.playlistFolderAction.setStatusTip(
"Create a new folder for every playlist downloaded")
self.playlistFolderAction.setCheckable(True)
if self.opts["playlistFolder"] == "true":
self.playlistFolderAction.setChecked(True)
self.playlistFolderAction.triggered.connect(
self.check_playlist_dir_box)
## About action
aboutAction = QAction(
QIcon(get_icon("help-about-symbolic", sysInstall)), "&About", self)
aboutAction.setStatusTip("Information about the program")
aboutAction.triggered.connect(self.about)
## ====== Theme actions
## System default theme
defaultThemeAction = QAction("Default", self)
defaultThemeAction.setStatusTip("Set theme to system default")
defaultThemeAction.triggered.connect(self.toggle_theme_default)
## Light theme
lightThemeAction = QAction("Light theme", self)
lightThemeAction.setStatusTip("Use a light theme")
lightThemeAction.triggered.connect(self.toggle_theme_light)
## Dark theme
darkThemeAction = QAction("Dark theme", self)
darkThemeAction.setStatusTip("Use a dark theme")
darkThemeAction.triggered.connect(self.toggle_theme_dark)
## Create the menubar
menuBar = self.menuBar()
## Create file menu
fileMenu = menuBar.addMenu("&File")
fileMenu.addAction(saveAction)
fileMenu.addAction(exportAction)
fileMenu.addSeparator()
fileMenu.addAction(importAction)
fileMenu.addSeparator()
fileMenu.addAction(goAction)
fileMenu.addSeparator()
fileMenu.addAction(exitAction)
## Edit Menu
editMenu = menuBar.addMenu("&Edit")
editMenu.addAction(pasteAction)
## Settins Menu
settingsMenu = menuBar.addMenu("&Settings")
themesMenu = settingsMenu.addMenu("Theme")
settingsMenu.addSeparator()
settingsMenu.addAction(setDestAction)
settingsMenu.addSeparator()
settingsMenu.addAction(self.dupeAction)
settingsMenu.addAction(self.playlistFolderAction)
## Themes submenu
themesMenu.addAction(defaultThemeAction)
themesMenu.addAction(lightThemeAction)
themesMenu.addAction(darkThemeAction)
## Help menu
helpMenu = menuBar.addMenu("&Help")
helpMenu.addAction(aboutAction)
def import_urls(self):
dDir = self.mainWidget.destEdit.text()
filename, blank = QFileDialog.getOpenFileName(self, "Import URLs",
dDir)
if filename != "":
try:
fin = open(filename, "r")
rawUrls = fin.readlines()
fin.close()
urls = []
for r in rawUrls:
urls.append(r.strip())
self.load_urls(urls)
self.statusBar().showMessage("URLs imported", 2000)
except (OSError, PermissionError, FileNotFoundError):
print("ERROR: Cannot read from '%s'! Unable to load URLs" %
filename)
def export_urls(self):
dDir = self.mainWidget.destEdit.text()
filename, blank = QFileDialog.getSaveFileName(self, "Export URLs",
dDir)
if filename != "":
try:
urls = self.mainWidget.get_urls()
fout = open(filename, "w")
fout.writelines(urls)
fout.close()
self.statusBar().showMessage("URLs exported", 2000)
except (OSError, PermissionError, FileNotFoundError):
print("ERROR: Cannot write to '%s'! Unable to export URLs" %
filename)
def load_urls(self, urls):
self.mainWidget.load_urls(urls)
def write_config(self):
self.opts["downloadPath"] = self.mainWidget.destEdit.text()
self.opts["duplicates"] = str(self.dupeAction.isChecked()).lower()
boolStr = str(self.playlistFolderAction.isChecked()).lower()
self.opts["playlistFolder"] = boolStr
write_config(self.opts)
def save_settings(self):
self.write_config()
self.statusBar().showMessage("Settings saved", 2000)
def check_dupe_box(self):
self.opts["duplicates"] = str(self.dupeAction.isChecked()).lower()
self.save_settings()
def check_playlist_dir_box(self):
boolStr = str(self.playlistFolderAction.isChecked()).lower()
self.opts["playlistFolder"] = boolStr
self.save_settings()
def about(self):
aboutStr = """
qYoutube-DL is a basic PyQt5 frontend to Youtube-DL.
Version: %s
License: GPLv3 - https://www.gnu.org/licenses/gpl-3.0.txt
Author: James Hendrie - [email protected]
Git: https://github.com/jahendrie/qytdl
""" % qytdl_version()
msg = QMessageBox.about(self, "About qYoutube-DL", aboutStr)
def toggle_theme_default(self):
self.set_stylesheet()
self.opts["theme"] = "default"
self.write_config()
def toggle_theme_light(self):
self.set_stylesheet("light")
self.opts["theme"] = "light"
self.write_config()
def toggle_theme_dark(self):
self.set_stylesheet("dark")
self.opts["theme"] = "dark"
self.write_config()
def set_stylesheet(self, ssStr=""):
if ssStr == "dark" or ssStr == "light":
ssFile = open(stylesheets_path("%s.qss" % ssStr), "r")
self.setStyleSheet(ssFile.read())
ssFile.close()
QIcon.setThemeName(ssStr)
else:
self.setStyleSheet("")
QIcon.setThemeName(self.defaultIconTheme)
class EbookViewer(MainWindow):
STATE_VERSION = 2
FLOW_MODE_TT = _("Switch to paged mode - where the text is broken up " "into pages like a paper book")
PAGED_MODE_TT = _("Switch to flow mode - where the text is not broken up " "into pages")
def __init__(self, pathtoebook=None, debug_javascript=False, open_at=None, start_in_fullscreen=False):
MainWindow.__init__(self, debug_javascript)
self.view.magnification_changed.connect(self.magnification_changed)
self.show_toc_on_open = False
self.current_book_has_toc = False
self.iterator = None
self.current_page = None
self.pending_search = None
self.pending_search_dir = None
self.pending_anchor = None
self.pending_reference = None
self.pending_bookmark = None
self.pending_restore = False
self.cursor_hidden = False
self.existing_bookmarks = []
self.selected_text = None
self.was_maximized = False
self.read_settings()
self.pos.value_changed.connect(self.update_pos_label)
self.pos.setMinimumWidth(150)
self.setFocusPolicy(Qt.StrongFocus)
self.view.set_manager(self)
self.pi = ProgressIndicator(self)
self.action_quit = QAction(_("&Quit"), self)
self.addAction(self.action_quit)
self.view_resized_timer = QTimer(self)
self.view_resized_timer.timeout.connect(self.viewport_resize_finished)
self.view_resized_timer.setSingleShot(True)
self.resize_in_progress = False
self.action_reload = QAction(_("&Reload book"), self)
self.action_reload.triggered.connect(self.reload_book)
self.action_quit.triggered.connect(self.quit)
self.action_reference_mode.triggered[bool].connect(self.view.reference_mode)
self.action_metadata.triggered[bool].connect(self.metadata.setVisible)
self.action_table_of_contents.toggled[bool].connect(self.set_toc_visible)
self.action_copy.triggered[bool].connect(self.copy)
self.action_font_size_larger.triggered.connect(self.font_size_larger)
self.action_font_size_smaller.triggered.connect(self.font_size_smaller)
self.action_open_ebook.triggered[bool].connect(self.open_ebook)
self.action_next_page.triggered.connect(self.view.next_page)
self.action_previous_page.triggered.connect(self.view.previous_page)
self.action_find_next.triggered.connect(self.find_next)
self.action_find_previous.triggered.connect(self.find_previous)
self.action_full_screen.triggered[bool].connect(self.toggle_fullscreen)
self.action_back.triggered[bool].connect(self.back)
self.action_forward.triggered[bool].connect(self.forward)
self.action_preferences.triggered.connect(self.do_config)
self.pos.editingFinished.connect(self.goto_page_num)
self.vertical_scrollbar.valueChanged[int].connect(lambda x: self.goto_page(x / 100.0))
self.search.search.connect(self.find)
self.search.focus_to_library.connect(lambda: self.view.setFocus(Qt.OtherFocusReason))
self.toc.pressed[QModelIndex].connect(self.toc_clicked)
self.toc.searched.connect(partial(self.toc_clicked, force=True))
self.reference.goto.connect(self.goto)
self.bookmarks.edited.connect(self.bookmarks_edited)
self.bookmarks.activated.connect(self.goto_bookmark)
self.bookmarks.create_requested.connect(self.bookmark)
self.set_bookmarks([])
self.load_theme_menu()
if pathtoebook is not None:
f = functools.partial(self.load_ebook, pathtoebook, open_at=open_at)
QTimer.singleShot(50, f)
self.window_mode_changed = None
self.toggle_toolbar_action = QAction(_("Show/hide controls"), self)
self.toggle_toolbar_action.setCheckable(True)
self.toggle_toolbar_action.triggered.connect(self.toggle_toolbars)
self.toolbar_hidden = None
self.addAction(self.toggle_toolbar_action)
self.full_screen_label_anim = QPropertyAnimation(self.full_screen_label, "size")
self.clock_timer = QTimer(self)
self.clock_timer.timeout.connect(self.update_clock)
self.action_print.triggered.connect(self.print_book)
self.print_menu.actions()[0].triggered.connect(self.print_preview)
self.clear_recent_history_action = QAction(_("Clear list of recently opened books"), self)
self.clear_recent_history_action.triggered.connect(self.clear_recent_history)
self.build_recent_menu()
self.open_history_menu.triggered.connect(self.open_recent)
for x in ("tool_bar", "tool_bar2"):
x = getattr(self, x)
for action in x.actions():
# So that the keyboard shortcuts for these actions will
# continue to function even when the toolbars are hidden
self.addAction(action)
for plugin in self.view.document.all_viewer_plugins:
plugin.customize_ui(self)
self.view.document.settings_changed.connect(self.settings_changed)
self.restore_state()
self.settings_changed()
self.action_toggle_paged_mode.toggled[bool].connect(self.toggle_paged_mode)
if start_in_fullscreen or self.view.document.start_in_fullscreen:
self.action_full_screen.trigger()
self.hide_cursor_timer = t = QTimer(self)
t.setSingleShot(True), t.setInterval(3000)
t.timeout.connect(self.hide_cursor)
t.start()
def eventFilter(self, obj, ev):
if ev.type() == ev.MouseMove:
if self.cursor_hidden:
self.cursor_hidden = False
QApplication.instance().restoreOverrideCursor()
self.hide_cursor_timer.start()
return False
def hide_cursor(self):
self.cursor_hidden = True
QApplication.instance().setOverrideCursor(Qt.BlankCursor)
def toggle_paged_mode(self, checked, at_start=False):
in_paged_mode = not self.action_toggle_paged_mode.isChecked()
self.view.document.in_paged_mode = in_paged_mode
self.action_toggle_paged_mode.setToolTip(
self.FLOW_MODE_TT if self.action_toggle_paged_mode.isChecked() else self.PAGED_MODE_TT
)
if at_start:
return
self.reload()
def settings_changed(self):
for x in ("", "2"):
x = getattr(self, "tool_bar" + x)
x.setVisible(self.view.document.show_controls)
def reload(self):
if hasattr(self, "current_index") and self.current_index > -1:
self.view.document.page_position.save(overwrite=False)
self.pending_restore = True
self.load_path(self.view.last_loaded_path)
def set_toc_visible(self, yes):
self.toc_dock.setVisible(yes)
if not yes:
self.show_toc_on_open = False
def clear_recent_history(self, *args):
vprefs.set("viewer_open_history", [])
self.build_recent_menu()
def build_recent_menu(self):
m = self.open_history_menu
m.clear()
recent = vprefs.get("viewer_open_history", [])
if recent:
m.addAction(self.clear_recent_history_action)
m.addSeparator()
count = 0
for path in recent:
if count > 9:
break
if os.path.exists(path):
m.addAction(RecentAction(path, m))
count += 1
def shutdown(self):
if self.isFullScreen() and not self.view.document.start_in_fullscreen:
self.action_full_screen.trigger()
return False
self.save_state()
return True
def quit(self):
if self.shutdown():
QApplication.instance().quit()
def closeEvent(self, e):
if self.shutdown():
return MainWindow.closeEvent(self, e)
else:
e.ignore()
def toggle_toolbars(self):
for x in ("tool_bar", "tool_bar2"):
x = getattr(self, x)
x.setVisible(not x.isVisible())
def save_state(self):
state = bytearray(self.saveState(self.STATE_VERSION))
vprefs["main_window_state"] = state
if not self.isFullScreen():
vprefs.set("viewer_window_geometry", bytearray(self.saveGeometry()))
if self.current_book_has_toc:
vprefs.set("viewer_toc_isvisible", self.show_toc_on_open or bool(self.toc_dock.isVisible()))
vprefs["multiplier"] = self.view.multiplier
vprefs["in_paged_mode"] = not self.action_toggle_paged_mode.isChecked()
def restore_state(self):
state = vprefs.get("main_window_state", None)
if state is not None:
try:
state = QByteArray(state)
self.restoreState(state, self.STATE_VERSION)
except:
pass
mult = vprefs.get("multiplier", None)
if mult:
self.view.multiplier = mult
# On windows Qt lets the user hide toolbars via a right click in a very
# specific location, ensure they are visible.
self.tool_bar.setVisible(True)
self.tool_bar2.setVisible(True)
self.toc_dock.close() # This will be opened on book open, if the book has a toc and it was previously opened
self.action_toggle_paged_mode.setChecked(not vprefs.get("in_paged_mode", True))
self.toggle_paged_mode(self.action_toggle_paged_mode.isChecked(), at_start=True)
def lookup(self, word):
from urllib import quote
word = quote(word.encode("utf-8"))
try:
url = lookup_website(canonicalize_lang(self.view.current_language) or "en").format(word=word)
except Exception:
traceback.print_exc()
url = default_lookup_website(canonicalize_lang(self.view.current_language) or "en").format(word=word)
open_url(url)
def get_remember_current_page_opt(self):
from calibre.gui2.viewer.documentview import config
c = config().parse()
return c.remember_current_page
def print_book(self):
p = Printing(self.iterator, self)
p.start_print()
def print_preview(self):
p = Printing(self.iterator, self)
p.start_preview()
def toggle_fullscreen(self):
if self.isFullScreen():
self.showNormal()
else:
self.showFullScreen()
def showFullScreen(self):
self.view.document.page_position.save()
self.window_mode_changed = "fullscreen"
self.tool_bar.setVisible(False)
self.tool_bar2.setVisible(False)
self.was_maximized = self.isMaximized()
if not self.view.document.fullscreen_scrollbar:
self.vertical_scrollbar.setVisible(False)
super(EbookViewer, self).showFullScreen()
def show_full_screen_label(self):
f = self.full_screen_label
height = f.final_height
width = int(0.7 * self.view.width())
f.resize(width, height)
if self.view.document.show_fullscreen_help:
f.setVisible(True)
a = self.full_screen_label_anim
a.setDuration(500)
a.setStartValue(QSize(width, 0))
a.setEndValue(QSize(width, height))
a.start()
QTimer.singleShot(3500, self.full_screen_label.hide)
self.view.document.switch_to_fullscreen_mode()
if self.view.document.fullscreen_clock:
self.show_clock()
if self.view.document.fullscreen_pos:
self.show_pos_label()
self.relayout_fullscreen_labels()
def show_clock(self):
self.clock_label.setVisible(True)
self.clock_label.setText(QTime(22, 33, 33).toString(Qt.SystemLocaleShortDate))
self.clock_timer.start(1000)
self.clock_label.setStyleSheet(self.info_label_style % ("rgba(0, 0, 0, 0)", self.view.document.colors()[1]))
self.clock_label.resize(self.clock_label.sizeHint())
self.update_clock()
def show_pos_label(self):
self.pos_label.setVisible(True)
self.pos_label.setStyleSheet(self.info_label_style % ("rgba(0, 0, 0, 0)", self.view.document.colors()[1]))
self.update_pos_label()
def relayout_fullscreen_labels(self):
vswidth = self.vertical_scrollbar.width() if self.vertical_scrollbar.isVisible() else 0
p = self.pos_label
p.move(15, p.parent().height() - p.height() - 10)
c = self.clock_label
c.move(c.parent().width() - vswidth - 15 - c.width(), c.parent().height() - c.height() - 10)
f = self.full_screen_label
f.move((f.parent().width() - f.width()) // 2, (f.parent().height() - f.final_height) // 2)
def update_clock(self):
self.clock_label.setText(QTime.currentTime().toString(Qt.SystemLocaleShortDate))
def update_pos_label(self, *args):
if self.pos_label.isVisible():
try:
value, maximum = args
except:
value, maximum = self.pos.value(), self.pos.maximum()
text = "%g/%g" % (value, maximum)
self.pos_label.setText(text)
self.pos_label.resize(self.pos_label.sizeHint())
def showNormal(self):
self.view.document.page_position.save()
self.clock_label.setVisible(False)
self.pos_label.setVisible(False)
self.clock_timer.stop()
self.vertical_scrollbar.setVisible(True)
self.window_mode_changed = "normal"
self.settings_changed()
self.full_screen_label.setVisible(False)
if self.was_maximized:
super(EbookViewer, self).showMaximized()
else:
super(EbookViewer, self).showNormal()
def handle_window_mode_toggle(self):
if self.window_mode_changed:
fs = self.window_mode_changed == "fullscreen"
self.window_mode_changed = None
if fs:
self.show_full_screen_label()
else:
self.view.document.switch_to_window_mode()
self.view.document.page_position.restore()
self.scrolled(self.view.scroll_fraction)
def goto(self, ref):
if ref:
tokens = ref.split(".")
if len(tokens) > 1:
spine_index = int(tokens[0]) - 1
if spine_index == self.current_index:
self.view.goto(ref)
else:
self.pending_reference = ref
self.load_path(self.iterator.spine[spine_index])
def goto_bookmark(self, bm):
spine_index = bm["spine"]
if spine_index > -1 and self.current_index == spine_index:
if self.resize_in_progress:
self.view.document.page_position.set_pos(bm["pos"])
else:
self.view.goto_bookmark(bm)
# Going to a bookmark does not call scrolled() so we update the
# page position explicitly. Use a timer to ensure it is
# accurate.
QTimer.singleShot(100, self.update_page_number)
else:
self.pending_bookmark = bm
if spine_index < 0 or spine_index >= len(self.iterator.spine):
spine_index = 0
self.pending_bookmark = None
self.load_path(self.iterator.spine[spine_index])
def toc_clicked(self, index, force=False):
if force or QApplication.mouseButtons() & Qt.LeftButton:
item = self.toc_model.itemFromIndex(index)
if item.abspath is not None:
if not os.path.exists(item.abspath):
return error_dialog(
self,
_("No such location"),
_("The location pointed to by this item" " does not exist."),
det_msg=item.abspath,
show=True,
)
url = QUrl.fromLocalFile(item.abspath)
if item.fragment:
url.setFragment(item.fragment)
self.link_clicked(url)
self.view.setFocus(Qt.OtherFocusReason)
def selection_changed(self, selected_text):
self.selected_text = selected_text.strip()
self.action_copy.setEnabled(bool(self.selected_text))
def copy(self, x):
if self.selected_text:
QApplication.clipboard().setText(self.selected_text)
def back(self, x):
pos = self.history.back(self.pos.value())
if pos is not None:
self.goto_page(pos)
def goto_page_num(self):
num = self.pos.value()
self.goto_page(num)
def forward(self, x):
pos = self.history.forward(self.pos.value())
if pos is not None:
self.goto_page(pos)
def goto_start(self):
self.goto_page(1)
def goto_end(self):
self.goto_page(self.pos.maximum())
def goto_page(self, new_page, loaded_check=True):
if self.current_page is not None or not loaded_check:
for page in self.iterator.spine:
if new_page >= page.start_page and new_page <= page.max_page:
try:
frac = float(new_page - page.start_page) / (page.pages - 1)
except ZeroDivisionError:
frac = 0
if page == self.current_page:
self.view.scroll_to(frac)
else:
self.load_path(page, pos=frac)
def open_ebook(self, checked):
files = choose_files(
self,
"ebook viewer open dialog",
_("Choose ebook"),
[(_("Ebooks"), available_input_formats())],
all_files=False,
select_only_single_file=True,
)
if files:
self.load_ebook(files[0])
def open_recent(self, action):
self.load_ebook(action.path)
def font_size_larger(self):
self.view.magnify_fonts()
def font_size_smaller(self):
self.view.shrink_fonts()
def magnification_changed(self, val):
tt = "%(action)s [%(sc)s]\n" + _("Current magnification: %(mag).1f")
sc = _(" or ").join(self.view.shortcuts.get_shortcuts("Font larger"))
self.action_font_size_larger.setToolTip(
tt % dict(action=unicode(self.action_font_size_larger.text()), mag=val, sc=sc)
)
sc = _(" or ").join(self.view.shortcuts.get_shortcuts("Font smaller"))
self.action_font_size_smaller.setToolTip(
tt % dict(action=unicode(self.action_font_size_smaller.text()), mag=val, sc=sc)
)
self.action_font_size_larger.setEnabled(self.view.multiplier < 3)
self.action_font_size_smaller.setEnabled(self.view.multiplier > 0.2)
def find(self, text, repeat=False, backwards=False):
if not text:
self.view.search("")
return self.search.search_done(False)
if self.view.search(text, backwards=backwards):
self.scrolled(self.view.scroll_fraction)
return self.search.search_done(True)
index = self.iterator.search(text, self.current_index, backwards=backwards)
if index is None:
if self.current_index > 0:
index = self.iterator.search(text, 0)
if index is None:
info_dialog(self, _("No matches found"), _("No matches found for: %s") % text).exec_()
return self.search.search_done(True)
return self.search.search_done(True)
self.pending_search = text
self.pending_search_dir = "backwards" if backwards else "forwards"
self.load_path(self.iterator.spine[index])
def find_next(self):
self.find(unicode(self.search.text()), repeat=True)
def find_previous(self):
self.find(unicode(self.search.text()), repeat=True, backwards=True)
def do_search(self, text, backwards):
self.pending_search = None
self.pending_search_dir = None
if self.view.search(text, backwards=backwards):
self.scrolled(self.view.scroll_fraction)
def internal_link_clicked(self, prev_pos):
self.history.add(prev_pos)
def link_clicked(self, url):
path = os.path.abspath(unicode(url.toLocalFile()))
frag = None
if path in self.iterator.spine:
self.update_page_number() # Ensure page number is accurate as it is used for history
self.history.add(self.pos.value())
path = self.iterator.spine[self.iterator.spine.index(path)]
if url.hasFragment():
frag = unicode(url.fragment())
if path != self.current_page:
self.pending_anchor = frag
self.load_path(path)
else:
oldpos = self.view.document.ypos
if frag:
self.view.scroll_to(frag)
else:
# Scroll to top
self.view.scroll_to(0)
if self.view.document.ypos == oldpos:
# If we are coming from goto_next_section() call this will
# cause another goto next section call with the next toc
# entry, since this one did not cause any scrolling at all.
QTimer.singleShot(10, self.update_indexing_state)
else:
open_url(url)
def load_started(self):
self.open_progress_indicator(_("Loading flow..."))
def load_finished(self, ok):
self.close_progress_indicator()
path = self.view.path()
try:
index = self.iterator.spine.index(path)
except (ValueError, AttributeError):
return -1
self.current_page = self.iterator.spine[index]
self.current_index = index
self.set_page_number(self.view.scroll_fraction)
QTimer.singleShot(100, self.update_indexing_state)
if self.pending_search is not None:
self.do_search(self.pending_search, self.pending_search_dir == "backwards")
self.pending_search = None
self.pending_search_dir = None
if self.pending_anchor is not None:
self.view.scroll_to(self.pending_anchor)
self.pending_anchor = None
if self.pending_reference is not None:
self.view.goto(self.pending_reference)
self.pending_reference = None
if self.pending_bookmark is not None:
self.goto_bookmark(self.pending_bookmark)
self.pending_bookmark = None
if self.pending_restore:
self.view.document.page_position.restore()
return self.current_index
def goto_next_section(self):
if hasattr(self, "current_index"):
entry = self.toc_model.next_entry(
self.current_index,
self.view.document.read_anchor_positions(),
self.view.viewport_rect,
self.view.document.in_paged_mode,
)
if entry is not None:
self.pending_goto_next_section = (self.toc_model.currently_viewed_entry, entry, False)
self.toc_clicked(entry.index(), force=True)
def goto_previous_section(self):
if hasattr(self, "current_index"):
entry = self.toc_model.next_entry(
self.current_index,
self.view.document.read_anchor_positions(),
self.view.viewport_rect,
self.view.document.in_paged_mode,
backwards=True,
)
if entry is not None:
self.pending_goto_next_section = (self.toc_model.currently_viewed_entry, entry, True)
self.toc_clicked(entry.index(), force=True)
def update_indexing_state(self, anchor_positions=None):
pgns = getattr(self, "pending_goto_next_section", None)
if hasattr(self, "current_index"):
if anchor_positions is None:
anchor_positions = self.view.document.read_anchor_positions()
items = self.toc_model.update_indexing_state(
self.current_index, self.view.viewport_rect, anchor_positions, self.view.document.in_paged_mode
)
if items:
self.toc.scrollTo(items[-1].index())
if pgns is not None:
self.pending_goto_next_section = None
# Check that we actually progressed
if pgns[0] is self.toc_model.currently_viewed_entry:
entry = self.toc_model.next_entry(
self.current_index,
self.view.document.read_anchor_positions(),
self.view.viewport_rect,
self.view.document.in_paged_mode,
backwards=pgns[2],
current_entry=pgns[1],
)
if entry is not None:
self.pending_goto_next_section = (self.toc_model.currently_viewed_entry, entry, pgns[2])
self.toc_clicked(entry.index(), force=True)
def load_path(self, path, pos=0.0):
self.open_progress_indicator(_("Laying out %s") % self.current_title)
self.view.load_path(path, pos=pos)
def viewport_resize_started(self, event):
if not self.resize_in_progress:
# First resize, so save the current page position
self.resize_in_progress = True
if not self.window_mode_changed:
# The special handling for window mode changed will already
# have saved page position, so only save it if this is not a
# mode change
self.view.document.page_position.save()
if self.resize_in_progress:
self.view_resized_timer.start(75)
def viewport_resize_finished(self):
# There hasn't been a resize event for some time
# restore the current page position.
self.resize_in_progress = False
if self.window_mode_changed:
# This resize is part of a window mode change, special case it
self.handle_window_mode_toggle()
else:
self.view.document.page_position.restore()
if self.isFullScreen():
self.relayout_fullscreen_labels()
self.view.document.after_resize()
# For some reason scroll_fraction returns incorrect results in paged
# mode for some time after a resize is finished. No way of knowing
# exactly how long, so we update it in a second, in the hopes that it
# will be enough *most* of the time.
QTimer.singleShot(1000, self.update_page_number)
def update_page_number(self):
self.set_page_number(self.view.document.scroll_fraction)
return self.pos.value()
def close_progress_indicator(self):
self.pi.stop()
for o in ("tool_bar", "tool_bar2", "view", "horizontal_scrollbar", "vertical_scrollbar"):
getattr(self, o).setEnabled(True)
self.unsetCursor()
self.view.setFocus(Qt.PopupFocusReason)
def open_progress_indicator(self, msg=""):
self.pi.start(msg)
for o in ("tool_bar", "tool_bar2", "view", "horizontal_scrollbar", "vertical_scrollbar"):
getattr(self, o).setEnabled(False)
self.setCursor(Qt.BusyCursor)
def load_theme_menu(self):
from calibre.gui2.viewer.config import load_themes
self.themes_menu.clear()
for key in load_themes():
title = key[len("theme_") :]
self.themes_menu.addAction(title, partial(self.load_theme, key))
def load_theme(self, theme_id):
self.view.load_theme(theme_id)
def do_config(self):
self.view.config(self)
self.load_theme_menu()
from calibre.gui2 import config
if not config["viewer_search_history"]:
self.search.clear_history()
def bookmark(self, *args):
num = 1
bm = None
while True:
bm = _("Bookmark #%d") % num
if bm not in self.existing_bookmarks:
break
num += 1
title, ok = QInputDialog.getText(self, _("Add bookmark"), _("Enter title for bookmark:"), text=bm)
title = unicode(title).strip()
if ok and title:
bm = self.view.bookmark()
bm["spine"] = self.current_index
bm["title"] = title
self.iterator.add_bookmark(bm)
self.set_bookmarks(self.iterator.bookmarks)
self.bookmarks.set_current_bookmark(bm)
def bookmarks_edited(self, bookmarks):
self.build_bookmarks_menu(bookmarks)
self.iterator.set_bookmarks(bookmarks)
self.iterator.save_bookmarks()
def build_bookmarks_menu(self, bookmarks):
self.bookmarks_menu.clear()
sc = _(" or ").join(self.view.shortcuts.get_shortcuts("Bookmark"))
self.bookmarks_menu.addAction(_("Bookmark this location [%s]") % sc, self.bookmark)
self.bookmarks_menu.addAction(_("Show/hide Bookmarks"), self.bookmarks_dock.toggleViewAction().trigger)
self.bookmarks_menu.addSeparator()
current_page = None
self.existing_bookmarks = []
for bm in bookmarks:
if bm["title"] == "calibre_current_page_bookmark":
if self.get_remember_current_page_opt():
current_page = bm
else:
self.existing_bookmarks.append(bm["title"])
self.bookmarks_menu.addAction(bm["title"], partial(self.goto_bookmark, bm))
return current_page
def set_bookmarks(self, bookmarks):
self.bookmarks.set_bookmarks(bookmarks)
return self.build_bookmarks_menu(bookmarks)
@property
def current_page_bookmark(self):
bm = self.view.bookmark()
bm["spine"] = self.current_index
bm["title"] = "calibre_current_page_bookmark"
return bm
def save_current_position(self):
if not self.get_remember_current_page_opt():
return
if hasattr(self, "current_index"):
try:
self.iterator.add_bookmark(self.current_page_bookmark)
except:
traceback.print_exc()
def load_ebook(self, pathtoebook, open_at=None, reopen_at=None):
if self.iterator is not None:
self.save_current_position()
self.iterator.__exit__()
self.iterator = EbookIterator(pathtoebook)
self.history.clear()
self.open_progress_indicator(_("Loading ebook..."))
worker = Worker(target=partial(self.iterator.__enter__, view_kepub=True))
worker.start()
while worker.isAlive():
worker.join(0.1)
QApplication.processEvents()
if worker.exception is not None:
if isinstance(worker.exception, DRMError):
from calibre.gui2.dialogs.drm_error import DRMErrorMessage
DRMErrorMessage(self).exec_()
else:
r = getattr(worker.exception, "reason", worker.exception)
error_dialog(
self,
_("Could not open ebook"),
as_unicode(r) or _("Unknown error"),
det_msg=worker.traceback,
show=True,
)
self.close_progress_indicator()
else:
self.metadata.show_opf(self.iterator.opf, self.iterator.book_format)
self.view.current_language = self.iterator.language
title = self.iterator.opf.title
if not title:
title = os.path.splitext(os.path.basename(pathtoebook))[0]
if self.iterator.toc:
self.toc_model = TOC(self.iterator.spine, self.iterator.toc)
self.toc.setModel(self.toc_model)
if self.show_toc_on_open:
self.action_table_of_contents.setChecked(True)
else:
self.toc_model = TOC(self.iterator.spine)
self.toc.setModel(self.toc_model)
self.action_table_of_contents.setChecked(False)
if isbytestring(pathtoebook):
pathtoebook = force_unicode(pathtoebook, filesystem_encoding)
vh = vprefs.get("viewer_open_history", [])
try:
vh.remove(pathtoebook)
except:
pass
vh.insert(0, pathtoebook)
vprefs.set("viewer_open_history", vh[:50])
self.build_recent_menu()
self.action_table_of_contents.setDisabled(not self.iterator.toc)
self.current_book_has_toc = bool(self.iterator.toc)
self.current_title = title
self.setWindowTitle(title + " [%s]" % self.iterator.book_format + " - " + self.base_window_title)
self.pos.setMaximum(sum(self.iterator.pages))
self.pos.setSuffix(" / %d" % sum(self.iterator.pages))
self.vertical_scrollbar.setMinimum(100)
self.vertical_scrollbar.setMaximum(100 * sum(self.iterator.pages))
self.vertical_scrollbar.setSingleStep(10)
self.vertical_scrollbar.setPageStep(100)
self.set_vscrollbar_value(1)
self.current_index = -1
QApplication.instance().alert(self, 5000)
previous = self.set_bookmarks(self.iterator.bookmarks)
if reopen_at is not None:
previous = reopen_at
if open_at is None and previous is not None:
self.goto_bookmark(previous)
else:
if open_at is None:
self.next_document()
else:
if open_at > self.pos.maximum():
open_at = self.pos.maximum()
if open_at < self.pos.minimum():
open_at = self.pos.minimum()
self.goto_page(open_at, loaded_check=False)
def set_vscrollbar_value(self, pagenum):
self.vertical_scrollbar.blockSignals(True)
self.vertical_scrollbar.setValue(int(pagenum * 100))
self.vertical_scrollbar.blockSignals(False)
def set_page_number(self, frac):
if getattr(self, "current_page", None) is not None:
page = self.current_page.start_page + frac * float(self.current_page.pages - 1)
self.pos.set_value(page)
self.set_vscrollbar_value(page)
def scrolled(self, frac, onload=False):
self.set_page_number(frac)
if not onload:
ap = self.view.document.read_anchor_positions()
self.update_indexing_state(ap)
def next_document(self):
if hasattr(self, "current_index") and self.current_index < len(self.iterator.spine) - 1:
self.load_path(self.iterator.spine[self.current_index + 1])
def previous_document(self):
if hasattr(self, "current_index") and self.current_index > 0:
self.load_path(self.iterator.spine[self.current_index - 1], pos=1.0)
def keyPressEvent(self, event):
if event.key() == Qt.Key_Escape:
if self.metadata.isVisible():
self.metadata.setVisible(False)
event.accept()
return
if self.isFullScreen():
self.action_full_screen.trigger()
event.accept()
return
try:
key = self.view.shortcuts.get_match(event)
except AttributeError:
return MainWindow.keyPressEvent(self, event)
try:
bac = self.bookmarks_menu.actions()[0]
except (AttributeError, TypeError, IndexError, KeyError):
bac = None
action = {
"Quit": self.action_quit,
"Show metadata": self.action_metadata,
"Copy": self.view.copy_action,
"Font larger": self.action_font_size_larger,
"Font smaller": self.action_font_size_smaller,
"Fullscreen": self.action_full_screen,
"Find next": self.action_find_next,
"Find previous": self.action_find_previous,
"Search online": self.view.search_online_action,
"Lookup word": self.view.dictionary_action,
"Next occurrence": self.view.search_action,
"Bookmark": bac,
"Reload": self.action_reload,
"Table of Contents": self.action_table_of_contents,
}.get(key, None)
if action is not None:
event.accept()
action.trigger()
return
if key == "Focus Search":
self.search.setFocus(Qt.OtherFocusReason)
return
if not self.view.handle_key_press(event):
event.ignore()
def reload_book(self):
if getattr(self.iterator, "pathtoebook", None):
try:
reopen_at = self.current_page_bookmark
except Exception:
reopen_at = None
self.load_ebook(self.iterator.pathtoebook, reopen_at=reopen_at)
return
def __enter__(self):
return self
def __exit__(self, *args):
if self.iterator is not None:
self.save_current_position()
self.iterator.__exit__(*args)
def read_settings(self):
c = config().parse()
if c.remember_window_size:
wg = vprefs.get("viewer_window_geometry", None)
if wg is not None:
self.restoreGeometry(wg)
self.show_toc_on_open = vprefs.get("viewer_toc_isvisible", False)
desktop = QApplication.instance().desktop()
av = desktop.availableGeometry(self).height() - 30
if self.height() > av:
self.resize(self.width(), av)
