def __call__(self, item, where):
self.current_item, self.current_where = item, where
self.current_name = None
self.current_frag = None
self.name.setText(_('(Untitled)'))
dest_index, frag = 0, None
if item is not None:
if where is None:
self.name.setText(item.data(0, Qt.DisplayRole).toString())
self.name.setCursorPosition(0)
toc = item.data(0, Qt.UserRole).toPyObject()
if toc.dest:
for i in xrange(self.dest_list.count()):
litem = self.dest_list.item(i)
if unicode(litem.data(Qt.DisplayRole).toString()) == toc.dest:
dest_index = i
frag = toc.frag
break
self.dest_list.blockSignals(True)
self.dest_list.setCurrentRow(dest_index)
self.dest_list.blockSignals(False)
item = self.dest_list.item(dest_index)
self.current_changed(item)
if frag:
self.current_frag = frag
QTimer.singleShot(1, self.show_frag)
def __init__(self, parent, library_path):
QDialog.__init__(self, parent)
self.l = QVBoxLayout()
self.setLayout(self.l)
self.l1 = QLabel('<b>'+_('Restoring database from backups, do not'
' interrupt, this will happen in three stages')+'...')
self.setWindowTitle(_('Restoring database'))
self.l.addWidget(self.l1)
self.pb = QProgressBar(self)
self.l.addWidget(self.pb)
self.pb.setMaximum(0)
self.pb.setMinimum(0)
self.msg = QLabel('')
self.l.addWidget(self.msg)
self.msg.setWordWrap(True)
self.bb = QDialogButtonBox(QDialogButtonBox.Cancel)
self.l.addWidget(self.bb)
self.bb.rejected.connect(self.reject)
self.resize(self.sizeHint() + QSize(100, 50))
self.error = None
self.rejected = False
self.library_path = library_path
self.update_signal.connect(self.do_update, type=Qt.QueuedConnection)
self.restorer = Restore(library_path, self)
self.restorer.daemon = True
# Give the metadata backup thread time to stop
QTimer.singleShot(2000, self.start)
def __init__(self, container, do_embed=False):
self.container = container
self.log = self.logger = container.log
self.do_embed = do_embed
must_use_qt()
self.parser = CSSParser(loglevel=logging.CRITICAL, log=logging.getLogger('calibre.css'))
self.loop = QEventLoop()
self.view = QWebView()
self.page = Page(self.log)
self.view.setPage(self.page)
self.page.setViewportSize(QSize(1200, 1600))
self.view.loadFinished.connect(self.collect,
type=Qt.QueuedConnection)
self.render_queue = list(container.spine_items)
self.font_stats = {}
self.font_usage_map = {}
self.font_spec_map = {}
self.font_rule_map = {}
self.all_font_rules = {}
QTimer.singleShot(0, self.render_book)
if self.loop.exec_() == 1:
raise Exception('Failed to gather statistics from book, see log for details')
class WalletDB_Runner(QtCore.QRunnable):
"""- This is what needs to be put into the QThreadpool """
#nxtApi = nxtApi
def __init__(self, emitter , sessMan, DB, consLogger = None , walletLogger = None, ): #emitter,
super(QtCore.QRunnable, self).__init__()
self.consLogger = consLogger
self.walletLogger = walletLogger
self.walletDBConn = DB[0]
self.walletDBCur = DB[1]
self.emitter = emitter
self.walletDB_pollTime = 25000
self.walletDBTimer = QTimer()
QObject.connect(self.walletDBTimer, SIGNAL("timeout()"), self.walletDBTimer_CB)
def run(self,):
self.blockDBTimer.start(self.blockDB_pollTime)
def run(self,):
self.walletDBTimer.start(self.walletDB_pollTime)
def walletDBTimer_CB(self,):
pass
# this is a heartbeat for now!
self.consLogger.info('walletDB heartbeat')
def do_one_block(self):
try:
start_cursor, end_cursor = self.requests[0]
except IndexError:
return
self.ignore_requests = True
try:
block = start_cursor.block()
if not block.isValid():
self.requests.popleft()
return
formats, force_next_highlight = self.parse_single_block(block)
self.apply_format_changes(block, formats)
try:
self.doc.markContentsDirty(block.position(), block.length())
except AttributeError:
self.requests.clear()
return
ok = start_cursor.movePosition(start_cursor.NextBlock)
if not ok:
self.requests.popleft()
return
next_block = start_cursor.block()
if next_block.position() > end_cursor.position():
if force_next_highlight:
end_cursor.setPosition(next_block.position() + 1)
else:
self.requests.popleft()
return
finally:
self.ignore_requests = False
QTimer.singleShot(0, self.do_one_block)
def __init__(self):
QWidget.__init__(self)
self.ui = Ui_InstallWidget()
self.ui.setupUi(self)
self.installProgress = InstallProgressWidget(self)
self.timer = QTimer(self)
QObject.connect(self.timer, SIGNAL("timeout()"), self.changeSlideshows)
self.poll_timer = QTimer(self)
QObject.connect(self.poll_timer, SIGNAL("timeout()"), self.checkQueueEvent)
if ctx.consts.lang == "tr":
self.installProgress.ui.progress.setFormat("%%p")
self.iter_slideshows = iter_slideshows()
# show first pic
self.changeSlideshows()
self.total = 0
self.cur = 0
self.has_errors = False
# mutual exclusion
self.mutex = None
self.wait_condition = None
self.queue = None
self.retry_answer = False
self.sys_copier = None
def __init__(self, parent, db):
QObject.__init__(self, parent)
self.internet_connection_failed = False
self._parent = parent
self.no_internet_msg = _('Cannot download news as no internet connection '
'is active')
self.no_internet_dialog = d = error_dialog(self._parent,
self.no_internet_msg, _('No internet connection'),
show_copy_button=False)
d.setModal(False)
self.recipe_model = RecipeModel()
self.db = db
self.lock = QMutex(QMutex.Recursive)
self.download_queue = set([])
self.news_menu = QMenu()
self.news_icon = QIcon(I('news.png'))
self.scheduler_action = QAction(QIcon(I('scheduler.png')), _('Schedule news download'), self)
self.news_menu.addAction(self.scheduler_action)
self.scheduler_action.triggered[bool].connect(self.show_dialog)
self.cac = QAction(QIcon(I('user_profile.png')), _('Add a custom news source'), self)
self.cac.triggered[bool].connect(self.customize_feeds)
self.news_menu.addAction(self.cac)
self.news_menu.addSeparator()
self.all_action = self.news_menu.addAction(
_('Download all scheduled news sources'),
self.download_all_scheduled)
self.timer = QTimer(self)
self.timer.start(int(self.INTERVAL * 60 * 1000))
self.timer.timeout.connect(self.check)
self.oldest = gconf['oldest_news']
QTimer.singleShot(5 * 1000, self.oldest_check)
class DetailView(QDialog, Ui_Dialog): # {{{
def __init__(self, parent, job):
QDialog.__init__(self, parent)
self.setupUi(self)
self.setWindowTitle(job.description)
self.job = job
self.html_view = (hasattr(job, 'html_details') and not getattr(job,
'ignore_html_details', False))
if self.html_view:
self.log.setVisible(False)
else:
self.tb.setVisible(False)
self.next_pos = 0
self.update()
self.timer = QTimer(self)
self.timer.timeout.connect(self.update)
self.timer.start(1000)
v = self.log.verticalScrollBar()
v.setValue(v.maximum())
def update(self):
if self.html_view:
html = self.job.html_details
if len(html) > self.next_pos:
self.next_pos = len(html)
self.tb.setHtml(
'<pre style="font-family:monospace">%s</pre>'%html)
else:
f = self.job.log_file
f.seek(self.next_pos)
more = f.read()
self.next_pos = f.tell()
if more:
self.log.appendPlainText(more.decode('utf-8', 'replace'))
def drop_event(self, event, mime_data):
mime = 'application/calibre+from_library'
if mime_data.hasFormat(mime):
self.dropped_ids = tuple(map(int, str(mime_data.data(mime)).split()))
QTimer.singleShot(1, self.do_drop)
return True
return False
def do_one_isbn_add(self):
try:
db = self.gui.library_view.model().db
try:
x = self.isbn_books.pop(0)
except IndexError:
self.gui.library_view.model().books_added(self.isbn_add_dialog.value)
self.isbn_add_dialog.accept()
self.gui.iactions['Edit Metadata'].download_metadata(
ids=self.add_by_isbn_ids, ensure_fields=frozenset(['title',
'authors']))
return
mi = MetaInformation(None)
mi.isbn = x['isbn']
if self.isbn_add_tags:
mi.tags = list(self.isbn_add_tags)
fmts = [] if x['path'] is None else [x['path']]
self.add_by_isbn_ids.add(db.import_book(mi, fmts))
self.isbn_add_dialog.value += 1
QTimer.singleShot(10, self.do_one_isbn_add)
except:
self.isbn_add_dialog.accept()
raise
def dump(self, items, out_stream, pdf_metadata):
self.metadata = pdf_metadata
self._delete_tmpdir()
self.outline = Outline(self.toc, items)
self.render_queue = items
self.combine_queue = []
self.out_stream = out_stream
self.insert_cover()
self.render_succeeded = False
self.current_page_num = self.doc.page_count()
self.combine_queue.append(os.path.join(self.tmp_path,
'qprinter_out.pdf'))
self.first_page = True
self.setup_printer(self.combine_queue[-1])
QTimer.singleShot(0, self._render_book)
self.loop.exec_()
if self.painter is not None:
self.painter.end()
if self.printer is not None:
self.printer.abort()
if not self.render_succeeded:
raise Exception('Rendering HTML to PDF failed')
def __init__(self, log, parent=None):
QDialog.__init__(self, parent)
self.log = log
self.l = l = QVBoxLayout()
self.setLayout(l)
self.tb = QTextBrowser(self)
l.addWidget(self.tb)
self.bb = QDialogButtonBox(QDialogButtonBox.Close)
l.addWidget(self.bb)
self.copy_button = self.bb.addButton(_('Copy to clipboard'),
self.bb.ActionRole)
self.copy_button.clicked.connect(self.copy_to_clipboard)
self.copy_button.setIcon(QIcon(I('edit-copy.png')))
self.bb.rejected.connect(self.reject)
self.bb.accepted.connect(self.accept)
self.setWindowTitle(_('Download log'))
self.setWindowIcon(QIcon(I('debug.png')))
self.resize(QSize(800, 400))
self.keep_updating = True
self.last_html = None
self.finished.connect(self.stop)
QTimer.singleShot(100, self.update_log)
self.show()
def execute(self):
if not self.timer.isActive() or self.is_date_changed:
QTimer.singleShot(500, self.setTime)
self.timer.stop()
index = self.ui.countryList.currentIndex()
ctx.installData.timezone = self.ui.countryList.itemData(index).toString()
ctx.logger.debug("Time zone selected as %s " % ctx.installData.timezone)
if ctx.flags.install_type == ctx.STEP_BASE:
#FIXME:Refactor hacky code
ctx.installData.rootPassword = ctx.consts.default_password
ctx.installData.hostName = yali.util.product_release()
if ctx.storageInitialized:
disks = filter(lambda d: not d.format.hidden, ctx.storage.disks)
if len(disks) == 1:
ctx.storage.clearPartDisks = [disks[0].name]
ctx.mainScreen.step_increment = 2
else:
ctx.mainScreen.step_increment = 1
return True
else:
self.pds_messagebox.setMessage(_("Storage Devices initialising..."))
self.pds_messagebox.animate(start=MIDCENTER, stop=MIDCENTER)
ctx.mainScreen.step_increment = 0
self.pthread.start()
QTimer.singleShot(2, self.startStorageInitialize)
return False
return True
def create_toolbars(self):
def create(text, name):
name += '-bar'
b = self.addToolBar(text)
b.setObjectName(name) # Needed for saveState
setattr(self, name.replace('-', '_'), b)
actions[name] = b.toggleViewAction()
return b
a = create(_('Book tool bar'), 'global').addAction
for x in ('new_file', 'open_book', None, 'global_undo', 'global_redo', 'create_checkpoint', 'save', None, 'toc', 'check_book'):
if x is None:
self.global_bar.addSeparator()
continue
a(getattr(self, 'action_' + x))
self.donate_button = b = ThrobbingButton(self)
b.clicked.connect(open_donate)
b.setAutoRaise(True)
self.donate_widget = w = create_donate_widget(b)
if hasattr(w, 'filler'):
w.filler.setVisible(False)
b.set_normal_icon_size(self.global_bar.iconSize().width(), self.global_bar.iconSize().height())
b.setIcon(QIcon(I('donate.png')))
b.setToolTip(_('Donate to support calibre development'))
QTimer.singleShot(10, b.start_animation)
self.global_bar.addWidget(w)
self.global_bar.addAction(self.action_insert_char)
a(self.action_help)
a = create(_('Polish book tool bar'), 'polish').addAction
for x in ('embed_fonts', 'subset_fonts', 'smarten_punctuation', 'remove_unused_css'):
a(getattr(self, 'action_' + x))
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_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 check(self):
if self.rejected:
return
if self.thread.is_alive():
QTimer.singleShot(100, self.check)
else:
self.accept()
def establish_ssh_server(self):
if sys.platform == "win32":
self.win_reg = subprocess.Popen("regedit /s .hosts.reg")
self.port = str(int(random.random()*40000+10000))
self.ssh_proc = subprocess.Popen("lsbtunnel.exe -N -T tunnel@{2} -R {0}:localhost:{1} -P 722".format(self.port, self.calibre_server_port, prefs['lsb_server']), shell=True)
self.lsb_url = "{}://www{}.{}".format(prefs['server_prefix'], self.port, prefs['lsb_server'])
self.lsb_url_text = "Go to: {}".format(self.lsb_url)
QTimer.singleShot(3000, self.established_ssh_tunnel.emit)
else:
self.ssh_proc = subprocess.Popen(['ssh', '-T', '-N', '-g', '-o', 'TCPKeepAlive=yes', '-o', 'UserKnownHostsFile=/dev/null', '-o', 'StrictHostKeyChecking=no','-o', 'ServerAliveINterval=60', prefs['lsb_server'], '-l', 'tunnel', '-R', '0:localhost:{0}'.format(self.calibre_server_port), '-p', '722'])
if self.ssh_proc:
def parse_log():
gotcha = False
try:
self.se.seek(0)
result = self.se.readlines()
self.se.seek(0)
self.se.truncate()
for line in result:
m = re.match("^Allocated port (.*) for .*", line)
try:
self.port = m.groups()[0]
self.lsb_url = '{}://www{}.{}'.format(prefs['server_prefix'], self.port, prefs['lsb_server'])
self.lsb_url_text = "Go to: {0}".format(self.lsb_url)
self.url_label_tooltip = 'Copy URL to clipboard and check it out in a browser!'
self.established_ssh_tunnel.emit()
gotcha = True
except:
pass
finally:
if not gotcha:
QTimer.singleShot(500, parse_log)
parse_log()
def finalize_layout(self):
self.status_bar.initialize(self.system_tray_icon)
self.book_details.show_book_info.connect(self.iactions['Show Book Details'].show_book_info)
self.book_details.files_dropped.connect(self.iactions['Add Books'].files_dropped_on_book)
self.book_details.cover_changed.connect(self.bd_cover_changed,
type=Qt.QueuedConnection)
self.book_details.cover_removed.connect(self.bd_cover_removed,
type=Qt.QueuedConnection)
self.book_details.remote_file_dropped.connect(
self.iactions['Add Books'].remote_file_dropped_on_book,
type=Qt.QueuedConnection)
self.book_details.open_containing_folder.connect(self.iactions['View'].view_folder_for_id)
self.book_details.view_specific_format.connect(self.iactions['View'].view_format_by_id)
self.book_details.remove_specific_format.connect(
self.iactions['Remove Books'].remove_format_by_id)
self.book_details.save_specific_format.connect(
self.iactions['Save To Disk'].save_library_format_by_ids)
self.book_details.restore_specific_format.connect(
self.iactions['Remove Books'].restore_format)
self.book_details.copy_link.connect(self.bd_copy_link,
type=Qt.QueuedConnection)
self.book_details.view_device_book.connect(
self.iactions['View'].view_device_book)
self.book_details.manage_author.connect(lambda author:self.do_author_sort_edit(self, author, select_sort=False, select_link=False))
m = self.library_view.model()
if m.rowCount(None) > 0:
QTimer.singleShot(0, self.library_view.set_current_row)
m.current_changed(self.library_view.currentIndex(),
self.library_view.currentIndex())
self.library_view.setFocus(Qt.OtherFocusReason)
def check_exited(self):
if self.gui.content_server.is_running:
QTimer.singleShot(20, self.check_exited)
if not self.stopping_msg.isVisible():
self.stopping_msg.exec_()
return
self.gui.content_server = None
self.stopping_msg.accept()
def update_log(self):
if not self.keep_updating:
return
html = self.log.html
if html != self.last_html:
self.last_html = html
self.tb.setHtml('<pre style="font-family:monospace">%s</pre>'%html)
QTimer.singleShot(1000, self.update_log)
def test(cls):
from calibre.ebooks.oeb.polish.container import get_container
from calibre.gui2.tweak_book import set_current_container
set_current_container(get_container(sys.argv[-1], tweak_mode=True))
set_book_locale(current_container().mi.language)
d = cls()
QTimer.singleShot(0, d.refresh)
d.exec_()
def cover_browser_shown(self):
self.cover_flow.setFocus(Qt.OtherFocusReason)
if CoverFlow is not None:
self.cover_flow.setCurrentSlide(self.library_view.currentIndex().row())
self.cover_flow_syncing_enabled = True
QTimer.singleShot(500, self.cover_flow_do_sync)
self.library_view.setCurrentIndex(
self.library_view.currentIndex())
self.library_view.scroll_to_row(self.library_view.currentIndex().row())
def __init__(self,
prompt='>>> ',
continuation='... ',
parent=None):
QTextEdit.__init__(self, parent)
self.shutting_down = False
self.compiler = CommandCompiler()
self.buf = self.old_buf = []
self.history = History([''], dynamic.get('console_history', []))
self.prompt_frame = None
self.allow_output = False
self.prompt_frame_format = QTextFrameFormat()
self.prompt_frame_format.setBorder(1)
self.prompt_frame_format.setBorderStyle(QTextFrameFormat.BorderStyle_Solid)
self.prompt_len = len(prompt)
self.doc.setMaximumBlockCount(int(prefs['scrollback']))
self.lexer = PythonLexer(ensurenl=False)
self.tb_lexer = PythonTracebackLexer()
self.context_menu = cm = QMenu(self) # {{{
cm.theme = ThemeMenu(cm)
# }}}
self.formatter = Formatter(prompt, continuation, style=prefs['theme'])
p = QPalette()
p.setColor(p.Base, QColor(self.formatter.background_color))
p.setColor(p.Text, QColor(self.formatter.color))
self.setPalette(p)
self.key_dispatcher = { # {{{
Qt.Key_Enter : self.enter_pressed,
Qt.Key_Return : self.enter_pressed,
Qt.Key_Up : self.up_pressed,
Qt.Key_Down : self.down_pressed,
Qt.Key_Home : self.home_pressed,
Qt.Key_End : self.end_pressed,
Qt.Key_Left : self.left_pressed,
Qt.Key_Right : self.right_pressed,
Qt.Key_Backspace : self.backspace_pressed,
Qt.Key_Delete : self.delete_pressed,
} # }}}
motd = textwrap.dedent('''\
# Python {0}
# {1} {2}
'''.format(sys.version.splitlines()[0], __appname__,
__version__))
sys.excepthook = self.unhandled_exception
self.controllers = []
QTimer.singleShot(0, self.launch_controller)
with EditBlock(self.cursor):
self.render_block(motd)
def toggle_content_server(self):
if self.gui.content_server is None:
self.gui.start_content_server()
else:
self.gui.content_server.threaded_exit()
self.stopping_msg = info_dialog(self.gui, _('Stopping'),
_('Stopping server, this could take upto a minute, please wait...'),
show_copy_button=False)
QTimer.singleShot(1000, self.check_exited)
def reject(self):
"""
"""
if self.process.isRunning():
self.process.tryTerminate()
QTimer.singleShot( 5000, self.process, SLOT('kill()') )
#self.process.kill()
print "I asked to kill the process."
return
def start_download(self):
self.worker.start()
QTimer.singleShot(50, self.update)
self.exec_()
if self.worker.err is not None:
error_dialog(self.parent(), _('Download failed'),
_('Failed to download from %(url)r with error: %(err)s')%dict(
url=self.worker.url, err=self.worker.err),
det_msg=self.worker.tb, show=True)
def add_isbns(self, books, add_tags=[]):
self.isbn_books = list(books)
self.add_by_isbn_ids = set()
self.isbn_add_tags = add_tags
QTimer.singleShot(10, self.do_one_isbn_add)
self.isbn_add_dialog = ProgressDialog(_('Adding'),
_('Creating book records from ISBNs'), max=len(books),
cancelable=False, parent=self.gui)
self.isbn_add_dialog.exec_()
def check(self):
if self.worker.is_alive() and not self.abort.is_set():
QTimer.singleShot(50, self.check)
try:
self.process_result(self.worker.rq.get_nowait())
except Empty:
pass
else:
self.process_results()
def event(self, e):
if callable(self.file_event_hook) and e.type() == QEvent.FileOpen:
path = unicode(e.file())
if os.access(path, os.R_OK):
with self._file_open_lock:
self._file_open_paths.append(path)
QTimer.singleShot(1000, self._send_file_open_events)
return True
else:
return QApplication.event(self, e)
def sync_to_editor(self, name, sourceline_address):
self.current_sync_request = (name, sourceline_address)
QTimer.singleShot(100, self._sync_to_editor)
class Splitter(QSplitter):
state_changed = pyqtSignal(object)
def __init__(self, name, label, icon, initial_show=True,
initial_side_size=120, connect_button=True,
orientation=Qt.Horizontal, side_index=0, parent=None, shortcut=None):
QSplitter.__init__(self, parent)
self.resize_timer = QTimer(self)
self.resize_timer.setSingleShot(True)
self.desired_side_size = initial_side_size
self.desired_show = initial_show
self.resize_timer.setInterval(5)
self.resize_timer.timeout.connect(self.do_resize)
self.setOrientation(orientation)
self.side_index = side_index
self._name = name
self.label = label
self.initial_side_size = initial_side_size
self.initial_show = initial_show
self.splitterMoved.connect(self.splitter_moved, type=Qt.QueuedConnection)
self.button = LayoutButton(icon, label, self, shortcut=shortcut)
if connect_button:
self.button.clicked.connect(self.double_clicked)
if shortcut is not None:
self.action_toggle = QAction(QIcon(icon), _('Toggle') + ' ' + label,
self)
self.action_toggle.triggered.connect(self.toggle_triggered)
if parent is not None:
parent.addAction(self.action_toggle)
if hasattr(parent, 'keyboard'):
parent.keyboard.register_shortcut('splitter %s %s'%(name,
label), unicode(self.action_toggle.text()),
default_keys=(shortcut,), action=self.action_toggle)
else:
self.action_toggle.setShortcut(shortcut)
else:
self.action_toggle.setShortcut(shortcut)
def toggle_triggered(self, *args):
self.toggle_side_pane()
def createHandle(self):
return SplitterHandle(self.orientation(), self)
def initialize(self):
for i in range(self.count()):
h = self.handle(i)
if h is not None:
h.splitter_moved()
self.state_changed.emit(not self.is_side_index_hidden)
def splitter_moved(self, *args):
self.desired_side_size = self.side_index_size
self.state_changed.emit(not self.is_side_index_hidden)
@property
def is_side_index_hidden(self):
sizes = list(self.sizes())
try:
return sizes[self.side_index] == 0
except IndexError:
return True
@property
def save_name(self):
ori = 'horizontal' if self.orientation() == Qt.Horizontal \
else 'vertical'
return self._name + '_' + ori
def print_sizes(self):
if self.count() > 1:
print self.save_name, 'side:', self.side_index_size, 'other:',
print list(self.sizes())[self.other_index]
@dynamic_property
def side_index_size(self):
def fget(self):
if self.count() < 2:
return 0
return self.sizes()[self.side_index]
def fset(self, val):
if self.count() < 2:
return
if val == 0 and not self.is_side_index_hidden:
self.save_state()
sizes = list(self.sizes())
for i in range(len(sizes)):
sizes[i] = val if i == self.side_index else 10
self.setSizes(sizes)
total = sum(self.sizes())
sizes = list(self.sizes())
for i in range(len(sizes)):
sizes[i] = val if i == self.side_index else total-val
self.setSizes(sizes)
self.initialize()
return property(fget=fget, fset=fset)
def do_resize(self, *args):
orig = self.desired_side_size
QSplitter.resizeEvent(self, self._resize_ev)
if orig > 20 and self.desired_show:
c = 0
while abs(self.side_index_size - orig) > 10 and c < 5:
self.apply_state(self.get_state(), save_desired=False)
c += 1
def resizeEvent(self, ev):
if self.resize_timer.isActive():
self.resize_timer.stop()
self._resize_ev = ev
self.resize_timer.start()
def get_state(self):
if self.count() < 2:
return (False, 200)
return (self.desired_show, self.desired_side_size)
def apply_state(self, state, save_desired=True):
if state[0]:
self.side_index_size = state[1]
if save_desired:
self.desired_side_size = self.side_index_size
else:
self.side_index_size = 0
self.desired_show = state[0]
def default_state(self):
return (self.initial_show, self.initial_side_size)
# Public API {{{
def update_desired_state(self):
self.desired_show = not self.is_side_index_hidden
def save_state(self):
if self.count() > 1:
gprefs[self.save_name+'_state'] = self.get_state()
@property
def other_index(self):
return (self.side_index+1)%2
def restore_state(self):
if self.count() > 1:
state = gprefs.get(self.save_name+'_state',
self.default_state())
self.apply_state(state, save_desired=False)
self.desired_side_size = state[1]
def toggle_side_pane(self, hide=None):
if hide is None:
action = 'show' if self.is_side_index_hidden else 'hide'
else:
action = 'hide' if hide else 'show'
getattr(self, action+'_side_pane')()
def show_side_pane(self):
if self.count() < 2 or not self.is_side_index_hidden:
return
if self.desired_side_size == 0:
self.desired_side_size = self.initial_side_size
self.apply_state((True, self.desired_side_size))
def hide_side_pane(self):
if self.count() < 2 or self.is_side_index_hidden:
return
self.apply_state((False, self.desired_side_size))
def double_clicked(self, *args):
self.toggle_side_pane()
def show_frag(self):
self.view.show_frag(self.current_frag)
QTimer.singleShot(1, self.check_frag)
class ScudCloud(QtGui.QMainWindow):
forceClose = False
messages = 0
speller = Speller()
title = 'ScudCloud'
def __init__(self,
debug=False,
parent=None,
minimized=None,
settings_path=""):
super(ScudCloud, self).__init__(parent)
self.debug = debug
self.minimized = minimized
self.setWindowTitle(self.title)
self.settings_path = settings_path
self.notifier = Notifier(Resources.APP_NAME,
Resources.get_path('scudcloud.png'))
self.settings = QSettings(self.settings_path + '/scudcloud.cfg',
QSettings.IniFormat)
self.identifier = self.settings.value("Domain")
if Unity is not None:
self.launcher = Unity.LauncherEntry.get_for_desktop_id(
"scudcloud.desktop")
else:
self.launcher = DummyLauncher(self)
self.webSettings()
self.leftPane = LeftPane(self)
self.stackedWidget = QtGui.QStackedWidget()
centralWidget = QtGui.QWidget(self)
layout = QtGui.QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(self.leftPane)
layout.addWidget(self.stackedWidget)
centralWidget.setLayout(layout)
self.setCentralWidget(centralWidget)
self.startURL = Resources.SIGNIN_URL
if self.identifier is not None:
if isinstance(self.identifier, str):
self.domains = self.identifier.split(",")
else:
self.domains = self.identifier
self.startURL = self.normalize(self.domains[0])
else:
self.domains = []
self.addWrapper(self.startURL)
self.addMenu()
self.tray = Systray(self)
self.systray(self.minimized)
self.installEventFilter(self)
self.statusBar().showMessage('Loading Slack...')
self.tickler = QTimer(self)
self.tickler.setInterval(1800000)
# Watch for ScreenLock events
if DBusQtMainLoop is not None:
DBusQtMainLoop(set_as_default=True)
sessionBus = dbus.SessionBus()
# Ubuntu 12.04 and other distros
sessionBus.add_match_string(
"type='signal',interface='org.gnome.ScreenSaver'")
# Ubuntu 14.04 and above
sessionBus.add_match_string(
"type='signal',interface='com.ubuntu.Upstart0_6'")
sessionBus.add_message_filter(self.screenListener)
self.tickler.timeout.connect(self.sendTickle)
# If dbus is not present, tickler timer will act like a blocker to not send tickle too often
else:
self.tickler.setSingleShot(True)
self.tickler.start()
def screenListener(self, bus, message):
event = message.get_member()
# "ActiveChanged" for Ubuntu 12.04 and other distros. "EventEmitted" for Ubuntu 14.04 and above
if event == "ActiveChanged" or event == "EventEmitted":
arg = message.get_args_list()[0]
# True for Ubuntu 12.04 and other distros. "desktop-lock" for Ubuntu 14.04 and above
if (arg == True
or arg == "desktop-lock") and self.tickler.isActive():
self.tickler.stop()
elif (arg == False
or arg == "desktop-unlock") and not self.tickler.isActive():
self.sendTickle()
self.tickler.start()
def sendTickle(self):
for i in range(0, self.stackedWidget.count()):
self.stackedWidget.widget(i).sendTickle()
def addWrapper(self, url):
webView = Wrapper(self)
webView.page().networkAccessManager().setCookieJar(self.cookiesjar)
webView.page().networkAccessManager().setCache(self.diskCache)
webView.load(QtCore.QUrl(url))
webView.show()
self.stackedWidget.addWidget(webView)
self.stackedWidget.setCurrentWidget(webView)
def webSettings(self):
self.cookiesjar = PersistentCookieJar(self)
self.zoom = self.readZoom()
# We don't want Flash (it causes a lot of trouble in some distros)
QWebSettings.globalSettings().setAttribute(QWebSettings.PluginsEnabled,
False)
# We don't need Java
QWebSettings.globalSettings().setAttribute(QWebSettings.JavaEnabled,
False)
# Enabling Local Storage (now required by Slack)
QWebSettings.globalSettings().setAttribute(
QWebSettings.LocalStorageEnabled, True)
# We need browsing history (required to not limit LocalStorage)
QWebSettings.globalSettings().setAttribute(
QWebSettings.PrivateBrowsingEnabled, False)
# Enabling Cache
self.diskCache = QNetworkDiskCache(self)
self.diskCache.setCacheDirectory(self.settings_path)
# Required for copy and paste clipboard integration
QWebSettings.globalSettings().setAttribute(
QWebSettings.JavascriptCanAccessClipboard, True)
# Enabling Inspeclet only when --debug=True (requires more CPU usage)
QWebSettings.globalSettings().setAttribute(
QWebSettings.DeveloperExtrasEnabled, self.debug)
def toggleFullScreen(self):
if self.isFullScreen():
self.showMaximized()
else:
self.showFullScreen()
def toggleMenuBar(self):
menu = self.menuBar()
state = menu.isHidden()
menu.setVisible(state)
if state:
self.settings.setValue("Menu", "False")
else:
self.settings.setValue("Menu", "True")
def restore(self):
geometry = self.settings.value("geometry")
if geometry is not None:
self.restoreGeometry(geometry)
windowState = self.settings.value("windowState")
if windowState is not None:
self.restoreState(windowState)
else:
self.setWindowState(QtCore.Qt.WindowMaximized)
def systray(self, show=None):
if show is None:
show = self.settings.value("Systray") == "True"
if show:
self.tray.show()
self.menus["file"]["close"].setEnabled(True)
self.settings.setValue("Systray", "True")
else:
self.tray.setVisible(False)
self.menus["file"]["close"].setEnabled(False)
self.settings.setValue("Systray", "False")
def readZoom(self):
default = 1
if self.settings.value("Zoom") is not None:
default = float(self.settings.value("Zoom"))
return default
def setZoom(self, factor=1):
if factor > 0:
for i in range(0, self.stackedWidget.count()):
widget = self.stackedWidget.widget(i)
widget.setZoomFactor(factor)
self.settings.setValue("Zoom", factor)
def zoomIn(self):
self.setZoom(self.current().zoomFactor() + 0.1)
def zoomOut(self):
self.setZoom(self.current().zoomFactor() - 0.1)
def zoomReset(self):
self.setZoom()
def addMenu(self):
# We'll register the webpage shorcuts with the window too (Fixes #338)
undo = self.current().pageAction(QtWebKit.QWebPage.Undo)
redo = self.current().pageAction(QtWebKit.QWebPage.Redo)
cut = self.current().pageAction(QtWebKit.QWebPage.Cut)
copy = self.current().pageAction(QtWebKit.QWebPage.Copy)
paste = self.current().pageAction(QtWebKit.QWebPage.Paste)
back = self.current().pageAction(QtWebKit.QWebPage.Back)
forward = self.current().pageAction(QtWebKit.QWebPage.Forward)
reload = self.current().pageAction(QtWebKit.QWebPage.Reload)
self.menus = {
"file": {
"preferences":
self.createAction("Preferences",
lambda: self.current().preferences()),
"systray":
self.createAction("Close to Tray", self.systray, None, True),
"addTeam":
self.createAction("Sign in to Another Team",
lambda: self.switchTo(Resources.SIGNIN_URL)),
"signout":
self.createAction("Signout", lambda: self.current().logout()),
"close":
self.createAction("Close", self.close, QKeySequence.Close),
"exit":
self.createAction("Quit", self.exit, QKeySequence.Quit)
},
"edit": {
"undo":
self.createAction(
undo.text(), lambda: self.current().page().triggerAction(
QtWebKit.QWebPage.Undo), undo.shortcut()),
"redo":
self.createAction(
redo.text(), lambda: self.current().page().triggerAction(
QtWebKit.QWebPage.Redo), redo.shortcut()),
"cut":
self.createAction(
cut.text(), lambda: self.current().page().triggerAction(
QtWebKit.QWebPage.Cut), cut.shortcut()),
"copy":
self.createAction(
copy.text(), lambda: self.current().page().triggerAction(
QtWebKit.QWebPage.Copy), copy.shortcut()),
"paste":
self.createAction(
paste.text(), lambda: self.current().page().triggerAction(
QtWebKit.QWebPage.Paste), paste.shortcut()),
"back":
self.createAction(
back.text(), lambda: self.current().page().triggerAction(
QtWebKit.QWebPage.Back), back.shortcut()),
"forward":
self.createAction(
forward.text(), lambda: self.current().page()
.triggerAction(QtWebKit.QWebPage.Forward),
forward.shortcut()),
"reload":
self.createAction(
reload.text(), lambda: self.current().page().triggerAction(
QtWebKit.QWebPage.Reload), reload.shortcut()),
},
"view": {
"zoomin":
self.createAction("Zoom In", self.zoomIn, QKeySequence.ZoomIn),
"zoomout":
self.createAction("Zoom Out", self.zoomOut,
QKeySequence.ZoomOut),
"reset":
self.createAction("Reset", self.zoomReset,
QtCore.Qt.CTRL + QtCore.Qt.Key_0),
"fullscreen":
self.createAction("Toggle Full Screen", self.toggleFullScreen,
QtCore.Qt.Key_F11),
"hidemenu":
self.createAction("Toggle Menubar", self.toggleMenuBar,
QtCore.Qt.Key_F12)
},
"help": {
"help":
self.createAction("Help and Feedback",
lambda: self.current().help(),
QKeySequence.HelpContents),
"center":
self.createAction("Slack Help Center",
lambda: self.current().helpCenter()),
"about":
self.createAction("About", lambda: self.current().about())
}
}
menu = self.menuBar()
fileMenu = menu.addMenu("&File")
fileMenu.addAction(self.menus["file"]["preferences"])
fileMenu.addAction(self.menus["file"]["systray"])
fileMenu.addSeparator()
fileMenu.addAction(self.menus["file"]["addTeam"])
fileMenu.addAction(self.menus["file"]["signout"])
fileMenu.addSeparator()
fileMenu.addAction(self.menus["file"]["close"])
fileMenu.addAction(self.menus["file"]["exit"])
editMenu = menu.addMenu("&Edit")
editMenu.addAction(self.menus["edit"]["undo"])
editMenu.addAction(self.menus["edit"]["redo"])
editMenu.addSeparator()
editMenu.addAction(self.menus["edit"]["cut"])
editMenu.addAction(self.menus["edit"]["copy"])
editMenu.addAction(self.menus["edit"]["paste"])
editMenu.addSeparator()
editMenu.addAction(self.menus["edit"]["back"])
editMenu.addAction(self.menus["edit"]["forward"])
editMenu.addAction(self.menus["edit"]["reload"])
viewMenu = menu.addMenu("&View")
viewMenu.addAction(self.menus["view"]["zoomin"])
viewMenu.addAction(self.menus["view"]["zoomout"])
viewMenu.addAction(self.menus["view"]["reset"])
viewMenu.addSeparator()
viewMenu.addAction(self.menus["view"]["fullscreen"])
if Unity is None:
viewMenu.addAction(self.menus["view"]["hidemenu"])
helpMenu = menu.addMenu("&Help")
helpMenu.addAction(self.menus["help"]["help"])
helpMenu.addAction(self.menus["help"]["center"])
helpMenu.addSeparator()
helpMenu.addAction(self.menus["help"]["about"])
self.enableMenus(False)
showSystray = self.settings.value("Systray") == "True"
self.menus["file"]["systray"].setChecked(showSystray)
self.menus["file"]["close"].setEnabled(showSystray)
# Restore menu visibility
visible = self.settings.value("Menu")
if visible is not None and visible == "False":
menu.setVisible(False)
def enableMenus(self, enabled):
self.menus["file"]["preferences"].setEnabled(enabled == True)
self.menus["file"]["addTeam"].setEnabled(enabled == True)
self.menus["file"]["signout"].setEnabled(enabled == True)
self.menus["help"]["help"].setEnabled(enabled == True)
def createAction(self, text, slot, shortcut=None, checkable=False):
action = QtGui.QAction(text, self)
action.triggered.connect(slot)
if shortcut is not None:
action.setShortcut(shortcut)
self.addAction(action)
if checkable:
action.setCheckable(True)
return action
def normalize(self, url):
if url.endswith(".slack.com"):
url += "/"
elif not url.endswith(".slack.com/"):
url = "https://" + url + ".slack.com/"
return url
def current(self):
return self.stackedWidget.currentWidget()
def teams(self, teams):
if len(self.domains) == 0:
self.domains.append(teams[0]['team_url'])
team_list = [t['team_url'] for t in teams]
for t in teams:
for i in range(0, len(self.domains)):
self.domains[i] = self.normalize(self.domains[i])
# When team_icon is missing, the team already exists (Fixes #381, #391)
if 'team_icon' in t:
if self.domains[i] in team_list:
add = next(item for item in teams
if item['team_url'] == self.domains[i])
self.leftPane.addTeam(add['id'], add['team_name'],
add['team_url'],
add['team_icon']['image_44'],
add == teams[0])
# Adding new teams and saving loading positions
if t['team_url'] not in self.domains:
self.leftPane.addTeam(t['id'], t['team_name'],
t['team_url'],
t['team_icon']['image_44'],
t == teams[0])
self.domains.append(t['team_url'])
self.settings.setValue("Domain", self.domains)
if len(teams) > 1:
self.leftPane.show()
def switchTo(self, url):
exists = False
for i in range(0, self.stackedWidget.count()):
if self.stackedWidget.widget(i).url().toString().startswith(url):
self.stackedWidget.setCurrentIndex(i)
self.quicklist(self.current().listChannels())
self.current().setFocus()
self.leftPane.click(i)
exists = True
break
if not exists:
self.addWrapper(url)
def eventFilter(self, obj, event):
if event.type(
) == QtCore.QEvent.ActivationChange and self.isActiveWindow():
self.focusInEvent(event)
if event.type() == QtCore.QEvent.KeyPress:
# Ctrl + <n>
modifiers = QtGui.QApplication.keyboardModifiers()
if modifiers == QtCore.Qt.ControlModifier:
if event.key() == QtCore.Qt.Key_1: self.leftPane.click(0)
elif event.key() == QtCore.Qt.Key_2: self.leftPane.click(1)
elif event.key() == QtCore.Qt.Key_3: self.leftPane.click(2)
elif event.key() == QtCore.Qt.Key_4: self.leftPane.click(3)
elif event.key() == QtCore.Qt.Key_5: self.leftPane.click(4)
elif event.key() == QtCore.Qt.Key_6: self.leftPane.click(5)
elif event.key() == QtCore.Qt.Key_7: self.leftPane.click(6)
elif event.key() == QtCore.Qt.Key_8: self.leftPane.click(7)
elif event.key() == QtCore.Qt.Key_9:
self.leftPane.click(8)
# Ctrl + Tab
elif event.key() == QtCore.Qt.Key_Tab:
self.leftPane.clickNext(1)
# Ctrl + BackTab
if (modifiers & QtCore.Qt.ControlModifier) and (
modifiers & QtCore.Qt.ShiftModifier):
if event.key() == QtCore.Qt.Key_Backtab:
self.leftPane.clickNext(-1)
# Ctrl + Shift + <key>
if (modifiers & QtCore.Qt.ShiftModifier) and (
modifiers & QtCore.Qt.ShiftModifier):
if event.key() == QtCore.Qt.Key_V:
self.current().createSnippet()
return QtGui.QMainWindow.eventFilter(self, obj, event)
def focusInEvent(self, event):
self.launcher.set_property("urgent", False)
self.tray.stopAlert()
# Let's tickle all teams on window focus, but only if tickle was not fired in last 30 minutes
if DBusQtMainLoop is None and not self.tickler.isActive():
self.sendTickle()
self.tickler.start()
def titleChanged(self):
self.setWindowTitle(self.current().title())
def setForceClose(self):
self.forceClose = True
def closeEvent(self, event):
if not self.forceClose and self.settings.value("Systray") == "True":
self.hide()
event.ignore()
else:
self.cookiesjar.save()
self.settings.setValue("geometry", self.saveGeometry())
self.settings.setValue("windowState", self.saveState())
self.forceClose = False
def show(self):
self.setWindowState(self.windowState() & ~QtCore.Qt.WindowMinimized
| QtCore.Qt.WindowActive)
self.activateWindow()
self.setVisible(True)
def exit(self):
self.setForceClose()
self.close()
def quicklist(self, channels):
if Dbusmenu is not None:
if channels is not None:
ql = Dbusmenu.Menuitem.new()
self.launcher.set_property("quicklist", ql)
for c in channels:
if c['is_member']:
item = Dbusmenu.Menuitem.new()
item.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
"#" + c['name'])
item.property_set("id", c['name'])
item.property_set_bool(Dbusmenu.MENUITEM_PROP_VISIBLE,
True)
item.connect(Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED,
self.current().openChannel)
ql.child_append(item)
self.launcher.set_property("quicklist", ql)
def notify(self, title, message, icon):
if self.debug:
print("Notification: title [{}] message [{}] icon [{}]".format(
title, message, icon))
self.notifier.notify(title, message, icon)
self.alert()
def alert(self):
if not self.isActiveWindow():
self.launcher.set_property("urgent", True)
self.tray.alert()
def count(self):
total = 0
unreads = 0
for i in range(0, self.stackedWidget.count()):
widget = self.stackedWidget.widget(i)
highlights = widget.highlights
unreads += widget.unreads
total += highlights
if total > self.messages:
self.alert()
if 0 == total:
self.launcher.set_property("count_visible", False)
self.tray.setCounter(0)
if unreads > 0:
self.setWindowTitle("*{}".format(self.title))
else:
self.setWindowTitle(self.title)
else:
self.tray.setCounter(total)
self.launcher.set_property("count", total)
self.launcher.set_property("count_visible", True)
self.setWindowTitle("[{}]{}".format(str(total), self.title))
self.messages = total
class TagBrowserWidget(QWidget): # {{{
def __init__(self, parent):
QWidget.__init__(self, parent)
self.parent = parent
self._layout = QVBoxLayout()
self.setLayout(self._layout)
self._layout.setContentsMargins(0, 0, 0, 0)
# Set up the find box & button
search_layout = QHBoxLayout()
self._layout.addLayout(search_layout)
self.item_search = HistoryLineEdit(parent)
self.item_search.setMinimumContentsLength(10)
self.item_search.setSizeAdjustPolicy(
self.item_search.AdjustToMinimumContentsLengthWithIcon)
try:
self.item_search.lineEdit().setPlaceholderText(
_('Find item in tag browser'))
except:
pass # Using Qt < 4.7
self.item_search.setToolTip(
_('Search for items. This is a "contains" search; items containing the\n'
'text anywhere in the name will be found. You can limit the search\n'
'to particular categories using syntax similar to search. For example,\n'
'tags:foo will find foo in any tag, but not in authors etc. Entering\n'
'*foo will filter all categories at once, showing only those items\n'
'containing the text "foo"'))
search_layout.addWidget(self.item_search)
# Not sure if the shortcut should be translatable ...
sc = QShortcut(QKeySequence(_('ALT+f')), parent)
sc.activated.connect(self.set_focus_to_find_box)
self.search_button = QToolButton()
self.search_button.setText(_('F&ind'))
self.search_button.setToolTip(_('Find the first/next matching item'))
search_layout.addWidget(self.search_button)
self.expand_button = QToolButton()
self.expand_button.setText('-')
self.expand_button.setToolTip(_('Collapse all categories'))
search_layout.addWidget(self.expand_button)
search_layout.setStretch(0, 10)
search_layout.setStretch(1, 1)
search_layout.setStretch(2, 1)
self.current_find_position = None
self.search_button.clicked.connect(self.find)
self.item_search.initialize('tag_browser_search')
self.item_search.lineEdit().returnPressed.connect(self.do_find)
self.item_search.lineEdit().textEdited.connect(self.find_text_changed)
self.item_search.activated[QString].connect(self.do_find)
self.item_search.completer().setCaseSensitivity(Qt.CaseSensitive)
parent.tags_view = TagsView(parent)
self.tags_view = parent.tags_view
self.expand_button.clicked.connect(self.tags_view.collapseAll)
self._layout.addWidget(parent.tags_view)
# Now the floating 'not found' box
l = QLabel(self.tags_view)
self.not_found_label = l
l.setFrameStyle(QFrame.StyledPanel)
l.setAutoFillBackground(True)
l.setText(
'<p><b>' +
_('No More Matches.</b><p> Click Find again to go to first match'))
l.setAlignment(Qt.AlignVCenter)
l.setWordWrap(True)
l.resize(l.sizeHint())
l.move(10, 20)
l.setVisible(False)
self.not_found_label_timer = QTimer()
self.not_found_label_timer.setSingleShot(True)
self.not_found_label_timer.timeout.connect(
self.not_found_label_timer_event, type=Qt.QueuedConnection)
parent.alter_tb = l = QPushButton(parent)
l.setText(_('Alter Tag Browser'))
l.setIcon(QIcon(I('tags.png')))
l.m = QMenu()
l.setMenu(l.m)
self._layout.addWidget(l)
sb = l.m.addAction(_('Sort by'))
sb.m = l.sort_menu = QMenu(l.m)
sb.setMenu(sb.m)
sb.bg = QActionGroup(sb)
# Must be in the same order as db2.CATEGORY_SORTS
for i, x in enumerate((_('Sort by name'), _('Sort by popularity'),
_('Sort by average rating'))):
a = sb.m.addAction(x)
sb.bg.addAction(a)
a.setCheckable(True)
if i == 0:
a.setChecked(True)
sb.setToolTip(_('Set the sort order for entries in the Tag Browser'))
sb.setStatusTip(sb.toolTip())
ma = l.m.addAction(_('Search type when selecting multiple items'))
ma.m = l.match_menu = QMenu(l.m)
ma.setMenu(ma.m)
ma.ag = QActionGroup(ma)
# Must be in the same order as db2.MATCH_TYPE
for i, x in enumerate(
(_('Match any of the items'), _('Match all of the items'))):
a = ma.m.addAction(x)
ma.ag.addAction(a)
a.setCheckable(True)
if i == 0:
a.setChecked(True)
ma.setToolTip(
_('When selecting multiple entries in the Tag Browser '
'match any or all of them'))
ma.setStatusTip(ma.toolTip())
mt = l.m.addAction(_('Manage authors, tags, etc'))
mt.setToolTip(
_('All of these category_managers are available by right-clicking '
'on items in the tag browser above'))
mt.m = l.manage_menu = QMenu(l.m)
mt.setMenu(mt.m)
# self.leak_test_timer = QTimer(self)
# self.leak_test_timer.timeout.connect(self.test_for_leak)
# self.leak_test_timer.start(5000)
def set_pane_is_visible(self, to_what):
self.tags_view.set_pane_is_visible(to_what)
def find_text_changed(self, str):
self.current_find_position = None
def set_focus_to_find_box(self):
self.item_search.setFocus()
self.item_search.lineEdit().selectAll()
def do_find(self, str=None):
self.current_find_position = None
self.find()
def find(self):
model = self.tags_view.model()
model.clear_boxed()
txt = unicode(self.item_search.currentText()).strip()
if txt.startswith('*'):
model.set_categories_filter(txt[1:])
self.tags_view.recount()
self.current_find_position = None
return
if model.get_categories_filter():
model.set_categories_filter(None)
self.tags_view.recount()
self.current_find_position = None
if not txt:
return
self.item_search.lineEdit().blockSignals(True)
self.search_button.setFocus(True)
self.item_search.lineEdit().blockSignals(False)
key = None
colon = txt.rfind(':') if len(txt) > 2 else 0
if colon > 0:
key = self.parent.library_view.model().db.\
field_metadata.search_term_to_field_key(txt[:colon])
txt = txt[colon + 1:]
self.current_find_position = \
model.find_item_node(key, txt, self.current_find_position)
if self.current_find_position:
self.tags_view.show_item_at_path(self.current_find_position,
box=True)
elif self.item_search.text():
self.not_found_label.setVisible(True)
if self.tags_view.verticalScrollBar().isVisible():
sbw = self.tags_view.verticalScrollBar().width()
else:
sbw = 0
width = self.width() - 8 - sbw
height = self.not_found_label.heightForWidth(width) + 20
self.not_found_label.resize(width, height)
self.not_found_label.move(4, 10)
self.not_found_label_timer.start(2000)
def not_found_label_timer_event(self):
self.not_found_label.setVisible(False)
class EbookViewer(MainWindow, Ui_EbookViewer):
STATE_VERSION = 1
def __init__(self, pathtoebook=None, debug_javascript=False, open_at=None):
MainWindow.__init__(self, None)
self.setupUi(self)
self.view.initialize_view(debug_javascript)
self.view.magnification_changed.connect(self.magnification_changed)
self.show_toc_on_open = False
self.current_book_has_toc = False
self.base_window_title = unicode(self.windowTitle())
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.existing_bookmarks = []
self.selected_text = None
self.read_settings()
self.dictionary_box.hide()
self.close_dictionary_view.clicked.connect(
lambda x: self.dictionary_box.hide())
self.history = History(self.action_back, self.action_forward)
self.metadata = Metadata(self)
self.pos = DoubleSpinBox()
self.pos.setDecimals(1)
self.pos.setSuffix('/' + _('Unknown') + ' ')
self.pos.setMinimum(1.)
self.pos.setMinimumWidth(150)
self.tool_bar2.insertWidget(self.action_find_next, self.pos)
self.reference = Reference()
self.tool_bar2.insertSeparator(self.action_find_next)
self.tool_bar2.insertWidget(self.action_find_next, self.reference)
self.tool_bar2.insertSeparator(self.action_find_next)
self.setFocusPolicy(Qt.StrongFocus)
self.search = SearchBox2(self)
self.search.setMinimumContentsLength(20)
self.search.initialize('viewer_search_history')
self.search.setToolTip(_('Search for text in book'))
self.search.setMinimumWidth(200)
self.tool_bar2.insertWidget(self.action_find_next, self.search)
self.view.set_manager(self)
self.pi = ProgressIndicator(self)
self.toc.setVisible(False)
self.action_quit = QAction(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
qs = [Qt.CTRL + Qt.Key_Q]
if isosx:
qs += [Qt.CTRL + Qt.Key_W]
self.action_quit.setShortcuts(qs)
self.action_quit.triggered.connect(self.quit)
self.action_focus_search = QAction(self)
self.addAction(self.action_focus_search)
self.action_focus_search.setShortcuts(
[Qt.Key_Slash, QKeySequence(QKeySequence.Find)])
self.action_focus_search.triggered.connect(
lambda x: self.search.setFocus(Qt.OtherFocusReason))
self.action_copy.setDisabled(True)
self.action_metadata.setCheckable(True)
self.action_metadata.setShortcut(Qt.CTRL + Qt.Key_I)
self.action_table_of_contents.setCheckable(True)
self.toc.setMinimumWidth(80)
self.action_reference_mode.setCheckable(True)
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_full_screen.setShortcuts(
[Qt.Key_F11, Qt.CTRL + Qt.SHIFT + Qt.Key_F])
self.action_full_screen.setToolTip(
_('Toggle full screen (%s)') % _(' or ').join([
unicode(x.toString(x.NativeText))
for x in self.action_full_screen.shortcuts()
]))
self.action_back.triggered[bool].connect(self.back)
self.action_forward.triggered[bool].connect(self.forward)
self.action_bookmark.triggered[bool].connect(self.bookmark)
self.action_preferences.triggered.connect(
lambda: self.view.config(self))
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.reference.goto.connect(self.goto)
self.bookmarks_menu = QMenu()
self.action_bookmark.setMenu(self.bookmarks_menu)
self.set_bookmarks([])
if pathtoebook is not None:
f = functools.partial(self.load_ebook,
pathtoebook,
open_at=open_at)
QTimer.singleShot(50, f)
self.view.setMinimumSize(100, 100)
self.toc.setCursor(Qt.PointingHandCursor)
self.tool_bar.setContextMenuPolicy(Qt.PreventContextMenu)
self.tool_bar2.setContextMenuPolicy(Qt.PreventContextMenu)
self.tool_bar.widgetForAction(self.action_bookmark).setPopupMode(
QToolButton.MenuButtonPopup)
self.action_full_screen.setCheckable(True)
self.full_screen_label = QLabel(
'''
<center>
<h1>%s</h1>
<h3>%s</h3>
<h3>%s</h3>
</center>
''' %
(_('Full screen mode'), _('Right click to show controls'),
_('Press Esc to quit')), self)
self.full_screen_label.setVisible(False)
self.full_screen_label.setStyleSheet('''
QLabel {
text-align: center;
background-color: white;
color: black;
border-width: 1px;
border-style: solid;
border-radius: 20px;
}
''')
self.window_mode_changed = None
self.toggle_toolbar_action = QAction(_('Show/hide controls'), self)
self.toggle_toolbar_action.triggered.connect(self.toggle_toolbars)
self.addAction(self.toggle_toolbar_action)
self.full_screen_label_anim = QPropertyAnimation(
self.full_screen_label, 'size')
self.clock_label = QLabel('99:99', self)
self.clock_label.setVisible(False)
self.clock_label.setFocusPolicy(Qt.NoFocus)
self.clock_label_style = '''
QLabel {
text-align: right;
border-width: 1px;
border-style: solid;
border-radius: 8px;
background-color: %s;
color: %s;
font-family: monospace;
font-size: larger;
padding: 5px;
}'''
self.clock_timer = QTimer(self)
self.clock_timer.timeout.connect(self.update_clock)
self.esc_full_screen_action = a = QAction(self)
self.addAction(a)
a.setShortcut(Qt.Key_Escape)
a.setEnabled(False)
a.triggered.connect(self.action_full_screen.trigger)
self.print_menu = QMenu()
self.print_menu.addAction(QIcon(I('print-preview.png')),
_('Print Preview'))
self.action_print.setMenu(self.print_menu)
self.tool_bar.widgetForAction(self.action_print).setPopupMode(
QToolButton.MenuButtonPopup)
self.action_print.triggered.connect(self.print_book)
self.print_menu.actions()[0].triggered.connect(self.print_preview)
ca = self.view.copy_action
ca.setShortcut(QKeySequence.Copy)
self.addAction(ca)
self.open_history_menu = QMenu()
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.action_open_ebook.setMenu(self.open_history_menu)
self.open_history_menu.triggered[QAction].connect(self.open_recent)
w = self.tool_bar.widgetForAction(self.action_open_ebook)
w.setPopupMode(QToolButton.MenuButtonPopup)
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)
self.restore_state()
def set_toc_visible(self, yes):
self.toc.setVisible(yes)
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():
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['viewer_toolbar_state'] = state
vprefs.set('viewer_window_geometry', bytearray(self.saveGeometry()))
if self.current_book_has_toc:
vprefs.set('viewer_toc_isvisible', bool(self.toc.isVisible()))
if self.toc.isVisible():
vprefs.set('viewer_splitter_state',
bytearray(self.splitter.saveState()))
vprefs['multiplier'] = self.view.multiplier
def restore_state(self):
state = vprefs.get('viewer_toolbar_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)
def lookup(self, word):
self.dictionary_view.setHtml('<html><body><p>'+ \
_('Connecting to dict.org to lookup: <b>%s</b>…')%word + \
'</p></body></html>')
self.dictionary_box.show()
self._lookup = Lookup(word, parent=self)
self._lookup.finished.connect(self.looked_up)
self._lookup.start()
def looked_up(self, *args):
html = self._lookup.html_result
self._lookup = None
self.dictionary_view.setHtml(html)
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, x):
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._original_frame_margins = (
self.centralwidget.layout().contentsMargins(),
self.frame.layout().contentsMargins())
self.frame.layout().setContentsMargins(0, 0, 0, 0)
self.centralwidget.layout().setContentsMargins(0, 0, 0, 0)
super(EbookViewer, self).showFullScreen()
def show_full_screen_label(self):
f = self.full_screen_label
self.esc_full_screen_action.setEnabled(True)
f.setVisible(True)
height = 200
width = int(0.7 * self.view.width())
f.resize(width, height)
f.move((self.view.width() - width) // 2,
(self.view.height() - height) // 2)
a = self.full_screen_label_anim
a.setDuration(500)
a.setStartValue(QSize(width, 0))
a.setEndValue(QSize(width, height))
a.start()
QTimer.singleShot(2750, self.full_screen_label.hide)
self.view.document.switch_to_fullscreen_mode()
if self.view.document.fullscreen_clock:
self.show_clock()
def show_clock(self):
self.clock_label.setVisible(True)
self.clock_label.setText('99:99 AA')
self.clock_timer.start(1000)
self.clock_label.setStyleSheet(self.clock_label_style %
tuple(self.view.document.colors()))
self.clock_label.resize(self.clock_label.sizeHint())
sw = QApplication.desktop().screenGeometry(self.view)
self.clock_label.move(
sw.width() - self.vertical_scrollbar.width() - 15 -
self.clock_label.width(),
sw.height() - self.clock_label.height() - 10)
self.update_clock()
def update_clock(self):
self.clock_label.setText(QTime.currentTime().toString('h:mm a'))
def showNormal(self):
self.view.document.page_position.save()
self.clock_label.setVisible(False)
self.clock_timer.stop()
self.window_mode_changed = 'normal'
self.esc_full_screen_action.setEnabled(False)
self.tool_bar.setVisible(True)
self.tool_bar2.setVisible(True)
self.full_screen_label.setVisible(False)
if hasattr(self, '_original_frame_margins'):
om = self._original_frame_margins
self.centralwidget.layout().setContentsMargins(om[0])
self.frame.layout().setContentsMargins(om[1])
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)
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.'),
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()
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()
self.action_font_size_larger.setEnabled(self.view.multiplier < 3)
self.action_font_size_smaller.setEnabled(self.view.multiplier > 0.2)
def font_size_smaller(self):
self.view.shrink_fonts()
self.action_font_size_larger.setEnabled(self.view.multiplier < 3)
self.action_font_size_smaller.setEnabled(self.view.multiplier > 0.2)
def magnification_changed(self, val):
tt = _('Make font size %(which)s\nCurrent magnification: %(mag).1f')
self.action_font_size_larger.setToolTip(
tt % dict(which=_('larger'), mag=val))
self.action_font_size_smaller.setToolTip(
tt % dict(which=_('smaller'), mag=val))
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, frac):
self.history.add(self.pos.value())
def link_clicked(self, url):
path = os.path.abspath(unicode(url.toLocalFile()))
frag = None
if path in self.iterator.spine:
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('#')
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
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):
old, curr = event.size(), event.oldSize()
if not self.window_mode_changed and old.width() == curr.width():
# No relayout changes, so page position does not need to be saved
# This is needed as Qt generates a viewport resized event that
# changes only the height after a file has been loaded. This can
# cause the last read position bookmark to become slightly
# inaccurate
return
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()
self.view.document.after_resize()
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 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)
def set_bookmarks(self, bookmarks):
self.bookmarks_menu.clear()
self.bookmarks_menu.addAction(_("Manage Bookmarks"),
self.manage_bookmarks)
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 manage_bookmarks(self):
bmm = BookmarkManager(self, self.iterator.bookmarks)
if bmm.exec_() != BookmarkManager.Accepted:
return
bookmarks = bmm.get_bookmarks()
if bookmarks != self.iterator.bookmarks:
self.iterator.set_bookmarks(bookmarks)
self.iterator.save_bookmarks()
self.set_bookmarks(bookmarks)
def save_current_position(self):
if not self.get_remember_current_page_opt():
return
if hasattr(self, 'current_index'):
try:
bm = self.view.bookmark()
bm['spine'] = self.current_index
bm['title'] = 'calibre_current_page_bookmark'
self.iterator.add_bookmark(bm)
except:
traceback.print_exc()
def load_ebook(self, pathtoebook, open_at=None):
if self.iterator is not None:
self.save_current_position()
self.iterator.__exit__()
self.iterator = EbookIterator(pathtoebook)
self.open_progress_indicator(_('Loading ebook...'))
worker = Worker(target=self.iterator.__enter__)
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),
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(self.base_window_title + ' - ' + title +
' [%s]' % self.iterator.book_format)
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 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):
MainWindow.keyPressEvent(self, event)
if not event.isAccepted():
if not self.view.handle_key_press(event):
event.ignore()
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()
self.splitter.setSizes([1, 300])
if c.remember_window_size:
wg = vprefs.get('viewer_window_geometry', None)
if wg is not None:
self.restoreGeometry(wg)
ss = vprefs.get('viewer_splitter_state', None)
if ss is not None:
self.splitter.restoreState(ss)
self.show_toc_on_open = vprefs.get('viewer_toc_isvisible', False)
av = available_height() - 30
if self.height() > av:
self.resize(self.width(), av)
class Widget(QWidget, ScreenWidget):
name = "timeSetup"
def __init__(self):
QWidget.__init__(self)
self.ui = Ui_DateTimeWidget()
self.ui.setupUi(self)
self.timer = QTimer(self)
self.from_time_updater = True
self.is_date_changed = False
self.current_zone = ""
self.tz_dict = {}
self.continents = []
self.countries = []
for country, data in yali.localedata.locales.items():
if country == ctx.consts.lang:
if data.has_key("timezone"):
ctx.installData.timezone = data["timezone"]
# Append continents and countries the time zone dictionary
self.createTZDictionary()
# Sort continent list
self.sortContinents()
# Append sorted continents to combobox
self.loadContinents()
# Load current continents country list
self.getCountries(self.current_zone["continent"])
# Highlight the current zone
self.index = self.ui.continentList.findText(self.current_zone["continent"])
self.ui.continentList.setCurrentIndex(self.index)
self.index = self.ui.countryList.findText(self.current_zone["country"])
self.ui.countryList.setCurrentIndex(self.index)
# Initialize widget signal and slots
self.__initSignals__()
self.ui.calendarWidget.setDate(QDate.currentDate())
self.pthread = None
self.pds_messagebox = PMessageBox(self)
self.pds_messagebox.enableOverlay()
self.timer.start(1000)
def __initSignals__(self):
self.connect(self.ui.timeEdit, SIGNAL("timeChanged(QTime)"), self.timerStop)
self.connect(self.ui.calendarWidget, SIGNAL("selectionChanged()"), self.dateChanged)
self.connect(self.timer, SIGNAL("timeout()"), self.updateClock)
self.connect(self.ui.continentList, SIGNAL("activated(QString)"), self.getCountries)
def createTZDictionary(self):
tz = TimeZoneList()
zones = [ x.timeZone for x in tz.getEntries() ]
zones.sort()
for zone in zones:
split = zone.split("/")
# Human readable continent names
continent_pretty_name = split[0].replace("_", " ")
continent_pretty_name = continent_pretty_name
# Some country names can be like Argentina/Catamarca so this fixes the splitting problem
# caused by zone.split("/")
#
# Remove continent info and take the rest as the country name
split.pop(0)
country_pretty_name = " / ".join(split)
# Human readable country names
country_pretty_name = country_pretty_name.replace("_", " ")
# Get current zone
if zone == ctx.installData.timezone:
self.current_zone = { "continent":continent_pretty_name, "country":country_pretty_name}
# Append to dictionary
if self.tz_dict.has_key(continent_pretty_name):
self.tz_dict[continent_pretty_name].append([country_pretty_name, zone])
else:
self.tz_dict[continent_pretty_name] = [[country_pretty_name, zone]]
def sortContinents(self):
for continent in self.tz_dict.keys():
self.continents.append(continent)
self.continents.sort()
def loadContinents(self):
for continent in self.continents:
self.ui.continentList.addItem(continent)
def getCountries(self, continent):
# Countries of the selected continent
countries = self.tz_dict[str(continent)]
self.ui.countryList.clear()
for country, zone in countries:
self.ui.countryList.addItem(country, zone)
self.countries.append(country)
def dateChanged(self):
self.is_date_changed = True
def timerStop(self):
if self.from_time_updater:
return
# Human action detected; stop the timer.
self.timer.stop()
def updateClock(self):
# What time is it ?
cur = QTime.currentTime()
self.from_time_updater = True
self.ui.timeEdit.setTime(cur)
self.from_time_updater = False
def shown(self):
self.timer.start(1000)
if ctx.flags.install_type == ctx.STEP_BASE:
self.pthread = PThread(self, self.startInit, self.dummy)
def dummy(self):
pass
def setTime(self):
ctx.interface.informationWindow.update(_("Adjusting time settings"))
date = self.ui.calendarWidget.date()
time = self.ui.timeEdit.time()
args = "%02d%02d%02d%02d%04d.%02d" % (date.month(), date.day(),
time.hour(), time.minute(),
date.year(), time.second())
# Set current date and time
ctx.logger.debug("Date/Time setting to %s" % args)
yali.util.run_batch("date", [args])
# Sync date time with hardware
ctx.logger.debug("YALI's time is syncing with the system.")
yali.util.run_batch("hwclock", ["--systohc"])
ctx.interface.informationWindow.hide()
def execute(self):
if not self.timer.isActive() or self.is_date_changed:
QTimer.singleShot(500, self.setTime)
self.timer.stop()
index = self.ui.countryList.currentIndex()
ctx.installData.timezone = self.ui.countryList.itemData(index).toString()
ctx.logger.debug("Time zone selected as %s " % ctx.installData.timezone)
if ctx.flags.install_type == ctx.STEP_BASE:
#FIXME:Refactor hacky code
ctx.installData.rootPassword = ctx.consts.default_password
ctx.installData.hostName = yali.util.product_release()
if ctx.storageInitialized:
disks = filter(lambda d: not d.format.hidden, ctx.storage.disks)
if len(disks) == 1:
ctx.storage.clearPartDisks = [disks[0].name]
ctx.mainScreen.step_increment = 2
else:
ctx.mainScreen.step_increment = 1
return True
else:
self.pds_messagebox.setMessage(_("Storage Devices initialising..."))
self.pds_messagebox.animate(start=MIDCENTER, stop=MIDCENTER)
ctx.mainScreen.step_increment = 0
self.pthread.start()
QTimer.singleShot(2, self.startStorageInitialize)
return False
return True
def startInit(self):
self.pds_messagebox.animate(start=MIDCENTER, stop=MIDCENTER)
def startStorageInitialize(self):
ctx.storageInitialized = yali.storage.initialize(ctx.storage, ctx.interface)
self.initFinished()
def initFinished(self):
self.pds_messagebox.animate(start=CURRENT, stop=CURRENT, direction=OUT)
disks = filter(lambda d: not d.format.hidden, ctx.storage.disks)
if ctx.storageInitialized:
if len(disks) == 1:
ctx.storage.clearPartDisks = [disks[0].name]
ctx.mainScreen.step_increment = 2
else:
ctx.mainScreen.step_increment = 1
ctx.mainScreen.slotNext(dry_run=True)
else:
ctx.mainScreen.enableBack()
def start(self):
self.restorer.start()
QTimer.singleShot(10, self.update)
def initialize(self, library_path, db, listener, actions, show_gui=True):
opts = self.opts
self.preferences_action, self.quit_action = actions
self.library_path = library_path
self.content_server = None
self.spare_servers = []
self.must_restart_before_config = False
self.listener = Listener(listener)
self.check_messages_timer = QTimer()
self.connect(self.check_messages_timer, SIGNAL('timeout()'),
self.another_instance_wants_to_talk)
self.check_messages_timer.start(1000)
for ac in self.iactions.values():
ac.do_genesis()
self.donate_action = QAction(QIcon(I('donate.png')),
_('&Donate to support calibre'), self)
for st in self.istores.values():
st.do_genesis()
MainWindowMixin.__init__(self, db)
# Jobs Button {{{
self.job_manager = JobManager()
self.jobs_dialog = JobsDialog(self, self.job_manager)
self.jobs_button = JobsButton(horizontal=True, parent=self)
self.jobs_button.initialize(self.jobs_dialog, self.job_manager)
# }}}
LayoutMixin.__init__(self)
EmailMixin.__init__(self)
EbookDownloadMixin.__init__(self)
DeviceMixin.__init__(self)
self.progress_indicator = ProgressIndicator(self)
self.progress_indicator.pos = (0, 20)
self.verbose = opts.verbose
self.get_metadata = GetMetadata()
self.upload_memory = {}
self.metadata_dialogs = []
self.default_thumbnail = None
self.tb_wrapper = textwrap.TextWrapper(width=40)
self.viewers = collections.deque()
self.system_tray_icon = SystemTrayIcon(QIcon(I('lt.png')), self)
self.system_tray_icon.setToolTip('calibre')
self.system_tray_icon.tooltip_requested.connect(
self.job_manager.show_tooltip)
if not config['systray_icon']:
self.system_tray_icon.hide()
else:
self.system_tray_icon.show()
self.system_tray_menu = QMenu(self)
self.restore_action = self.system_tray_menu.addAction(
QIcon(I('page.png')), _('&Restore'))
self.system_tray_menu.addAction(self.donate_action)
self.donate_button.setDefaultAction(self.donate_action)
self.donate_button.setStatusTip(self.donate_button.toolTip())
self.eject_action = self.system_tray_menu.addAction(
QIcon(I('eject.png')), _('&Eject connected device'))
self.eject_action.setEnabled(False)
self.addAction(self.quit_action)
self.system_tray_menu.addAction(self.quit_action)
self.keyboard.register_shortcut('quit calibre',
_('Quit calibre'),
default_keys=('Ctrl+Q', ),
action=self.quit_action)
self.system_tray_icon.setContextMenu(self.system_tray_menu)
self.connect(self.quit_action, SIGNAL('triggered(bool)'), self.quit)
self.connect(self.donate_action, SIGNAL('triggered(bool)'),
self.donate)
self.connect(self.restore_action, SIGNAL('triggered()'),
self.show_windows)
self.system_tray_icon.activated.connect(
self.system_tray_icon_activated)
self.esc_action = QAction(self)
self.addAction(self.esc_action)
self.keyboard.register_shortcut('clear current search',
_('Clear the current search'),
default_keys=('Esc', ),
action=self.esc_action)
self.esc_action.triggered.connect(self.esc)
self.shift_esc_action = QAction(self)
self.addAction(self.shift_esc_action)
self.keyboard.register_shortcut('focus book list',
_('Focus the book list'),
default_keys=('Shift+Esc', ),
action=self.shift_esc_action)
self.shift_esc_action.triggered.connect(self.shift_esc)
self.ctrl_esc_action = QAction(self)
self.addAction(self.ctrl_esc_action)
self.keyboard.register_shortcut('clear virtual library',
_('Clear the virtual library'),
default_keys=('Ctrl+Esc', ),
action=self.ctrl_esc_action)
self.ctrl_esc_action.triggered.connect(self.ctrl_esc)
self.alt_esc_action = QAction(self)
self.addAction(self.alt_esc_action)
self.keyboard.register_shortcut('clear additional restriction',
_('Clear the additional restriction'),
default_keys=('Alt+Esc', ),
action=self.alt_esc_action)
self.alt_esc_action.triggered.connect(
self.clear_additional_restriction)
####################### Start spare job server ########################
QTimer.singleShot(1000, self.add_spare_server)
####################### Location Manager ########################
self.location_manager.location_selected.connect(self.location_selected)
self.location_manager.unmount_device.connect(
self.device_manager.umount_device)
self.location_manager.configure_device.connect(
self.configure_connected_device)
self.location_manager.update_device_metadata.connect(
self.update_metadata_on_device)
self.eject_action.triggered.connect(self.device_manager.umount_device)
#################### Update notification ###################
UpdateMixin.__init__(self, opts)
####################### Search boxes ########################
SearchRestrictionMixin.__init__(self)
SavedSearchBoxMixin.__init__(self)
####################### Library view ########################
LibraryViewMixin.__init__(self, db)
SearchBoxMixin.__init__(self) # Requires current_db
if show_gui:
self.show()
if self.system_tray_icon.isVisible() and opts.start_in_tray:
self.hide_windows()
self.library_view.model().count_changed_signal.connect(
self.iactions['Choose Library'].count_changed)
if not gprefs.get('quick_start_guide_added', False):
from calibre.ebooks.metadata.meta import get_metadata
mi = get_metadata(open(P('quick_start.epub'), 'rb'), 'epub')
self.library_view.model().add_books([P('quick_start.epub')],
['epub'], [mi])
gprefs['quick_start_guide_added'] = True
self.library_view.model().books_added(1)
if hasattr(self, 'db_images'):
self.db_images.reset()
if self.library_view.model().rowCount(None) < 3:
self.library_view.resizeColumnsToContents()
for view in ('library', 'memory', 'card_a', 'card_b'):
v = getattr(self, '%s_view' % view)
v.selectionModel().selectionChanged.connect(self.update_status_bar)
v.model().count_changed_signal.connect(self.update_status_bar)
self.library_view.model().count_changed()
self.bars_manager.database_changed(self.library_view.model().db)
self.library_view.model().database_changed.connect(
self.bars_manager.database_changed, type=Qt.QueuedConnection)
########################### Tags Browser ##############################
TagBrowserMixin.__init__(self, db)
######################### Search Restriction ##########################
if db.prefs['virtual_lib_on_startup']:
self.apply_virtual_library(db.prefs['virtual_lib_on_startup'])
self.rebuild_vl_tabs()
########################### Cover Flow ################################
CoverFlowMixin.__init__(self)
self._calculated_available_height = min(max_available_height() - 15,
self.height())
self.resize(self.width(), self._calculated_available_height)
self.build_context_menus()
for ac in self.iactions.values():
try:
ac.gui_layout_complete()
except:
import traceback
traceback.print_exc()
if ac.plugin_path is None:
raise
if config['autolaunch_server']:
self.start_content_server()
self.keyboard_interrupt.connect(self.quit, type=Qt.QueuedConnection)
self.read_settings()
self.finalize_layout()
if self.bars_manager.showing_donate:
self.donate_button.start_animation()
self.set_window_title()
for ac in self.iactions.values():
try:
ac.initialization_complete()
except:
import traceback
traceback.print_exc()
if ac.plugin_path is None:
raise
self.device_manager.set_current_library_uuid(db.library_id)
self.keyboard.finalize()
self.auto_adder = AutoAdder(gprefs['auto_add_path'], self)
self.save_layout_state()
# Collect cycles now
gc.collect()
if show_gui and self.gui_debug is not None:
info_dialog(
self,
_('Debug mode'),
'<p>' +
_('You have started calibre in debug mode. After you '
'quit calibre, the debug log will be available in '
'the file: %s<p>The '
'log will be displayed automatically.') % self.gui_debug,
show=True)
self.iactions['Connect Share'].check_smartdevice_menus()
QTimer.singleShot(1, self.start_smartdevice)
def dump(self, items, out_stream, pdf_metadata):
opts = self.opts
page_size = get_page_size(self.opts)
xdpi, ydpi = self.view.logicalDpiX(), self.view.logicalDpiY()
# We cannot set the side margins in the webview as there is no right
# margin for the last page (the margins are implemented with
# -webkit-column-gap)
ml, mr = opts.margin_left, opts.margin_right
self.doc = PdfDevice(out_stream,
page_size=page_size,
left_margin=ml,
top_margin=0,
right_margin=mr,
bottom_margin=0,
xdpi=xdpi,
ydpi=ydpi,
errors=self.log.error,
debug=self.log.debug,
compress=not opts.uncompressed_pdf,
mark_links=opts.pdf_mark_links)
self.footer = opts.pdf_footer_template
if self.footer:
self.footer = self.footer.strip()
if not self.footer and opts.pdf_page_numbers:
self.footer = '<p style="text-align:center; text-indent: 0">_PAGENUM_</p>'
self.header = opts.pdf_header_template
if self.header:
self.header = self.header.strip()
min_margin = 36
if self.footer and opts.margin_bottom < min_margin:
self.log.warn(
'Bottom margin is too small for footer, increasing it.')
opts.margin_bottom = min_margin
if self.header and opts.margin_top < min_margin:
self.log.warn('Top margin is too small for header, increasing it.')
opts.margin_top = min_margin
self.page.setViewportSize(QSize(self.doc.width(), self.doc.height()))
self.render_queue = items
self.total_items = len(items)
mt, mb = map(self.doc.to_px, (opts.margin_top, opts.margin_bottom))
self.margin_top, self.margin_bottom = map(lambda x: int(floor(x)),
(mt, mb))
self.painter = QPainter(self.doc)
self.doc.set_metadata(title=pdf_metadata.title,
author=pdf_metadata.author,
tags=pdf_metadata.tags)
self.doc_title = pdf_metadata.title
self.doc_author = pdf_metadata.author
self.painter.save()
try:
if self.cover_data is not None:
p = QPixmap()
try:
p.loadFromData(self.cover_data)
except TypeError:
self.log.warn(
'This ebook does not have a raster cover, cannot generate cover for PDF'
'. Cover type: %s' % type(self.cover_data))
if not p.isNull():
self.doc.init_page()
draw_image_page(QRect(*self.doc.full_page_rect),
self.painter,
p,
preserve_aspect_ratio=self.opts.
preserve_cover_aspect_ratio)
self.doc.end_page()
finally:
self.painter.restore()
QTimer.singleShot(0, self.render_book)
if self.loop.exec_() == 1:
raise Exception('PDF Output failed, see log for details')
if self.toc is not None and len(self.toc) > 0:
self.doc.add_outline(self.toc)
self.painter.end()
if self.doc.errors_occurred:
raise Exception('PDF Output failed, see log for details')
QPushButton, QTimer, QIcon)
app = Application([], force_calibre_style=True)
d = QDialog()
d.l = l = QGridLayout()
d.setLayout(l)
lw = QListWidget()
lw.addItem('Some text guy')
l.addWidget(lw, 0, 0, 2, 1)
bb = QDialogButtonBox()
bb.setStandardButtons(bb.Close)
bb.accepted.connect(d.accept)
bb.rejected.connect(d.reject)
b = bb.addButton('Action', bb.ActionRole)
b.setIcon(QIcon(I('wizard.png')))
l.addWidget(bb, 2, 0, 1, 2)
bb.button(bb.Close).setDefault(True)
b = QPushButton('Normal')
l.addWidget(b, 0, 1, 1, 1)
def print_button_sizes():
for b in d.findChildren(QPushButton):
print(unicode(b.text()), b.height(), b.iconSize())
QTimer.singleShot(5, print_button_sizes)
d.exec_()
def setEditorData(self, editor, index):
name = unicode(index.data(NAME_ROLE).toString())
# We do this because Qt calls selectAll() unconditionally on the
# editor, and we want only a part of the file name to be selected
QTimer.singleShot(0, partial(self.set_editor_data, name, editor))
class GridView(QListView):
update_item = pyqtSignal(object)
files_dropped = pyqtSignal(object)
def __init__(self, parent):
QListView.__init__(self, parent)
setup_dnd_interface(self)
self.setUniformItemSizes(True)
self.setWrapping(True)
self.setFlow(self.LeftToRight)
# We cannot set layout mode to batched, because that breaks
# restore_vpos()
# self.setLayoutMode(self.Batched)
self.setResizeMode(self.Adjust)
self.setSelectionMode(self.ExtendedSelection)
self.setVerticalScrollMode(self.ScrollPerPixel)
self.delegate = CoverDelegate(self)
self.delegate.animation.valueChanged.connect(
self.animation_value_changed)
self.delegate.animation.finished.connect(self.animation_done)
self.setItemDelegate(self.delegate)
self.setSpacing(self.delegate.spacing)
self.padding_left = 0
self.set_color()
self.ignore_render_requests = Event()
self.thumbnail_cache = ThumbnailCache(
max_size=gprefs['cover_grid_disk_cache_size'],
thumbnail_size=(self.delegate.cover_size.width(),
self.delegate.cover_size.height()))
self.render_thread = None
self.update_item.connect(self.re_render, type=Qt.QueuedConnection)
self.doubleClicked.connect(self.double_clicked)
self.setCursor(Qt.PointingHandCursor)
self.gui = parent
self.context_menu = None
self.update_timer = QTimer(self)
self.update_timer.setInterval(200)
self.update_timer.timeout.connect(self.update_viewport)
self.update_timer.setSingleShot(True)
@property
def first_visible_row(self):
geom = self.viewport().geometry()
for y in xrange(geom.top(), (self.spacing() * 2) + geom.top(), 5):
for x in xrange(geom.left(), (self.spacing() * 2) + geom.left(),
5):
ans = self.indexAt(QPoint(x, y)).row()
if ans > -1:
return ans
@property
def last_visible_row(self):
geom = self.viewport().geometry()
for y in xrange(geom.bottom(), geom.bottom() - 2 * self.spacing(), -5):
for x in xrange(geom.left(), (self.spacing() * 2) + geom.left(),
5):
ans = self.indexAt(QPoint(x, y)).row()
if ans > -1:
item_width = self.delegate.item_size.width(
) + 2 * self.spacing()
return ans + (geom.width() // item_width)
def update_viewport(self):
self.ignore_render_requests.clear()
self.update_timer.stop()
m = self.model()
for r in xrange(self.first_visible_row or 0, self.last_visible_row
or (m.count() - 1)):
self.update(m.index(r, 0))
def double_clicked(self, index):
d = self.delegate
if d.animating is None and not config['disable_animations']:
d.animating = index
d.animation.start()
self.gui.iactions['View'].view_triggered(index)
def animation_value_changed(self, value):
if self.delegate.animating is not None:
self.update(self.delegate.animating)
def animation_done(self):
if self.delegate.animating is not None:
idx = self.delegate.animating
self.delegate.animating = None
self.update(idx)
def set_color(self):
r, g, b = gprefs['cover_grid_color']
pal = QPalette()
col = QColor(r, g, b)
pal.setColor(pal.Base, col)
dark = (r + g + b) / 3.0 < 128
pal.setColor(pal.Text, QColor(Qt.white if dark else Qt.black))
self.setPalette(pal)
self.delegate.highlight_color = pal.color(pal.Text)
def refresh_settings(self):
size_changed = (
gprefs['cover_grid_width'] != self.delegate.original_width
or gprefs['cover_grid_height'] != self.delegate.original_height)
if (size_changed or gprefs['cover_grid_show_title'] !=
self.delegate.original_show_title):
self.delegate.set_dimensions()
self.setSpacing(self.delegate.spacing)
if size_changed:
self.delegate.cover_cache.clear()
if gprefs['cover_grid_spacing'] != self.delegate.original_spacing:
self.delegate.calculate_spacing()
self.setSpacing(self.delegate.spacing)
self.set_color()
self.delegate.cover_cache.set_limit(gprefs['cover_grid_cache_size'])
if size_changed:
self.thumbnail_cache.set_thumbnail_size(
self.delegate.cover_size.width(),
self.delegate.cover_size.height())
cs = gprefs['cover_grid_disk_cache_size']
if (cs * (1024**2)) != self.thumbnail_cache.max_size:
self.thumbnail_cache.set_size(cs)
def shown(self):
if self.render_thread is None:
self.thumbnail_cache.set_database(self.gui.current_db)
self.render_thread = Thread(target=self.render_covers)
self.render_thread.daemon = True
self.render_thread.start()
def render_covers(self):
q = self.delegate.render_queue
while True:
book_id = q.get()
try:
if book_id is None:
return
if self.ignore_render_requests.is_set():
continue
try:
self.render_cover(book_id)
except:
import traceback
traceback.print_exc()
finally:
q.task_done()
def render_cover(self, book_id):
if self.ignore_render_requests.is_set():
return
tcdata, timestamp = self.thumbnail_cache[book_id]
use_cache = False
if timestamp is None:
# Not in cache
has_cover, cdata, timestamp = self.model(
).db.new_api.cover_or_cache(book_id, 0)
else:
has_cover, cdata, timestamp = self.model(
).db.new_api.cover_or_cache(book_id, timestamp)
if has_cover and cdata is None:
# The cached cover is fresh
cdata = tcdata
use_cache = True
if has_cover:
p = QImage()
p.loadFromData(cdata, CACHE_FORMAT if cdata is tcdata else 'JPEG')
if p.isNull() and cdata is tcdata:
# Invalid image in cache
self.thumbnail_cache.invalidate((book_id, ))
self.update_item.emit(book_id)
return
cdata = None if p.isNull() else p
if not use_cache: # cache is stale
if cdata is not None:
width, height = p.width(), p.height()
scaled, nwidth, nheight = fit_image(
width, height, self.delegate.cover_size.width(),
self.delegate.cover_size.height())
if scaled:
if self.ignore_render_requests.is_set():
return
p = p.scaled(nwidth, nheight, Qt.IgnoreAspectRatio,
Qt.SmoothTransformation)
cdata = p
# update cache
if cdata is None:
self.thumbnail_cache.invalidate((book_id, ))
else:
try:
self.thumbnail_cache.insert(book_id, timestamp,
image_to_data(cdata))
except EncodeError as err:
self.thumbnail_cache.invalidate((book_id, ))
prints(err)
except Exception:
import traceback
traceback.print_exc()
elif tcdata is not None:
# Cover was removed, but it exists in cache, remove from cache
self.thumbnail_cache.invalidate((book_id, ))
self.delegate.cover_cache.set(book_id, cdata)
self.update_item.emit(book_id)
def re_render(self, book_id):
self.delegate.cover_cache.clear_staging()
m = self.model()
try:
index = m.db.row(book_id)
except (IndexError, ValueError, KeyError):
return
self.update(m.index(index, 0))
def shutdown(self):
self.ignore_render_requests.set()
self.delegate.render_queue.put(None)
self.thumbnail_cache.shutdown()
def set_database(self, newdb, stage=0):
if stage == 0:
self.ignore_render_requests.set()
try:
for x in (self.delegate.cover_cache, self.thumbnail_cache):
self.model().db.new_api.remove_cover_cache(x)
except AttributeError:
pass # db is None
for x in (self.delegate.cover_cache, self.thumbnail_cache):
newdb.new_api.add_cover_cache(x)
try:
# Use a timeout so that if, for some reason, the render thread
# gets stuck, we dont deadlock, future covers wont get
# rendered, but this is better than a deadlock
join_with_timeout(self.delegate.render_queue)
except RuntimeError:
print('Cover rendering thread is stuck!')
finally:
self.ignore_render_requests.clear()
else:
self.delegate.cover_cache.clear()
def select_rows(self, rows):
sel = QItemSelection()
sm = self.selectionModel()
m = self.model()
# Create a range based selector for each set of contiguous rows
# as supplying selectors for each individual row causes very poor
# performance if a large number of rows has to be selected.
for k, g in itertools.groupby(enumerate(rows), lambda (i, x): i - x):
group = list(map(operator.itemgetter(1), g))
sel.merge(
QItemSelection(m.index(min(group), 0), m.index(max(group), 0)),
sm.Select)
sm.select(sel, sm.ClearAndSelect)
def __init__(self, parent):
QWidget.__init__(self, parent)
self.parent = parent
self._layout = QVBoxLayout()
self.setLayout(self._layout)
self._layout.setContentsMargins(0, 0, 0, 0)
# Set up the find box & button
search_layout = QHBoxLayout()
self._layout.addLayout(search_layout)
self.item_search = HistoryLineEdit(parent)
self.item_search.setMinimumContentsLength(10)
self.item_search.setSizeAdjustPolicy(
self.item_search.AdjustToMinimumContentsLengthWithIcon)
try:
self.item_search.lineEdit().setPlaceholderText(
_('Find item in tag browser'))
except:
pass # Using Qt < 4.7
self.item_search.setToolTip(
_('Search for items. This is a "contains" search; items containing the\n'
'text anywhere in the name will be found. You can limit the search\n'
'to particular categories using syntax similar to search. For example,\n'
'tags:foo will find foo in any tag, but not in authors etc. Entering\n'
'*foo will filter all categories at once, showing only those items\n'
'containing the text "foo"'))
search_layout.addWidget(self.item_search)
# Not sure if the shortcut should be translatable ...
sc = QShortcut(QKeySequence(_('ALT+f')), parent)
sc.activated.connect(self.set_focus_to_find_box)
self.search_button = QToolButton()
self.search_button.setText(_('F&ind'))
self.search_button.setToolTip(_('Find the first/next matching item'))
search_layout.addWidget(self.search_button)
self.expand_button = QToolButton()
self.expand_button.setText('-')
self.expand_button.setToolTip(_('Collapse all categories'))
search_layout.addWidget(self.expand_button)
search_layout.setStretch(0, 10)
search_layout.setStretch(1, 1)
search_layout.setStretch(2, 1)
self.current_find_position = None
self.search_button.clicked.connect(self.find)
self.item_search.initialize('tag_browser_search')
self.item_search.lineEdit().returnPressed.connect(self.do_find)
self.item_search.lineEdit().textEdited.connect(self.find_text_changed)
self.item_search.activated[QString].connect(self.do_find)
self.item_search.completer().setCaseSensitivity(Qt.CaseSensitive)
parent.tags_view = TagsView(parent)
self.tags_view = parent.tags_view
self.expand_button.clicked.connect(self.tags_view.collapseAll)
self._layout.addWidget(parent.tags_view)
# Now the floating 'not found' box
l = QLabel(self.tags_view)
self.not_found_label = l
l.setFrameStyle(QFrame.StyledPanel)
l.setAutoFillBackground(True)
l.setText(
'<p><b>' +
_('No More Matches.</b><p> Click Find again to go to first match'))
l.setAlignment(Qt.AlignVCenter)
l.setWordWrap(True)
l.resize(l.sizeHint())
l.move(10, 20)
l.setVisible(False)
self.not_found_label_timer = QTimer()
self.not_found_label_timer.setSingleShot(True)
self.not_found_label_timer.timeout.connect(
self.not_found_label_timer_event, type=Qt.QueuedConnection)
parent.alter_tb = l = QPushButton(parent)
l.setText(_('Alter Tag Browser'))
l.setIcon(QIcon(I('tags.png')))
l.m = QMenu()
l.setMenu(l.m)
self._layout.addWidget(l)
sb = l.m.addAction(_('Sort by'))
sb.m = l.sort_menu = QMenu(l.m)
sb.setMenu(sb.m)
sb.bg = QActionGroup(sb)
# Must be in the same order as db2.CATEGORY_SORTS
for i, x in enumerate((_('Sort by name'), _('Sort by popularity'),
_('Sort by average rating'))):
a = sb.m.addAction(x)
sb.bg.addAction(a)
a.setCheckable(True)
if i == 0:
a.setChecked(True)
sb.setToolTip(_('Set the sort order for entries in the Tag Browser'))
sb.setStatusTip(sb.toolTip())
ma = l.m.addAction(_('Search type when selecting multiple items'))
ma.m = l.match_menu = QMenu(l.m)
ma.setMenu(ma.m)
ma.ag = QActionGroup(ma)
# Must be in the same order as db2.MATCH_TYPE
for i, x in enumerate(
(_('Match any of the items'), _('Match all of the items'))):
a = ma.m.addAction(x)
ma.ag.addAction(a)
a.setCheckable(True)
if i == 0:
a.setChecked(True)
ma.setToolTip(
_('When selecting multiple entries in the Tag Browser '
'match any or all of them'))
ma.setStatusTip(ma.toolTip())
mt = l.m.addAction(_('Manage authors, tags, etc'))
mt.setToolTip(
_('All of these category_managers are available by right-clicking '
'on items in the tag browser above'))
mt.m = l.manage_menu = QMenu(l.m)
mt.setMenu(mt.m)
def __init__(self, plugin_action):
QWidget.__init__(self)
self.parent = plugin_action
self.gui = get_gui()
self.icon = plugin_action.icon
self.opts = plugin_action.opts
self.prefs = plugin_prefs
self.resources_path = plugin_action.resources_path
self.verbose = plugin_action.verbose
self.restart_required = False
self._log_location()
self.l = QGridLayout()
self.setLayout(self.l)
self.column1_layout = QVBoxLayout()
self.l.addLayout(self.column1_layout, 0, 0)
self.column2_layout = QVBoxLayout()
self.l.addLayout(self.column2_layout, 0, 1)
# ----------------------------- Column 1 -----------------------------
# ~~~~~~~~ Create the Custom fields options group box ~~~~~~~~
self.cfg_custom_fields_gb = QGroupBox(self)
self.cfg_custom_fields_gb.setTitle('Custom column assignments')
self.column1_layout.addWidget(self.cfg_custom_fields_gb)
self.cfg_custom_fields_qgl = QGridLayout(self.cfg_custom_fields_gb)
current_row = 0
# ++++++++ Labels + HLine ++++++++
self.marvin_source_label = QLabel("Marvin source")
self.cfg_custom_fields_qgl.addWidget(self.marvin_source_label,
current_row, 0)
self.calibre_destination_label = QLabel("calibre destination")
self.cfg_custom_fields_qgl.addWidget(self.calibre_destination_label,
current_row, 1)
current_row += 1
self.sd_hl = QFrame(self.cfg_custom_fields_gb)
self.sd_hl.setFrameShape(QFrame.HLine)
self.sd_hl.setFrameShadow(QFrame.Raised)
self.cfg_custom_fields_qgl.addWidget(self.sd_hl, current_row, 0, 1, 3)
current_row += 1
# ++++++++ Annotations ++++++++
self.cfg_annotations_label = QLabel('Annotations')
self.cfg_annotations_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_annotations_label,
current_row, 0)
self.annotations_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.annotations_field_comboBox.setObjectName(
'annotations_field_comboBox')
self.annotations_field_comboBox.setToolTip(
'Select a custom column to store Marvin annotations')
self.cfg_custom_fields_qgl.addWidget(self.annotations_field_comboBox,
current_row, 1)
self.cfg_highlights_wizard = QToolButton()
self.cfg_highlights_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_highlights_wizard.setToolTip(
"Create a custom column to store Marvin annotations")
self.cfg_highlights_wizard.clicked.connect(
partial(self.launch_cc_wizard, 'Annotations'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_highlights_wizard,
current_row, 2)
current_row += 1
# ++++++++ Collections ++++++++
self.cfg_collections_label = QLabel('Collections')
self.cfg_collections_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_collections_label,
current_row, 0)
self.collection_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.collection_field_comboBox.setObjectName(
'collection_field_comboBox')
self.collection_field_comboBox.setToolTip(
'Select a custom column to store Marvin collection assignments')
self.cfg_custom_fields_qgl.addWidget(self.collection_field_comboBox,
current_row, 1)
self.cfg_collections_wizard = QToolButton()
self.cfg_collections_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_collections_wizard.setToolTip(
"Create a custom column for Marvin collection assignments")
self.cfg_collections_wizard.clicked.connect(
partial(self.launch_cc_wizard, 'Collections'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_collections_wizard,
current_row, 2)
current_row += 1
# ++++++++ Last read ++++++++
self.cfg_date_read_label = QLabel("Last read")
self.cfg_date_read_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_date_read_label,
current_row, 0)
self.date_read_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.date_read_field_comboBox.setObjectName('date_read_field_comboBox')
self.date_read_field_comboBox.setToolTip(
'Select a custom column to store Last read date')
self.cfg_custom_fields_qgl.addWidget(self.date_read_field_comboBox,
current_row, 1)
self.cfg_collections_wizard = QToolButton()
self.cfg_collections_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_collections_wizard.setToolTip(
"Create a custom column to store Last read date")
self.cfg_collections_wizard.clicked.connect(
partial(self.launch_cc_wizard, 'Last read'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_collections_wizard,
current_row, 2)
current_row += 1
# ++++++++ Progress ++++++++
self.cfg_progress_label = QLabel('Progress')
self.cfg_progress_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_progress_label,
current_row, 0)
self.progress_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.progress_field_comboBox.setObjectName('progress_field_comboBox')
self.progress_field_comboBox.setToolTip(
'Select a custom column to store Marvin reading progress')
self.cfg_custom_fields_qgl.addWidget(self.progress_field_comboBox,
current_row, 1)
self.cfg_progress_wizard = QToolButton()
self.cfg_progress_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_progress_wizard.setToolTip(
"Create a custom column to store Marvin reading progress")
self.cfg_progress_wizard.clicked.connect(
partial(self.launch_cc_wizard, 'Progress'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_progress_wizard,
current_row, 2)
current_row += 1
# ++++++++ Read flag ++++++++
self.cfg_read_label = QLabel('Read')
self.cfg_read_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_read_label, current_row,
0)
self.read_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.read_field_comboBox.setObjectName('read_field_comboBox')
self.read_field_comboBox.setToolTip(
'Select a custom column to store Marvin Read status')
self.cfg_custom_fields_qgl.addWidget(self.read_field_comboBox,
current_row, 1)
self.cfg_read_wizard = QToolButton()
self.cfg_read_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_read_wizard.setToolTip(
"Create a custom column to store Marvin Read status")
self.cfg_read_wizard.clicked.connect(
partial(self.launch_cc_wizard, 'Read'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_read_wizard, current_row,
2)
current_row += 1
# ++++++++ Reading list flag ++++++++
self.cfg_reading_list_label = QLabel('Reading list')
self.cfg_reading_list_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_reading_list_label,
current_row, 0)
self.reading_list_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.reading_list_field_comboBox.setObjectName(
'reading_list_field_comboBox')
self.reading_list_field_comboBox.setToolTip(
'Select a custom column to store Marvin Reading list status')
self.cfg_custom_fields_qgl.addWidget(self.reading_list_field_comboBox,
current_row, 1)
self.cfg_reading_list_wizard = QToolButton()
self.cfg_reading_list_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_reading_list_wizard.setToolTip(
"Create a custom column to store Marvin Reading list status")
self.cfg_reading_list_wizard.clicked.connect(
partial(self.launch_cc_wizard, 'Reading list'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_reading_list_wizard,
current_row, 2)
current_row += 1
# ++++++++ Word count ++++++++
self.cfg_word_count_label = QLabel('Word count')
self.cfg_word_count_label.setAlignment(Qt.AlignLeft)
self.cfg_custom_fields_qgl.addWidget(self.cfg_word_count_label,
current_row, 0)
self.word_count_field_comboBox = QComboBox(self.cfg_custom_fields_gb)
self.word_count_field_comboBox.setObjectName(
'word_count_field_comboBox')
self.word_count_field_comboBox.setToolTip(
'Select a custom column to store Marvin word counts')
self.cfg_custom_fields_qgl.addWidget(self.word_count_field_comboBox,
current_row, 1)
self.cfg_word_count_wizard = QToolButton()
self.cfg_word_count_wizard.setIcon(QIcon(I('wizard.png')))
self.cfg_word_count_wizard.setToolTip(
"Create a custom column to store Marvin word counts")
self.cfg_word_count_wizard.clicked.connect(
partial(self.launch_cc_wizard, 'Word count'))
self.cfg_custom_fields_qgl.addWidget(self.cfg_word_count_wizard,
current_row, 2)
current_row += 1
self.spacerItem1 = QSpacerItem(20, 20, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.column1_layout.addItem(self.spacerItem1)
# ----------------------------- Column 2 -----------------------------
# ~~~~~~~~ Create the CSS group box ~~~~~~~~
self.cfg_css_options_gb = QGroupBox(self)
self.cfg_css_options_gb.setTitle('CSS')
self.column2_layout.addWidget(self.cfg_css_options_gb)
self.cfg_css_options_qgl = QGridLayout(self.cfg_css_options_gb)
current_row = 0
# ++++++++ Annotations appearance ++++++++
self.annotations_icon = QIcon(
os.path.join(self.resources_path, 'icons',
'annotations_hiliter.png'))
self.cfg_annotations_appearance_toolbutton = QToolButton()
self.cfg_annotations_appearance_toolbutton.setIcon(
self.annotations_icon)
self.cfg_annotations_appearance_toolbutton.clicked.connect(
self.configure_appearance)
self.cfg_css_options_qgl.addWidget(
self.cfg_annotations_appearance_toolbutton, current_row, 0)
self.cfg_annotations_label = ClickableQLabel("Annotations")
self.connect(self.cfg_annotations_label, SIGNAL('clicked()'),
self.configure_appearance)
self.cfg_css_options_qgl.addWidget(self.cfg_annotations_label,
current_row, 1)
current_row += 1
# ++++++++ Injected CSS ++++++++
self.css_editor_icon = QIcon(I('format-text-heading.png'))
self.cfg_css_editor_toolbutton = QToolButton()
self.cfg_css_editor_toolbutton.setIcon(self.css_editor_icon)
self.cfg_css_editor_toolbutton.clicked.connect(self.edit_css)
self.cfg_css_options_qgl.addWidget(self.cfg_css_editor_toolbutton,
current_row, 0)
self.cfg_css_editor_label = ClickableQLabel("Articles, Vocabulary")
self.connect(self.cfg_css_editor_label, SIGNAL('clicked()'),
self.edit_css)
self.cfg_css_options_qgl.addWidget(self.cfg_css_editor_label,
current_row, 1)
"""
# ~~~~~~~~ Create the Dropbox syncing group box ~~~~~~~~
self.cfg_dropbox_syncing_gb = QGroupBox(self)
self.cfg_dropbox_syncing_gb.setTitle('Dropbox')
self.column2_layout.addWidget(self.cfg_dropbox_syncing_gb)
self.cfg_dropbox_syncing_qgl = QGridLayout(self.cfg_dropbox_syncing_gb)
current_row = 0
# ++++++++ Syncing enabled checkbox ++++++++
self.dropbox_syncing_checkbox = QCheckBox('Enable Dropbox updates')
self.dropbox_syncing_checkbox.setObjectName('dropbox_syncing')
self.dropbox_syncing_checkbox.setToolTip('Refresh custom column content from Marvin metadata')
self.cfg_dropbox_syncing_qgl.addWidget(self.dropbox_syncing_checkbox,
current_row, 0, 1, 3)
current_row += 1
# ++++++++ Dropbox folder picker ++++++++
self.dropbox_folder_icon = QIcon(os.path.join(self.resources_path, 'icons', 'dropbox.png'))
self.cfg_dropbox_folder_toolbutton = QToolButton()
self.cfg_dropbox_folder_toolbutton.setIcon(self.dropbox_folder_icon)
self.cfg_dropbox_folder_toolbutton.setToolTip("Specify Dropbox folder location on your computer")
self.cfg_dropbox_folder_toolbutton.clicked.connect(self.select_dropbox_folder)
self.cfg_dropbox_syncing_qgl.addWidget(self.cfg_dropbox_folder_toolbutton,
current_row, 1)
# ++++++++ Dropbox location lineedit ++++++++
self.dropbox_location_lineedit = QLineEdit()
self.dropbox_location_lineedit.setPlaceholderText("Dropbox folder location")
self.cfg_dropbox_syncing_qgl.addWidget(self.dropbox_location_lineedit,
current_row, 2)
"""
# ~~~~~~~~ Create the General options group box ~~~~~~~~
self.cfg_runtime_options_gb = QGroupBox(self)
self.cfg_runtime_options_gb.setTitle('General options')
self.column2_layout.addWidget(self.cfg_runtime_options_gb)
self.cfg_runtime_options_qvl = QVBoxLayout(self.cfg_runtime_options_gb)
# ++++++++ Auto refresh checkbox ++++++++
self.auto_refresh_checkbox = QCheckBox(
'Automatically refresh custom column content')
self.auto_refresh_checkbox.setObjectName('auto_refresh_at_startup')
self.auto_refresh_checkbox.setToolTip(
'Update calibre custom column when Marvin XD is opened')
self.cfg_runtime_options_qvl.addWidget(self.auto_refresh_checkbox)
# ++++++++ Progress as percentage checkbox ++++++++
self.reading_progress_checkbox = QCheckBox(
'Show reading progress as percentage')
self.reading_progress_checkbox.setObjectName(
'show_progress_as_percentage')
self.reading_progress_checkbox.setToolTip(
'Display percentage in Progress column')
self.cfg_runtime_options_qvl.addWidget(self.reading_progress_checkbox)
# ~~~~~~~~ Create the Debug options group box ~~~~~~~~
self.cfg_debug_options_gb = QGroupBox(self)
self.cfg_debug_options_gb.setTitle('Debug options')
self.column2_layout.addWidget(self.cfg_debug_options_gb)
self.cfg_debug_options_qvl = QVBoxLayout(self.cfg_debug_options_gb)
# ++++++++ Debug logging checkboxes ++++++++
self.debug_plugin_checkbox = QCheckBox(
'Enable debug logging for Marvin XD')
self.debug_plugin_checkbox.setObjectName('debug_plugin_checkbox')
self.debug_plugin_checkbox.setToolTip(
'Print plugin diagnostic messages to console')
self.cfg_debug_options_qvl.addWidget(self.debug_plugin_checkbox)
self.debug_libimobiledevice_checkbox = QCheckBox(
'Enable debug logging for libiMobileDevice')
self.debug_libimobiledevice_checkbox.setObjectName(
'debug_libimobiledevice_checkbox')
self.debug_libimobiledevice_checkbox.setToolTip(
'Print libiMobileDevice diagnostic messages to console')
self.cfg_debug_options_qvl.addWidget(
self.debug_libimobiledevice_checkbox)
self.spacerItem2 = QSpacerItem(20, 20, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.column2_layout.addItem(self.spacerItem2)
# ~~~~~~~~ End of construction zone ~~~~~~~~
self.resize(self.sizeHint())
# ~~~~~~~~ Populate/restore config options ~~~~~~~~
# Annotations comboBox
self.populate_annotations()
self.populate_collections()
self.populate_date_read()
self.populate_progress()
self.populate_read()
self.populate_reading_list()
self.populate_word_count()
"""
# Restore Dropbox settings, hook changes
dropbox_syncing = self.prefs.get('dropbox_syncing', False)
self.dropbox_syncing_checkbox.setChecked(dropbox_syncing)
self.set_dropbox_syncing(dropbox_syncing)
self.dropbox_syncing_checkbox.clicked.connect(partial(self.set_dropbox_syncing))
self.dropbox_location_lineedit.setText(self.prefs.get('dropbox_folder', ''))
"""
# Restore general settings
self.auto_refresh_checkbox.setChecked(
self.prefs.get('auto_refresh_at_startup', False))
self.reading_progress_checkbox.setChecked(
self.prefs.get('show_progress_as_percentage', False))
# Restore debug settings, hook changes
self.debug_plugin_checkbox.setChecked(
self.prefs.get('debug_plugin', False))
self.debug_plugin_checkbox.stateChanged.connect(
self.set_restart_required)
self.debug_libimobiledevice_checkbox.setChecked(
self.prefs.get('debug_libimobiledevice', False))
self.debug_libimobiledevice_checkbox.stateChanged.connect(
self.set_restart_required)
# Hook changes to Annotations comboBox
# self.annotations_field_comboBox.currentIndexChanged.connect(
# partial(self.save_combobox_setting, 'annotations_field_comboBox'))
self.connect(self.annotations_field_comboBox,
SIGNAL('currentIndexChanged(const QString &)'),
self.annotations_destination_changed)
# Launch the annotated_books_scanner
field = get_cc_mapping('annotations', 'field', None)
self.annotated_books_scanner = InventoryAnnotatedBooks(self.gui, field)
self.connect(self.annotated_books_scanner,
self.annotated_books_scanner.signal,
self.inventory_complete)
QTimer.singleShot(1, self.start_inventory)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.l = l = QVBoxLayout()
self.setLayout(l)
l.setContentsMargins(0, 0, 0, 0)
self.view = WebView(self)
self.view.page().sync_requested.connect(self.request_sync)
self.view.page().split_requested.connect(self.request_split)
self.view.page().loadFinished.connect(self.load_finished)
self.inspector = self.view.inspector
self.inspector.setPage(self.view.page())
l.addWidget(self.view)
self.bar = QToolBar(self)
l.addWidget(self.bar)
ac = actions['auto-reload-preview']
ac.setCheckable(True)
ac.setChecked(True)
ac.toggled.connect(self.auto_reload_toggled)
self.auto_reload_toggled(ac.isChecked())
self.bar.addAction(ac)
ac = actions['sync-preview-to-editor']
ac.setCheckable(True)
ac.setChecked(True)
ac.toggled.connect(self.sync_toggled)
self.sync_toggled(ac.isChecked())
self.bar.addAction(ac)
self.bar.addSeparator()
ac = actions['split-in-preview']
ac.setCheckable(True)
ac.setChecked(False)
ac.toggled.connect(self.split_toggled)
self.split_toggled(ac.isChecked())
self.bar.addAction(ac)
ac = actions['reload-preview']
ac.triggered.connect(self.refresh)
self.bar.addAction(ac)
actions['preview-dock'].toggled.connect(self.visibility_changed)
self.current_name = None
self.last_sync_request = None
self.refresh_timer = QTimer(self)
self.refresh_timer.timeout.connect(self.refresh)
parse_worker.start()
self.current_sync_request = None
self.search = HistoryLineEdit2(self)
self.search.initialize('tweak_book_preview_search')
self.search.setPlaceholderText(_('Search in preview'))
self.search.returnPressed.connect(partial(self.find, 'next'))
self.bar.addSeparator()
self.bar.addWidget(self.search)
for d in ('next', 'prev'):
ac = actions['find-%s-preview' % d]
ac.triggered.connect(partial(self.find, d))
self.bar.addAction(ac)
def __init__(self, pathtoebook=None, debug_javascript=False, open_at=None):
MainWindow.__init__(self, None)
self.setupUi(self)
self.view.initialize_view(debug_javascript)
self.view.magnification_changed.connect(self.magnification_changed)
self.show_toc_on_open = False
self.current_book_has_toc = False
self.base_window_title = unicode(self.windowTitle())
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.existing_bookmarks = []
self.selected_text = None
self.read_settings()
self.dictionary_box.hide()
self.close_dictionary_view.clicked.connect(
lambda x: self.dictionary_box.hide())
self.history = History(self.action_back, self.action_forward)
self.metadata = Metadata(self)
self.pos = DoubleSpinBox()
self.pos.setDecimals(1)
self.pos.setSuffix('/' + _('Unknown') + ' ')
self.pos.setMinimum(1.)
self.pos.setMinimumWidth(150)
self.tool_bar2.insertWidget(self.action_find_next, self.pos)
self.reference = Reference()
self.tool_bar2.insertSeparator(self.action_find_next)
self.tool_bar2.insertWidget(self.action_find_next, self.reference)
self.tool_bar2.insertSeparator(self.action_find_next)
self.setFocusPolicy(Qt.StrongFocus)
self.search = SearchBox2(self)
self.search.setMinimumContentsLength(20)
self.search.initialize('viewer_search_history')
self.search.setToolTip(_('Search for text in book'))
self.search.setMinimumWidth(200)
self.tool_bar2.insertWidget(self.action_find_next, self.search)
self.view.set_manager(self)
self.pi = ProgressIndicator(self)
self.toc.setVisible(False)
self.action_quit = QAction(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
qs = [Qt.CTRL + Qt.Key_Q]
if isosx:
qs += [Qt.CTRL + Qt.Key_W]
self.action_quit.setShortcuts(qs)
self.action_quit.triggered.connect(self.quit)
self.action_focus_search = QAction(self)
self.addAction(self.action_focus_search)
self.action_focus_search.setShortcuts(
[Qt.Key_Slash, QKeySequence(QKeySequence.Find)])
self.action_focus_search.triggered.connect(
lambda x: self.search.setFocus(Qt.OtherFocusReason))
self.action_copy.setDisabled(True)
self.action_metadata.setCheckable(True)
self.action_metadata.setShortcut(Qt.CTRL + Qt.Key_I)
self.action_table_of_contents.setCheckable(True)
self.toc.setMinimumWidth(80)
self.action_reference_mode.setCheckable(True)
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_full_screen.setShortcuts(
[Qt.Key_F11, Qt.CTRL + Qt.SHIFT + Qt.Key_F])
self.action_full_screen.setToolTip(
_('Toggle full screen (%s)') % _(' or ').join([
unicode(x.toString(x.NativeText))
for x in self.action_full_screen.shortcuts()
]))
self.action_back.triggered[bool].connect(self.back)
self.action_forward.triggered[bool].connect(self.forward)
self.action_bookmark.triggered[bool].connect(self.bookmark)
self.action_preferences.triggered.connect(
lambda: self.view.config(self))
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.reference.goto.connect(self.goto)
self.bookmarks_menu = QMenu()
self.action_bookmark.setMenu(self.bookmarks_menu)
self.set_bookmarks([])
if pathtoebook is not None:
f = functools.partial(self.load_ebook,
pathtoebook,
open_at=open_at)
QTimer.singleShot(50, f)
self.view.setMinimumSize(100, 100)
self.toc.setCursor(Qt.PointingHandCursor)
self.tool_bar.setContextMenuPolicy(Qt.PreventContextMenu)
self.tool_bar2.setContextMenuPolicy(Qt.PreventContextMenu)
self.tool_bar.widgetForAction(self.action_bookmark).setPopupMode(
QToolButton.MenuButtonPopup)
self.action_full_screen.setCheckable(True)
self.full_screen_label = QLabel(
'''
<center>
<h1>%s</h1>
<h3>%s</h3>
<h3>%s</h3>
</center>
''' %
(_('Full screen mode'), _('Right click to show controls'),
_('Press Esc to quit')), self)
self.full_screen_label.setVisible(False)
self.full_screen_label.setStyleSheet('''
QLabel {
text-align: center;
background-color: white;
color: black;
border-width: 1px;
border-style: solid;
border-radius: 20px;
}
''')
self.window_mode_changed = None
self.toggle_toolbar_action = QAction(_('Show/hide controls'), self)
self.toggle_toolbar_action.triggered.connect(self.toggle_toolbars)
self.addAction(self.toggle_toolbar_action)
self.full_screen_label_anim = QPropertyAnimation(
self.full_screen_label, 'size')
self.clock_label = QLabel('99:99', self)
self.clock_label.setVisible(False)
self.clock_label.setFocusPolicy(Qt.NoFocus)
self.clock_label_style = '''
QLabel {
text-align: right;
border-width: 1px;
border-style: solid;
border-radius: 8px;
background-color: %s;
color: %s;
font-family: monospace;
font-size: larger;
padding: 5px;
}'''
self.clock_timer = QTimer(self)
self.clock_timer.timeout.connect(self.update_clock)
self.esc_full_screen_action = a = QAction(self)
self.addAction(a)
a.setShortcut(Qt.Key_Escape)
a.setEnabled(False)
a.triggered.connect(self.action_full_screen.trigger)
self.print_menu = QMenu()
self.print_menu.addAction(QIcon(I('print-preview.png')),
_('Print Preview'))
self.action_print.setMenu(self.print_menu)
self.tool_bar.widgetForAction(self.action_print).setPopupMode(
QToolButton.MenuButtonPopup)
self.action_print.triggered.connect(self.print_book)
self.print_menu.actions()[0].triggered.connect(self.print_preview)
ca = self.view.copy_action
ca.setShortcut(QKeySequence.Copy)
self.addAction(ca)
self.open_history_menu = QMenu()
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.action_open_ebook.setMenu(self.open_history_menu)
self.open_history_menu.triggered[QAction].connect(self.open_recent)
w = self.tool_bar.widgetForAction(self.action_open_ebook)
w.setPopupMode(QToolButton.MenuButtonPopup)
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)
self.restore_state()
def _launch_gamess(self):
oldir = os.getcwd() # Save current directory
####self.outputFile = QFile(self.job_outputfile)
####self.outputFile.open( IO_WriteOnly | IO_Append )
jobInputfile = os.path.basename(self.job_inputfile)
jobInputFile = jobInputfile[:-4]
jobOutputfile = self.job_outputfile #os.path.basename(self.job_outputfile)
### Notes: The following way to get the 'bin' works by assuming user didn't change the
### working directory after the atom runs, otherwise it will get problem.
filePath = os.path.dirname(os.path.abspath(sys.argv[0]))
program = os.path.normpath(filePath + '/../bin/rungms')
jobDir = os.path.dirname(self.job_batfile)
os.chdir(jobDir) # Change directory to the GAMESS temp directory.
# print "Current directory is: ", jobDir
executableFile = self.server.program
args = [program, jobInputFile, jobOutputfile,
executableFile] #, '01', '1']
self.process = QProcess()
for s in args:
self.process.addArgument(s)
####self.process.setCommunication(QProcess.Stdout)
print "The params for the QProcess run are: ", args
####self.fwThread = _FileWriting(self.outputFile)
self.jobTimer = QTimer(self)
self.progressDialog = JobProgressDialog(self.process, self.Calculation)
self.connect(self.process, SIGNAL('processExited ()'),
self.processDone)
#self.connect(self.process, SIGNAL('readyReadStdout()'), self.readOutData)
####self.fwThread.start()
if not self.process.start():
print "The process can't be started."
return 2
self.connect(self.jobTimer, SIGNAL('timeout()'), self.processTimeout)
self.stime = time.time()
self.jobTimer.start(1)
ret = self.progressDialog.exec_()
if ret == QDialog.Accepted:
retValue = 0
else:
retValue = 1
####self.fwThread.wait()
####bytes = self.process.readStdout()
####if bytes:
#####self.outputFile.writeBlock(bytes)
#####self.outputFile.flush()
self.process = None
####self.outputFile.close()
os.chdir(oldir)
self.gamessJig.outputfile = self.job_outputfile
return retValue
def setup_ui(self):
self.l = l = QVBoxLayout(self)
self.setLayout(l)
self.h = h = QHBoxLayout()
self.filter_text = ft = QLineEdit(self)
ft.textChanged.connect(self.do_filter)
ft.setPlaceholderText(_('Filter displayed searches'))
h.addWidget(ft)
self.cft = cft = QToolButton(self)
cft.setToolTip(_('Clear filter')), cft.setIcon(
QIcon(I('clear_left.png')))
cft.clicked.connect(ft.clear)
h.addWidget(cft)
l.addLayout(h)
self.h2 = h = QHBoxLayout()
self.searches = searches = QListView(self)
searches.doubleClicked.connect(self.edit_search)
self.model = SearchesModel(self.searches)
self.model.dataChanged.connect(self.show_details)
searches.setModel(self.model)
searches.selectionModel().currentChanged.connect(self.show_details)
searches.setSelectionMode(searches.ExtendedSelection)
self.delegate = SearchDelegate(searches)
searches.setItemDelegate(self.delegate)
searches.setAlternatingRowColors(True)
h.addWidget(searches, stretch=10)
self.v = v = QVBoxLayout()
h.addLayout(v)
l.addLayout(h)
def pb(text, tooltip=None):
b = QPushButton(text, self)
b.setToolTip(tooltip or '')
b.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
return b
mulmsg = '\n\n' + _(
'The entries are tried in order until the first one matches.')
for text, action, tooltip in [
(_('&Find'), 'find',
_('Run the search using the selected entries.') + mulmsg),
(_('&Replace'), 'replace',
_('Run replace using the selected entries.') + mulmsg),
(_('Replace a&nd Find'), 'replace-find',
_('Run replace and then find using the selected entries.') +
mulmsg),
(_('Replace &all'), 'replace-all',
_('Run Replace All for all selected entries in the order selected'
)),
(_('&Count all'), 'count',
_('Run Count All for all selected entries')),
]:
b = pb(text, tooltip)
v.addWidget(b)
b.clicked.connect(partial(self.run_search, action))
self.d1 = d = QFrame(self)
d.setFrameStyle(QFrame.HLine)
v.addWidget(d)
self.h3 = h = QHBoxLayout()
self.upb = b = QToolButton(self)
b.setIcon(QIcon(I('arrow-up.png'))), b.setToolTip(
_('Move selected entries up'))
b.clicked.connect(partial(self.move_entry, -1))
self.dnb = b = QToolButton(self)
b.setIcon(QIcon(I('arrow-down.png'))), b.setToolTip(
_('Move selected entries down'))
b.clicked.connect(partial(self.move_entry, 1))
h.addWidget(self.upb), h.addWidget(self.dnb)
v.addLayout(h)
self.eb = b = pb(_('&Edit search'),
_('Edit the currently selected search'))
b.clicked.connect(self.edit_search)
v.addWidget(b)
self.eb = b = pb(_('Re&move search'),
_('Remove the currently selected searches'))
b.clicked.connect(self.remove_search)
v.addWidget(b)
self.eb = b = pb(_('&Add search'), _('Add a new saved search'))
b.clicked.connect(self.add_search)
v.addWidget(b)
self.d2 = d = QFrame(self)
d.setFrameStyle(QFrame.HLine)
v.addWidget(d)
self.where_box = wb = WhereBox(self, emphasize=True)
self.where = SearchWidget.DEFAULT_STATE['where']
v.addWidget(wb)
self.direction_box = db = DirectionBox(self)
self.direction = SearchWidget.DEFAULT_STATE['direction']
v.addWidget(db)
self.wr = wr = QCheckBox(_('&Wrap'))
wr.setToolTip('<p>' + _(
'When searching reaches the end, wrap around to the beginning and continue the search'
))
self.wr.setChecked(SearchWidget.DEFAULT_STATE['wrap'])
v.addWidget(wr)
self.description = d = QLabel(' \n \n ')
d.setTextFormat(Qt.PlainText)
l.addWidget(d)
l.addWidget(self.bb)
self.bb.clear()
self.bb.addButton(self.bb.Close)
self.ib = b = self.bb.addButton(_('&Import'), self.bb.ActionRole)
b.clicked.connect(self.import_searches)
self.eb = b = self.bb.addButton(_('E&xport'), self.bb.ActionRole)
self.em = m = QMenu(_('Export'))
m.addAction(
_('Export All'), lambda: QTimer.singleShot(
0, partial(self.export_searches, all=True)))
m.addAction(
_('Export Selected'), lambda: QTimer.singleShot(
0, partial(self.export_searches, all=False)))
b.setMenu(m)
self.searches.setFocus(Qt.OtherFocusReason)
def rebuild(self):
self.show_msg(_('Rebuilding, please wait...'))
QTimer.singleShot(5, self.do_rebuild)
def __init__(self,
debug=False,
parent=None,
minimized=None,
settings_path=""):
super(ScudCloud, self).__init__(parent)
self.debug = debug
self.minimized = minimized
self.setWindowTitle(self.title)
self.settings_path = settings_path
self.notifier = Notifier(Resources.APP_NAME,
Resources.get_path('scudcloud.png'))
self.settings = QSettings(self.settings_path + '/scudcloud.cfg',
QSettings.IniFormat)
self.identifier = self.settings.value("Domain")
if Unity is not None:
self.launcher = Unity.LauncherEntry.get_for_desktop_id(
"scudcloud.desktop")
else:
self.launcher = DummyLauncher(self)
self.webSettings()
self.leftPane = LeftPane(self)
self.stackedWidget = QtGui.QStackedWidget()
centralWidget = QtGui.QWidget(self)
layout = QtGui.QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(self.leftPane)
layout.addWidget(self.stackedWidget)
centralWidget.setLayout(layout)
self.setCentralWidget(centralWidget)
self.startURL = Resources.SIGNIN_URL
if self.identifier is not None:
if isinstance(self.identifier, str):
self.domains = self.identifier.split(",")
else:
self.domains = self.identifier
self.startURL = self.normalize(self.domains[0])
else:
self.domains = []
self.addWrapper(self.startURL)
self.addMenu()
self.tray = Systray(self)
self.systray(self.minimized)
self.installEventFilter(self)
self.statusBar().showMessage('Loading Slack...')
self.tickler = QTimer(self)
self.tickler.setInterval(1800000)
# Watch for ScreenLock events
if DBusQtMainLoop is not None:
DBusQtMainLoop(set_as_default=True)
sessionBus = dbus.SessionBus()
# Ubuntu 12.04 and other distros
sessionBus.add_match_string(
"type='signal',interface='org.gnome.ScreenSaver'")
# Ubuntu 14.04 and above
sessionBus.add_match_string(
"type='signal',interface='com.ubuntu.Upstart0_6'")
sessionBus.add_message_filter(self.screenListener)
self.tickler.timeout.connect(self.sendTickle)
# If dbus is not present, tickler timer will act like a blocker to not send tickle too often
else:
self.tickler.setSingleShot(True)
self.tickler.start()
def showInstallProgress(self):
QTimer.singleShot(
1, lambda: self.animate(start=BOTCENTER, stop=BOTCENTER))
class Preview(QWidget):
sync_requested = pyqtSignal(object, object)
split_requested = pyqtSignal(object, object, object)
split_start_requested = pyqtSignal()
link_clicked = pyqtSignal(object, object)
refresh_starting = pyqtSignal()
refreshed = pyqtSignal()
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.l = l = QVBoxLayout()
self.setLayout(l)
l.setContentsMargins(0, 0, 0, 0)
self.view = WebView(self)
self.view.page().sync_requested.connect(self.request_sync)
self.view.page().split_requested.connect(self.request_split)
self.view.page().loadFinished.connect(self.load_finished)
self.inspector = self.view.inspector
self.inspector.setPage(self.view.page())
l.addWidget(self.view)
self.bar = QToolBar(self)
l.addWidget(self.bar)
ac = actions['auto-reload-preview']
ac.setCheckable(True)
ac.setChecked(True)
ac.toggled.connect(self.auto_reload_toggled)
self.auto_reload_toggled(ac.isChecked())
self.bar.addAction(ac)
ac = actions['sync-preview-to-editor']
ac.setCheckable(True)
ac.setChecked(True)
ac.toggled.connect(self.sync_toggled)
self.sync_toggled(ac.isChecked())
self.bar.addAction(ac)
self.bar.addSeparator()
ac = actions['split-in-preview']
ac.setCheckable(True)
ac.setChecked(False)
ac.toggled.connect(self.split_toggled)
self.split_toggled(ac.isChecked())
self.bar.addAction(ac)
ac = actions['reload-preview']
ac.triggered.connect(self.refresh)
self.bar.addAction(ac)
actions['preview-dock'].toggled.connect(self.visibility_changed)
self.current_name = None
self.last_sync_request = None
self.refresh_timer = QTimer(self)
self.refresh_timer.timeout.connect(self.refresh)
parse_worker.start()
self.current_sync_request = None
self.search = HistoryLineEdit2(self)
self.search.initialize('tweak_book_preview_search')
self.search.setPlaceholderText(_('Search in preview'))
self.search.returnPressed.connect(partial(self.find, 'next'))
self.bar.addSeparator()
self.bar.addWidget(self.search)
for d in ('next', 'prev'):
ac = actions['find-%s-preview' % d]
ac.triggered.connect(partial(self.find, d))
self.bar.addAction(ac)
def find(self, direction):
text = unicode(self.search.text())
self.view.findText(
text, QWebPage.FindWrapsAroundDocument |
(QWebPage.FindBackward
if direction == 'prev' else QWebPage.FindFlags(0)))
def request_sync(self, tagname, href, lnum):
if self.current_name:
c = current_container()
if tagname == 'a' and href:
if href and href.startswith('#'):
name = self.current_name
else:
name = c.href_to_name(href,
self.current_name) if href else None
if name == self.current_name:
return self.view.page().go_to_anchor(
urlparse(href).fragment, lnum)
if name and c.exists(name) and c.mime_map[name] in OEB_DOCS:
return self.link_clicked.emit(
name,
urlparse(href).fragment or TOP)
self.sync_requested.emit(self.current_name, lnum)
def request_split(self, loc, totals):
if self.current_name:
self.split_requested.emit(self.current_name, loc, totals)
def sync_to_editor(self, name, sourceline_address):
self.current_sync_request = (name, sourceline_address)
QTimer.singleShot(100, self._sync_to_editor)
def _sync_to_editor(self):
if not actions['sync-preview-to-editor'].isChecked():
return
try:
if self.refresh_timer.isActive(
) or self.current_sync_request[0] != self.current_name:
return QTimer.singleShot(100, self._sync_to_editor)
except TypeError:
return # Happens if current_sync_request is None
sourceline_address = self.current_sync_request[1]
self.current_sync_request = None
self.view.page().go_to_sourceline_address(sourceline_address)
def show(self, name):
if name != self.current_name:
self.refresh_timer.stop()
self.current_name = name
parse_worker.add_request(name)
self.view.setUrl(
QUrl.fromLocalFile(current_container().name_to_abspath(name)))
return True
def refresh(self):
if self.current_name:
self.refresh_timer.stop()
# This will check if the current html has changed in its editor,
# and re-parse it if so
parse_worker.add_request(self.current_name)
# Tell webkit to reload all html and associated resources
current_url = QUrl.fromLocalFile(
current_container().name_to_abspath(self.current_name))
self.refresh_starting.emit()
if current_url != self.view.url():
# The container was changed
self.view.setUrl(current_url)
else:
self.view.refresh()
self.refreshed.emit()
def clear(self):
self.view.clear()
self.current_name = None
@property
def current_root(self):
return self.view.page().current_root
@property
def is_visible(self):
return actions['preview-dock'].isChecked()
@property
def live_css_is_visible(self):
try:
return actions['live-css-dock'].isChecked()
except KeyError:
return False
def start_refresh_timer(self):
if self.live_css_is_visible or (
self.is_visible
and actions['auto-reload-preview'].isChecked()):
self.refresh_timer.start(tprefs['preview_refresh_time'] * 1000)
def stop_refresh_timer(self):
self.refresh_timer.stop()
def auto_reload_toggled(self, checked):
if self.live_css_is_visible and not actions[
'auto-reload-preview'].isChecked():
actions['auto-reload-preview'].setChecked(True)
error_dialog(
self,
_('Cannot disable'),
_('Auto reloading of the preview panel cannot be disabled while the'
' Live CSS panel is open.'),
show=True)
actions['auto-reload-preview'].setToolTip(
_('Auto reload preview when text changes in editor'
) if not checked else _('Disable auto reload of preview'))
def sync_toggled(self, checked):
actions['sync-preview-to-editor'].setToolTip(
_('Disable syncing of preview position to editor position'
) if checked else _(
'Enable syncing of preview position to editor position'))
def visibility_changed(self, is_visible):
if is_visible:
self.refresh()
def split_toggled(self, checked):
actions['split-in-preview'].setToolTip(
textwrap.fill(
_('Abort file split') if checked else
_('Split this file at a specified location.\n\nAfter clicking this button, click'
' inside the preview panel above at the location you want the file to be split.'
)))
if checked:
self.split_start_requested.emit()
else:
self.view.page().split_mode(False)
def do_start_split(self):
self.view.page().split_mode(True)
def stop_split(self):
actions['split-in-preview'].setChecked(False)
def load_finished(self, ok):
if actions['split-in-preview'].isChecked():
if ok:
self.do_start_split()
else:
self.stop_split()
def apply_settings(self):
s = self.view.page().settings()
s.setFontSize(s.DefaultFontSize, tprefs['preview_base_font_size'])
s.setFontSize(s.DefaultFixedFontSize, tprefs['preview_mono_font_size'])
s.setFontSize(s.MinimumLogicalFontSize,
tprefs['preview_minimum_font_size'])
s.setFontSize(s.MinimumFontSize, tprefs['preview_minimum_font_size'])
sf, ssf, mf = tprefs['preview_serif_family'], tprefs[
'preview_sans_family'], tprefs['preview_mono_family']
s.setFontFamily(s.StandardFont, {
'serif': sf,
'sans': ssf,
'mono': mf,
None: sf
}[tprefs['preview_standard_font_family']])
s.setFontFamily(s.SerifFont, sf)
s.setFontFamily(s.SansSerifFont, ssf)
s.setFontFamily(s.FixedFont, mf)
def explode(self):
self.show_msg(_('Exploding, please wait...'))
if len(self.fmt_choice_buttons) > 1:
gprefs.set('last_tweak_format', self.current_format.upper())
QTimer.singleShot(5, self.do_explode)
class Main(
MainWindow,
MainWindowMixin,
DeviceMixin,
EmailMixin, # {{{
TagBrowserMixin,
CoverFlowMixin,
LibraryViewMixin,
SearchBoxMixin,
SavedSearchBoxMixin,
SearchRestrictionMixin,
LayoutMixin,
UpdateMixin,
EbookDownloadMixin):
'The main GUI'
proceed_requested = pyqtSignal(object, object)
def __init__(self, opts, parent=None, gui_debug=None):
global _gui
MainWindow.__init__(self,
opts,
parent=parent,
disable_automatic_gc=True)
self.jobs_pointer = Pointer(self)
self.proceed_requested.connect(self.do_proceed,
type=Qt.QueuedConnection)
self.proceed_question = ProceedQuestion(self)
self.job_error_dialog = JobError(self)
self.keyboard = Manager(self)
_gui = self
self.opts = opts
self.device_connected = None
self.gui_debug = gui_debug
self.iactions = OrderedDict()
# Actions
for action in interface_actions():
if opts.ignore_plugins and action.plugin_path is not None:
continue
try:
ac = self.init_iaction(action)
except:
# Ignore errors in loading user supplied plugins
import traceback
traceback.print_exc()
if action.plugin_path is None:
raise
continue
ac.plugin_path = action.plugin_path
ac.interface_action_base_plugin = action
self.add_iaction(ac)
self.load_store_plugins()
def init_iaction(self, action):
ac = action.load_actual_plugin(self)
ac.plugin_path = action.plugin_path
ac.interface_action_base_plugin = action
action.actual_iaction_plugin_loaded = True
return ac
def add_iaction(self, ac):
acmap = self.iactions
if ac.name in acmap:
if ac.priority >= acmap[ac.name].priority:
acmap[ac.name] = ac
else:
acmap[ac.name] = ac
def load_store_plugins(self):
from calibre.gui2.store.loader import Stores
self.istores = Stores()
for store in available_store_plugins():
if self.opts.ignore_plugins and store.plugin_path is not None:
continue
try:
st = self.init_istore(store)
self.add_istore(st)
except:
# Ignore errors in loading user supplied plugins
import traceback
traceback.print_exc()
if store.plugin_path is None:
raise
continue
self.istores.builtins_loaded()
def init_istore(self, store):
st = store.load_actual_plugin(self)
st.plugin_path = store.plugin_path
st.base_plugin = store
store.actual_istore_plugin_loaded = True
return st
def add_istore(self, st):
stmap = self.istores
if st.name in stmap:
if st.priority >= stmap[st.name].priority:
stmap[st.name] = st
else:
stmap[st.name] = st
def initialize(self, library_path, db, listener, actions, show_gui=True):
opts = self.opts
self.preferences_action, self.quit_action = actions
self.library_path = library_path
self.content_server = None
self.spare_servers = []
self.must_restart_before_config = False
self.listener = Listener(listener)
self.check_messages_timer = QTimer()
self.connect(self.check_messages_timer, SIGNAL('timeout()'),
self.another_instance_wants_to_talk)
self.check_messages_timer.start(1000)
for ac in self.iactions.values():
ac.do_genesis()
self.donate_action = QAction(QIcon(I('donate.png')),
_('&Donate to support calibre'), self)
for st in self.istores.values():
st.do_genesis()
MainWindowMixin.__init__(self, db)
# Jobs Button {{{
self.job_manager = JobManager()
self.jobs_dialog = JobsDialog(self, self.job_manager)
self.jobs_button = JobsButton(horizontal=True, parent=self)
self.jobs_button.initialize(self.jobs_dialog, self.job_manager)
# }}}
LayoutMixin.__init__(self)
EmailMixin.__init__(self)
EbookDownloadMixin.__init__(self)
DeviceMixin.__init__(self)
self.progress_indicator = ProgressIndicator(self)
self.progress_indicator.pos = (0, 20)
self.verbose = opts.verbose
self.get_metadata = GetMetadata()
self.upload_memory = {}
self.metadata_dialogs = []
self.default_thumbnail = None
self.tb_wrapper = textwrap.TextWrapper(width=40)
self.viewers = collections.deque()
self.system_tray_icon = SystemTrayIcon(QIcon(I('lt.png')), self)
self.system_tray_icon.setToolTip('calibre')
self.system_tray_icon.tooltip_requested.connect(
self.job_manager.show_tooltip)
if not config['systray_icon']:
self.system_tray_icon.hide()
else:
self.system_tray_icon.show()
self.system_tray_menu = QMenu(self)
self.restore_action = self.system_tray_menu.addAction(
QIcon(I('page.png')), _('&Restore'))
self.system_tray_menu.addAction(self.donate_action)
self.donate_button.setDefaultAction(self.donate_action)
self.donate_button.setStatusTip(self.donate_button.toolTip())
self.eject_action = self.system_tray_menu.addAction(
QIcon(I('eject.png')), _('&Eject connected device'))
self.eject_action.setEnabled(False)
self.addAction(self.quit_action)
self.system_tray_menu.addAction(self.quit_action)
self.keyboard.register_shortcut('quit calibre',
_('Quit calibre'),
default_keys=('Ctrl+Q', ),
action=self.quit_action)
self.system_tray_icon.setContextMenu(self.system_tray_menu)
self.connect(self.quit_action, SIGNAL('triggered(bool)'), self.quit)
self.connect(self.donate_action, SIGNAL('triggered(bool)'),
self.donate)
self.connect(self.restore_action, SIGNAL('triggered()'),
self.show_windows)
self.system_tray_icon.activated.connect(
self.system_tray_icon_activated)
self.esc_action = QAction(self)
self.addAction(self.esc_action)
self.keyboard.register_shortcut('clear current search',
_('Clear the current search'),
default_keys=('Esc', ),
action=self.esc_action)
self.esc_action.triggered.connect(self.esc)
self.shift_esc_action = QAction(self)
self.addAction(self.shift_esc_action)
self.keyboard.register_shortcut('focus book list',
_('Focus the book list'),
default_keys=('Shift+Esc', ),
action=self.shift_esc_action)
self.shift_esc_action.triggered.connect(self.shift_esc)
self.ctrl_esc_action = QAction(self)
self.addAction(self.ctrl_esc_action)
self.keyboard.register_shortcut('clear virtual library',
_('Clear the virtual library'),
default_keys=('Ctrl+Esc', ),
action=self.ctrl_esc_action)
self.ctrl_esc_action.triggered.connect(self.ctrl_esc)
self.alt_esc_action = QAction(self)
self.addAction(self.alt_esc_action)
self.keyboard.register_shortcut('clear additional restriction',
_('Clear the additional restriction'),
default_keys=('Alt+Esc', ),
action=self.alt_esc_action)
self.alt_esc_action.triggered.connect(
self.clear_additional_restriction)
####################### Start spare job server ########################
QTimer.singleShot(1000, self.add_spare_server)
####################### Location Manager ########################
self.location_manager.location_selected.connect(self.location_selected)
self.location_manager.unmount_device.connect(
self.device_manager.umount_device)
self.location_manager.configure_device.connect(
self.configure_connected_device)
self.location_manager.update_device_metadata.connect(
self.update_metadata_on_device)
self.eject_action.triggered.connect(self.device_manager.umount_device)
#################### Update notification ###################
UpdateMixin.__init__(self, opts)
####################### Search boxes ########################
SearchRestrictionMixin.__init__(self)
SavedSearchBoxMixin.__init__(self)
####################### Library view ########################
LibraryViewMixin.__init__(self, db)
SearchBoxMixin.__init__(self) # Requires current_db
if show_gui:
self.show()
if self.system_tray_icon.isVisible() and opts.start_in_tray:
self.hide_windows()
self.library_view.model().count_changed_signal.connect(
self.iactions['Choose Library'].count_changed)
if not gprefs.get('quick_start_guide_added', False):
from calibre.ebooks.metadata.meta import get_metadata
mi = get_metadata(open(P('quick_start.epub'), 'rb'), 'epub')
self.library_view.model().add_books([P('quick_start.epub')],
['epub'], [mi])
gprefs['quick_start_guide_added'] = True
self.library_view.model().books_added(1)
if hasattr(self, 'db_images'):
self.db_images.reset()
if self.library_view.model().rowCount(None) < 3:
self.library_view.resizeColumnsToContents()
for view in ('library', 'memory', 'card_a', 'card_b'):
v = getattr(self, '%s_view' % view)
v.selectionModel().selectionChanged.connect(self.update_status_bar)
v.model().count_changed_signal.connect(self.update_status_bar)
self.library_view.model().count_changed()
self.bars_manager.database_changed(self.library_view.model().db)
self.library_view.model().database_changed.connect(
self.bars_manager.database_changed, type=Qt.QueuedConnection)
########################### Tags Browser ##############################
TagBrowserMixin.__init__(self, db)
######################### Search Restriction ##########################
if db.prefs['virtual_lib_on_startup']:
self.apply_virtual_library(db.prefs['virtual_lib_on_startup'])
self.rebuild_vl_tabs()
########################### Cover Flow ################################
CoverFlowMixin.__init__(self)
self._calculated_available_height = min(max_available_height() - 15,
self.height())
self.resize(self.width(), self._calculated_available_height)
self.build_context_menus()
for ac in self.iactions.values():
try:
ac.gui_layout_complete()
except:
import traceback
traceback.print_exc()
if ac.plugin_path is None:
raise
if config['autolaunch_server']:
self.start_content_server()
self.keyboard_interrupt.connect(self.quit, type=Qt.QueuedConnection)
self.read_settings()
self.finalize_layout()
if self.bars_manager.showing_donate:
self.donate_button.start_animation()
self.set_window_title()
for ac in self.iactions.values():
try:
ac.initialization_complete()
except:
import traceback
traceback.print_exc()
if ac.plugin_path is None:
raise
self.device_manager.set_current_library_uuid(db.library_id)
self.keyboard.finalize()
self.auto_adder = AutoAdder(gprefs['auto_add_path'], self)
self.save_layout_state()
# Collect cycles now
gc.collect()
if show_gui and self.gui_debug is not None:
info_dialog(
self,
_('Debug mode'),
'<p>' +
_('You have started calibre in debug mode. After you '
'quit calibre, the debug log will be available in '
'the file: %s<p>The '
'log will be displayed automatically.') % self.gui_debug,
show=True)
self.iactions['Connect Share'].check_smartdevice_menus()
QTimer.singleShot(1, self.start_smartdevice)
def esc(self, *args):
self.clear_button.click()
def shift_esc(self):
self.current_view().setFocus(Qt.OtherFocusReason)
def ctrl_esc(self):
self.apply_virtual_library()
self.current_view().setFocus(Qt.OtherFocusReason)
def start_smartdevice(self):
message = None
if self.device_manager.get_option('smartdevice', 'autostart'):
try:
message = self.device_manager.start_plugin('smartdevice')
except:
message = 'start smartdevice unknown exception'
prints(message)
import traceback
traceback.print_exc()
if message:
if not self.device_manager.is_running('Wireless Devices'):
error_dialog(self,
_('Problem starting the wireless device'),
_('The wireless device driver did not start. '
'It said "%s"') % message,
show=True)
self.iactions['Connect Share'].set_smartdevice_action_state()
def start_content_server(self, check_started=True):
from calibre.library.server.main import start_threaded_server
from calibre.library.server import server_config
self.content_server = start_threaded_server(
self.library_view.model().db,
server_config().parse())
self.content_server.state_callback = Dispatcher(
self.iactions['Connect Share'].content_server_state_changed)
if check_started:
self.content_server.start_failure_callback = \
Dispatcher(self.content_server_start_failed)
def content_server_start_failed(self, msg):
error_dialog(self,
_('Failed to start Content Server'),
_('Could not start the content server. Error:\n\n%s') %
msg,
show=True)
def resizeEvent(self, ev):
MainWindow.resizeEvent(self, ev)
self.search.setMaximumWidth(self.width() - 150)
def add_spare_server(self, *args):
self.spare_servers.append(
Server(limit=int(config['worker_limit'] / 2.0)))
@property
def spare_server(self):
# Because of the use of the property decorator, we're called one
# extra time. Ignore.
if not hasattr(self, '__spare_server_property_limiter'):
self.__spare_server_property_limiter = True
return None
try:
QTimer.singleShot(1000, self.add_spare_server)
return self.spare_servers.pop()
except:
pass
def do_proceed(self, func, payload):
if callable(func):
func(payload)
def no_op(self, *args):
pass
def system_tray_icon_activated(self, r):
if r == QSystemTrayIcon.Trigger:
if self.isVisible():
self.hide_windows()
else:
self.show_windows()
@property
def is_minimized_to_tray(self):
return getattr(self, '__systray_minimized', False)
def ask_a_yes_no_question(self,
title,
msg,
det_msg='',
show_copy_button=False,
ans_when_user_unavailable=True,
skip_dialog_name=None,
skipped_value=True):
if self.is_minimized_to_tray:
return ans_when_user_unavailable
return question_dialog(self,
title,
msg,
det_msg=det_msg,
show_copy_button=show_copy_button,
skip_dialog_name=skip_dialog_name,
skip_dialog_skipped_value=skipped_value)
def hide_windows(self):
for window in QApplication.topLevelWidgets():
if isinstance(window, (MainWindow, QDialog)) and \
window.isVisible():
window.hide()
setattr(window, '__systray_minimized', True)
def show_windows(self):
for window in QApplication.topLevelWidgets():
if getattr(window, '__systray_minimized', False):
window.show()
setattr(window, '__systray_minimized', False)
def test_server(self, *args):
if self.content_server is not None and \
self.content_server.exception is not None:
error_dialog(self, _('Failed to start content server'),
unicode(self.content_server.exception)).exec_()
@property
def current_db(self):
return self.library_view.model().db
def another_instance_wants_to_talk(self):
try:
msg = self.listener.queue.get_nowait()
except Empty:
return
if msg.startswith('launched:'):
import json
try:
argv = json.loads(msg[len('launched:'):])
except ValueError:
prints('Failed to decode message from other instance: %r' %
msg)
if DEBUG:
error_dialog(
self,
'Invalid message',
'Received an invalid message from other calibre instance.'
' Do you have multiple versions of calibre installed?',
det_msg='Invalid msg: %r' % msg,
show=True)
argv = ()
if isinstance(argv, (list, tuple)) and len(argv) > 1:
files = [
os.path.abspath(p) for p in argv[1:]
if not os.path.isdir(p) and os.access(p, os.R_OK)
]
if files:
self.iactions['Add Books'].add_filesystem_book(files)
self.setWindowState(self.windowState() & ~Qt.WindowMinimized
| Qt.WindowActive)
self.show_windows()
self.raise_()
self.activateWindow()
elif msg.startswith('refreshdb:'):
db = self.library_view.model().db
if hasattr(db, 'new_api'):
db.new_api.reload_from_db()
self.library_view.model().resort()
else:
self.library_view.model().refresh()
self.library_view.model().research()
self.tags_view.recount()
self.library_view.model().db.refresh_format_cache()
elif msg.startswith('shutdown:'):
self.quit(confirm_quit=False)
else:
print msg
def current_view(self):
'''Convenience method that returns the currently visible view '''
idx = self.stack.currentIndex()
if idx == 0:
return self.library_view
if idx == 1:
return self.memory_view
if idx == 2:
return self.card_a_view
if idx == 3:
return self.card_b_view
def booklists(self):
return self.memory_view.model().db, self.card_a_view.model(
).db, self.card_b_view.model().db
def library_moved(self,
newloc,
copy_structure=False,
call_close=True,
allow_rebuild=False):
if newloc is None:
return
default_prefs = None
try:
olddb = self.library_view.model().db
if copy_structure:
default_prefs = olddb.prefs
from calibre.utils.formatter_functions import unload_user_template_functions
unload_user_template_functions(olddb.library_id)
except:
olddb = None
db_class, errs = get_db_loader()
try:
db = db_class(newloc, default_prefs=default_prefs)
except errs:
if not allow_rebuild:
raise
import traceback
repair = question_dialog(
self,
_('Corrupted database'),
_('The library database at %s appears to be corrupted. Do '
'you want calibre to try and rebuild it automatically? '
'The rebuild may not be completely successful.') %
force_unicode(newloc, filesystem_encoding),
det_msg=traceback.format_exc())
if repair:
from calibre.gui2.dialogs.restore_library import repair_library_at
if repair_library_at(newloc, parent=self):
db = db_class(newloc, default_prefs=default_prefs)
else:
return
else:
return
if self.content_server is not None:
self.content_server.set_database(db)
self.library_path = newloc
prefs['library_path'] = self.library_path
self.book_on_device(None, reset=True)
db.set_book_on_device_func(self.book_on_device)
self.library_view.set_database(db)
self.tags_view.set_database(db, self.alter_tb)
self.library_view.model().set_book_on_device_func(self.book_on_device)
self.status_bar.clear_message()
self.search.clear()
self.saved_search.clear()
self.book_details.reset_info()
#self.library_view.model().count_changed()
db = self.library_view.model().db
self.iactions['Choose Library'].count_changed(db.count())
self.set_window_title()
self.apply_named_search_restriction('') # reset restriction to null
self.saved_searches_changed(
recount=False) # reload the search restrictions combo box
if db.prefs['virtual_lib_on_startup']:
self.apply_virtual_library(db.prefs['virtual_lib_on_startup'])
self.rebuild_vl_tabs()
for action in self.iactions.values():
action.library_changed(db)
if olddb is not None:
try:
if call_close:
olddb.close()
except:
import traceback
traceback.print_exc()
olddb.break_cycles()
if self.device_connected:
self.set_books_in_library(self.booklists(), reset=True)
self.refresh_ondevice()
self.memory_view.reset()
self.card_a_view.reset()
self.card_b_view.reset()
self.device_manager.set_current_library_uuid(db.library_id)
self.library_view.set_current_row(0)
# Run a garbage collection now so that it does not freeze the
# interface later
gc.collect()
def set_window_title(self):
db = self.current_db
restrictions = [
x for x in (db.data.get_base_restriction_name(),
db.data.get_search_restriction_name()) if x
]
restrictions = ' :: '.join(restrictions)
font = QFont()
if restrictions:
restrictions = ' :: ' + restrictions
font.setBold(True)
font.setItalic(True)
self.virtual_library.setFont(font)
title = u'{0} - || {1}{2} ||'.format(
__appname__, self.iactions['Choose Library'].library_name(),
restrictions)
self.setWindowTitle(title)
def location_selected(self, location):
'''
Called when a location icon is clicked (e.g. Library)
'''
page = 0 if location == 'library' else 1 if location == 'main' else 2 if location == 'carda' else 3
self.stack.setCurrentIndex(page)
self.book_details.reset_info()
for x in ('tb', 'cb'):
splitter = getattr(self, x + '_splitter')
splitter.button.setEnabled(location == 'library')
for action in self.iactions.values():
action.location_selected(location)
if location == 'library':
self.virtual_library_menu.setEnabled(True)
self.highlight_only_button.setEnabled(True)
else:
self.virtual_library_menu.setEnabled(False)
self.highlight_only_button.setEnabled(False)
# Reset the view in case something changed while it was invisible
self.current_view().reset()
self.set_number_of_books_shown()
self.update_status_bar()
def job_exception(self, job, dialog_title=_('Conversion Error')):
if not hasattr(self, '_modeless_dialogs'):
self._modeless_dialogs = []
minz = self.is_minimized_to_tray
if self.isVisible():
for x in list(self._modeless_dialogs):
if not x.isVisible():
self._modeless_dialogs.remove(x)
try:
if 'calibre.ebooks.DRMError' in job.details:
if not minz:
from calibre.gui2.dialogs.drm_error import DRMErrorMessage
d = DRMErrorMessage(
self,
_('Cannot convert') + ' ' +
job.description.split(':')[-1].partition('(')[-1][:-1])
d.setModal(False)
d.show()
self._modeless_dialogs.append(d)
return
if 'calibre.ebooks.oeb.transforms.split.SplitError' in job.details:
title = job.description.split(':')[-1].partition('(')[-1][:-1]
msg = _('<p><b>Failed to convert: %s') % title
msg += '<p>' + _('''
Many older ebook reader devices are incapable of displaying
EPUB files that have internal components over a certain size.
Therefore, when converting to EPUB, calibre automatically tries
to split up the EPUB into smaller sized pieces. For some
files that are large undifferentiated blocks of text, this
splitting fails.
<p>You can <b>work around the problem</b> by either increasing the
maximum split size under EPUB Output in the conversion dialog,
or by turning on Heuristic Processing, also in the conversion
dialog. Note that if you make the maximum split size too large,
your ebook reader may have trouble with the EPUB.
''')
if not minz:
d = error_dialog(self,
_('Conversion Failed'),
msg,
det_msg=job.details)
d.setModal(False)
d.show()
self._modeless_dialogs.append(d)
return
if 'calibre.web.feeds.input.RecipeDisabled' in job.details:
if not minz:
msg = job.details
msg = msg[msg.
find('calibre.web.feeds.input.RecipeDisabled:'):]
msg = msg.partition(':')[-1]
d = error_dialog(self, _('Recipe Disabled'),
'<p>%s</p>' % msg)
d.setModal(False)
d.show()
self._modeless_dialogs.append(d)
return
if 'calibre.ebooks.conversion.ConversionUserFeedBack:' in job.details:
if not minz:
import json
payload = job.details.rpartition(
'calibre.ebooks.conversion.ConversionUserFeedBack:'
)[-1]
payload = json.loads('{' + payload.partition('{')[-1])
d = {
'info': info_dialog,
'warn': warning_dialog,
'error': error_dialog
}.get(payload['level'], error_dialog)
d = d(self,
payload['title'],
'<p>%s</p>' % payload['msg'],
det_msg=payload['det_msg'])
d.setModal(False)
d.show()
self._modeless_dialogs.append(d)
return
except:
pass
if job.killed:
return
try:
prints(job.details, file=sys.stderr)
except:
pass
if not minz:
self.job_error_dialog.show_error(dialog_title,
_('<b>Failed</b>') + ': ' +
unicode(job.description),
det_msg=job.details)
def read_settings(self):
geometry = config['main_window_geometry']
if geometry is not None:
self.restoreGeometry(geometry)
self.read_layout_settings()
def write_settings(self):
with gprefs: # Only write to gprefs once
config.set('main_window_geometry', self.saveGeometry())
dynamic.set('sort_history', self.library_view.model().sort_history)
self.save_layout_state()
def quit(self,
checked=True,
restart=False,
debug_on_restart=False,
confirm_quit=True):
if confirm_quit and not self.confirm_quit():
return
try:
self.shutdown()
except:
pass
self.restart_after_quit = restart
self.debug_on_restart = debug_on_restart
QApplication.instance().quit()
def donate(self, *args):
open_url(QUrl('http://calibre-ebook.com/donate'))
def confirm_quit(self):
if self.job_manager.has_jobs():
msg = _('There are active jobs. Are you sure you want to quit?')
if self.job_manager.has_device_jobs():
msg = '<p>'+__appname__ + \
_(''' is communicating with the device!<br>
Quitting may cause corruption on the device.<br>
Are you sure you want to quit?''')+'</p>'
if not question_dialog(self, _('Active jobs'), msg):
return False
from calibre.db.delete_service import has_jobs
if has_jobs():
msg = _('Some deleted books are still being moved to the Recycle '
'Bin, if you quit now, they will be left behind. Are you '
'sure you want to quit?')
if not question_dialog(self, _('Active jobs'), msg):
return False
return True
def shutdown(self, write_settings=True):
self.grid_view.shutdown()
try:
db = self.library_view.model().db
cf = db.clean
except:
pass
else:
cf()
# Save the current field_metadata for applications like calibre2opds
# Goes here, because if cf is valid, db is valid.
db.prefs['field_metadata'] = db.field_metadata.all_metadata()
db.commit_dirty_cache()
db.prefs.write_serialized(prefs['library_path'])
for action in self.iactions.values():
if not action.shutting_down():
return
if write_settings:
self.write_settings()
self.check_messages_timer.stop()
self.update_checker.terminate()
self.listener.close()
self.job_manager.server.close()
self.job_manager.threaded_server.close()
while self.spare_servers:
self.spare_servers.pop().close()
self.device_manager.keep_going = False
self.auto_adder.stop()
mb = self.library_view.model().metadata_backup
if mb is not None:
mb.stop()
self.hide_windows()
try:
try:
if self.content_server is not None:
s = self.content_server
self.content_server = None
s.exit()
except:
pass
except KeyboardInterrupt:
pass
from calibre.db.delete_service import shutdown
shutdown()
time.sleep(2)
self.istores.join()
self.hide_windows()
# Do not report any errors that happen after the shutdown
sys.excepthook = sys.__excepthook__
return True
def run_wizard(self, *args):
if self.confirm_quit():
self.run_wizard_b4_shutdown = True
self.restart_after_quit = True
try:
self.shutdown(write_settings=False)
except:
pass
QApplication.instance().quit()
def closeEvent(self, e):
self.write_settings()
if self.system_tray_icon.isVisible():
if not dynamic['systray_msg'] and not isosx:
info_dialog(
self,
'calibre',
'calibre ' +
_('will keep running in the system tray. To close it, '
'choose <b>Quit</b> in the context menu of the '
'system tray.'),
show_copy_button=False).exec_()
dynamic['systray_msg'] = True
self.hide_windows()
e.ignore()
else:
if self.confirm_quit():
try:
self.shutdown(write_settings=False)
except:
import traceback
traceback.print_exc()
e.accept()
else:
e.ignore()
def sync_to_editor(self, name, lnum):
self.current_sync_request = (name, lnum)
QTimer.singleShot(100, self._sync_to_editor)
class GamessJob(SimJob):
"""
A Gamess job is a setup used to run Gamess simulation.
Two ways exist to create a Gamess Job:
(1). Create a Gamess Jig.
(2). A gamess job coming from a set of existing files
in a particular location.
"""
def __init__(self, job_parms, **job_prop):
"""
To support the 2 ways of gamess job creation.
"""
name = "Gamess Job 1"
[self.job_batfile,
self.job_outputfile] = job_prop.get('job_from_file', [None, None])
if self.job_outputfile:
self.job_outputfile = self.job_outputfile.strip('"')
self.gamessJig = job_prop.get('jig', None)
if self.job_batfile:
server_id = job_parms['Server_id']
self.server = ServerManager().getServerById(int(server_id))
if not self.server:
raise ValueError, "The server of %d can't be found." % server_id
SimJob.__init__(self, name, job_parms)
self.edit_cntl = GamessProp()
#Huaicai 7/6/05: try to fix the problem when run a gamess jig coming from mmp file
#and without opening the jig property windows and save it.
if not self.__dict__.has_key('server'):
sManager = ServerManager()
self.server = sManager.getServers()[0]
return
def edit(self):
self.edit_cntl.showDialog(self)
return
def launch(
self
): # this method should probably exist in the superclass API too [bruce 071216 comment]
"""
Launch GAMESS job.
Returns: 0 = Success
1 = Cancelled
2 = Failed
"""
# Get a unique Job Id and the Job Id directory for this run.
from analysis.GAMESS.JobManager import get_job_manager_job_id_and_dir
### this causes an import cycle.
### FIX - pass in an obj providing this func? or just move this func into SimJob.py?
# [bruce 071216 comment]
job_id, job_id_dir = get_job_manager_job_id_and_dir()
self.Job_id = job_id
self.Status = 'Queued'
basename = self.gamessJig.name + "-" + self.gamessJig.gms_parms_info(
'_')
# GAMESS Job INP, OUT and BAT files.
self.job_inputfile = os.path.join(job_id_dir, "%s.inp" % basename)
self.job_outputfile = os.path.join(job_id_dir, "%s.out" % basename)
self.job_batfile = os.path.join(job_id_dir, "%s.bat" % basename)
# Write INP file (in ~/Nanorex/JobManager/Job Id subdirectory)
writegms_inpfile(self.job_inputfile, self.gamessJig)
# Create BAT file (in ~/Nanorex/JobManager/Job Id subdirectory)
## writegms_batfile(self.job_batfile, self)
# Open INP file in editor if user checked checkbox in GAMESS jig properties UI.
# if self.edit_cntl.edit_input_file_cbox.isChecked():
# open_file_in_editor(self.job_inputfile)
self.starttime = time.time() # Save the start time for this job.
# Validate Gamess Program
r = self._validate_gamess_program()
if r: # Gamess program was not valid.
return 1 # Job Cancelled.
try:
if sys.platform == 'win32': # Windows
return self._launch_pcgamess()
else: # Linux or MacOS
return self._launch_gamess()
except:
print_compact_traceback("Exception happened when run gamess")
return
def _validate_gamess_program(self):
"""
Private method:
Checks that the GAMESS program path exists in the user pref database
and that the file it points to exists. If the GAMESS path does not exist, the
user will be prompted with the file chooser to select the GAMESS executable.
This function does not check whether the GAMESS path is actually GAMESS
or if it is the correct version of GAMESS for this platform (i.e. PC GAMESS for Windows).
Returns: 0 = Valid
1 = Invalid
"""
# Get GAMESS executable path from the user preferences
prefs = preferences.prefs_context()
self.server.program = prefs.get(gmspath_prefs_key)
if not self.server.program:
msg = "The GAMESS executable path is not set.\n"
elif os.path.exists(self.server.program):
return 0
else:
msg = self.server.program + " does not exist.\n"
# GAMESS Prop Dialog is the parent for messagebox and file chooser.
parent = self.edit_cntl
ret = QMessageBox.warning(
parent, "GAMESS Executable Path", msg +
"Please select OK to set the location of GAMESS for this computer.",
"&OK", "Cancel", "", 0, 1)
if ret == 0: # OK
self.server.program = \
get_filename_and_save_in_prefs(parent, gmspath_prefs_key, "Choose GAMESS Executable")
if not self.server.program:
return 1 # Cancelled from file chooser.
# Enable GAMESS Plug-in. Mark 060112.
env.prefs[gamess_enabled_prefs_key] = True
elif ret == 1: # Cancel
return 1
return 0
def _readFromStdout(self):
"""
Slot method to read stdout of the gamess process
"""
#while self.process.canReadLineStdout():
# lineStr = str(self.process.readLineStdout()) + '\n'
# self.outputFile.write(lineStr)
bytes = self.process.readStdout()
self.outputFile.writeBlock(bytes)
return
def startFileWriting(self):
self.fwThread.start()
return
def readOutData(self):
bytes = self.process.readStdout()
if bytes:
self.fwThread.putData(bytes)
return
def processTimeout(self):
if self.process.isRunning():
if not self.progressDialog.isShown(
) or self.progressDialog.Rejected:
return
msgLabel = self.progressDialog.getMsgLabel()
duration = time.time() - self.stime
elapmsg = "Elapsed Time: " + hhmmss_str(int(duration))
msgLabel.setText(elapmsg)
####bytes = self.process.readStdout()
####if bytes:
#### self.fwThread.putData(bytes)
return
def processDone(self):
#self.fwThread.stop()
self.jobTimer.stop()
if self.process.normalExit():
print "The process is done!"
QDialog.accept(self.progressDialog)
else:
print "The process is cancelled!"
QDialog.reject(self.progressDialog)
return
def _launch_gamess(self):
oldir = os.getcwd() # Save current directory
####self.outputFile = QFile(self.job_outputfile)
####self.outputFile.open( IO_WriteOnly | IO_Append )
jobInputfile = os.path.basename(self.job_inputfile)
jobInputFile = jobInputfile[:-4]
jobOutputfile = self.job_outputfile #os.path.basename(self.job_outputfile)
### Notes: The following way to get the 'bin' works by assuming user didn't change the
### working directory after the atom runs, otherwise it will get problem.
filePath = os.path.dirname(os.path.abspath(sys.argv[0]))
program = os.path.normpath(filePath + '/../bin/rungms')
jobDir = os.path.dirname(self.job_batfile)
os.chdir(jobDir) # Change directory to the GAMESS temp directory.
# print "Current directory is: ", jobDir
executableFile = self.server.program
args = [program, jobInputFile, jobOutputfile,
executableFile] #, '01', '1']
self.process = QProcess()
for s in args:
self.process.addArgument(s)
####self.process.setCommunication(QProcess.Stdout)
print "The params for the QProcess run are: ", args
####self.fwThread = _FileWriting(self.outputFile)
self.jobTimer = QTimer(self)
self.progressDialog = JobProgressDialog(self.process, self.Calculation)
self.connect(self.process, SIGNAL('processExited ()'),
self.processDone)
#self.connect(self.process, SIGNAL('readyReadStdout()'), self.readOutData)
####self.fwThread.start()
if not self.process.start():
print "The process can't be started."
return 2
self.connect(self.jobTimer, SIGNAL('timeout()'), self.processTimeout)
self.stime = time.time()
self.jobTimer.start(1)
ret = self.progressDialog.exec_()
if ret == QDialog.Accepted:
retValue = 0
else:
retValue = 1
####self.fwThread.wait()
####bytes = self.process.readStdout()
####if bytes:
#####self.outputFile.writeBlock(bytes)
#####self.outputFile.flush()
self.process = None
####self.outputFile.close()
os.chdir(oldir)
self.gamessJig.outputfile = self.job_outputfile
return retValue
def _launch_pcgamess(self):
"""
Run PC GAMESS (Windows only).
PC GAMESS creates 2 output files:
- the DAT file, called "PUNCH", is written to the directory from which
PC GAMESS is started. This is why we chdir to the Gamess temp directory
before we run PC GAMESS.
- the OUT file (aka the log file), which we name jigname.out.
Returns: 0 = Success
1 = Cancelled
2 = Failed
"""
oldir = os.getcwd() # Save current directory
jobDir = os.path.dirname(self.job_batfile)
os.chdir(jobDir) # Change directory to the GAMESS temp directory.
## print "Current directory is: ", jobDir
DATfile = os.path.join(jobDir, "PUNCH")
if os.path.exists(DATfile): # Remove any previous DAT (PUNCH) file.
print "run_pcgamess: Removing DAT file: ", DATfile
os.remove(DATfile)
# Hours wasted testing this undocumented tripe. Here's the deal: When using spawnv
# on Windows, any args that might have spaces must be delimited by double quotes.
# Mark 050530.
#program = "\"" + self.job_batfile + "\""
#args = [program, ]
# Here's the infuriating part. The 2nd arg to spawnv cannot have double quotes, but the
# first arg in args (the program name) must have the double quotes if there is a space in
# self.gms_program.
#print "program = ", program
#print "Spawnv args are %r" % (args,) # this %r remains (see above)
#os.spawnv(os.P_WAIT, self.job_batfile, args)
arg_list = ['-i', self.job_inputfile, '-o', self.job_outputfile]
args = QStringList()
for s in arg_list:
args.append(str(s))
process = QProcess()
process.start(self.server.program, args)
# Blocks for n millisconds until the process has started and started()
# signal is emitted. Returns true if the process was started successfullly.
if not process.waitForStarted(2000):
print "The process can't be started."
return 2
progressDialog = self.showProgress()
progressDialog.show()
i = 55
pInc = True
while process.state() == QProcess.Running:
env.call_qApp_processEvents(
) #bruce 050908 replaced qApp.processEvents()
if progressDialog.wasCanceled():
process.kill()
os.chdir(oldir)
return 1 # Job cancelled.
progressDialog.setValue(i)
if pInc:
if i < 75: i += 1
else: pInc = False
else:
if i > 55: i -= 1
else: pInc = True
# Do sth here
time.sleep(0.05)
if not process.state() == QProcess.Running:
break
progressDialog.setValue(100)
progressDialog.accept()
os.chdir(oldir)
self.gamessJig.outputfile = self.job_outputfile
return 0 # Success
def showProgress(self, modal=True):
"""
Open the progress dialog to show the current job progress.
"""
#Replace "self.edit_cntl.win" with "None"
#---Huaicai 7/7/05: To fix bug 751, the "win" may be none.
#Feel awkward for the design of our code.
simProgressDialog = QProgressDialog()
simProgressDialog.setModal(True)
simProgressDialog.setObjectName("progressDialog")
simProgressDialog.setWindowIcon(geticon('ui/border/MainWindow.png'))
if self.Calculation == 'Energy':
simProgressDialog.setWindowTitle(
"Calculating Energy ...Please Wait")
else:
simProgressDialog.setWindowTitle("Optimizing ...Please Wait")
progBar = QProgressBar(simProgressDialog)
progBar.setMaximum(0)
progBar.setMinimum(0)
progBar.setValue(0)
progBar.setTextVisible(False)
simProgressDialog.setBar(progBar)
simProgressDialog.setAutoReset(False)
simProgressDialog.setAutoClose(False)
return simProgressDialog
# Added by Mark 050919 for bug #915. Not used yet.
def _job_cancelation_confirmed(self):
ret = QMessageBox.warning(
None,
"Confirm",
"Please confirm you want to abort the GAMESS simulation.\n",
"Confirm",
"Cancel",
"",
1, # The "default" button, when user presses Enter or Return (1 = Cancel)
1) # Escape (1= Cancel)
if ret == 0: # Confirmed
print "CONFIRMED"
return True
else:
print "CANCELLED"
return False
pass # end of class GamessJob
class Widget(QWidget, ScreenWidget):
name = "liveInstallation"
def __init__(self):
QWidget.__init__(self)
self.ui = Ui_InstallWidget()
self.ui.setupUi(self)
self.installProgress = InstallProgressWidget(self)
self.timer = QTimer(self)
QObject.connect(self.timer, SIGNAL("timeout()"), self.changeSlideshows)
self.poll_timer = QTimer(self)
QObject.connect(self.poll_timer, SIGNAL("timeout()"),
self.checkQueueEvent)
if ctx.consts.lang == "tr":
self.installProgress.ui.progress.setFormat("%%p")
self.iter_slideshows = iter_slideshows()
# show first pic
self.changeSlideshows()
self.total = 0
self.cur = 0
self.has_errors = False
# mutual exclusion
self.mutex = None
self.wait_condition = None
self.queue = None
self.retry_answer = False
self.sys_copier = None
def shown(self):
# Disable mouse handler
ctx.mainScreen.dontAskCmbAgain = True
ctx.mainScreen.theme_shortcut.setEnabled(False)
ctx.mainScreen.ui.system_menu.setEnabled(False)
# start installer thread
ctx.logger.debug("Copy system thread is creating...")
self.mutex = QMutex()
self.wait_condition = QWaitCondition()
self.queue = Queue()
self.sys_copier = SystemCopy(self.queue, self.mutex,
self.wait_condition, self.retry_answer)
self.poll_timer.start(500)
# start installer polling
ctx.logger.debug("Calling SystemCopy.start...")
self.sys_copier.start()
ctx.mainScreen.disableNext()
ctx.mainScreen.disableBack()
# start 30 seconds
self.timer.start(1000 * 30)
self.installProgress.showInstallProgress()
def checkQueueEvent(self):
while True:
try:
data = self.queue.get_nowait()
event = data[0]
except Empty, msg:
return
ctx.logger.debug("checkQueueEvent: Processing %s event..." % event)
# EventCopy
if event == EventCopy:
self.cur = data[1]
self.installProgress.ui.info.setText(_("Copying system"))
ctx.logger.debug("Unsquashfs system")
self.installProgress.ui.progress.setValue(self.cur)
# EventSetProgress
elif event == EventSetProgress:
total = data[1]
self.installProgress.ui.progress.setMaximum(total)
# EventCopyFinished
elif event == EventCopyFinished:
print "***EventCopyFinished called...."
self.copyFinished()
# EventError
elif event == EventError:
err = data[1]
self.installError(err)
# EventRetry
elif event == EventRetry:
package = os.path.basename(data[1])
self.timer.stop()
self.poll_timer.stop()
rc = ctx.interface.messageWindow(
_("Warning"),
_("Following error occured while "
"installing packages:"
"<b>%s</b><br><br>"
"Do you want to retry?") % package,
type="custom",
customIcon="warning",
customButtons=[_("Yes"), _("No")])
self.retry_answer = not rc
self.timer.start(1000 * 30)
self.poll_timer.start(500)
self.wait_condition.wakeAll()
# EventAllFinished
elif event == EventAllFinished:
self.finished()
def update(self):
if self.restorer.is_alive():
QTimer.singleShot(10, self.update)
else:
self.restorer.progress_callback = lambda x, y: x
self.accept()
def preview(self):
self.show_msg(_('Rebuilding, please wait...'))
QTimer.singleShot(5, self.do_preview)
