577 lines
20 KiB
Python
577 lines
20 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
# Copyright (C) 2011 Alex Yatskov
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
import os
|
|
import tarfile
|
|
from PyQt4 import QtGui, QtCore, uic
|
|
from preferences import DialogPreferences
|
|
from update import UpdateFinder
|
|
from about import DialogAbout
|
|
from constants import constants
|
|
from util import buildResPath
|
|
import reader_util
|
|
|
|
|
|
class MainWindowReader(QtGui.QMainWindow):
|
|
class State:
|
|
def __init__(self):
|
|
self.filename = unicode()
|
|
self.definitions = list()
|
|
self.searchPosition = 0
|
|
self.searchText = unicode()
|
|
self.scanPosition = 0
|
|
self.archiveIndex = None
|
|
|
|
|
|
def __init__(self, parent, preferences, language, filename=None, anki=None, closed=None, updated=None):
|
|
QtGui.QMainWindow.__init__(self, parent)
|
|
uic.loadUi(buildResPath('ui/reader.ui'), self)
|
|
|
|
self.textContent.mouseMoveEvent = self.onContentMouseMove
|
|
self.textContent.mousePressEvent = self.onContentMousePress
|
|
self.dockAnki.setEnabled(bool(anki))
|
|
|
|
self.preferences = preferences
|
|
self.updateFinder = UpdateFinder()
|
|
self.state = self.State()
|
|
self.language = language
|
|
self.addedFacts = list()
|
|
self.anki = anki
|
|
self.closed = closed
|
|
self.updated = updated
|
|
self.zoom = 0
|
|
|
|
self.applyPreferences()
|
|
self.updateRecentFiles()
|
|
self.updateDefinitions()
|
|
|
|
if filename:
|
|
self.openFile(filename)
|
|
elif self.preferences.generalRecentLoad:
|
|
filenames = self.preferences.recentFiles()
|
|
if filenames:
|
|
self.openFile(filenames[0])
|
|
|
|
self.actionOpen.triggered.connect(self.onActionOpen)
|
|
self.actionPreferences.triggered.connect(self.onActionPreferences)
|
|
self.actionAbout.triggered.connect(self.onActionAbout)
|
|
self.actionZoomIn.triggered.connect(self.onActionZoomIn)
|
|
self.actionZoomOut.triggered.connect(self.onActionZoomOut)
|
|
self.actionZoomReset.triggered.connect(self.onActionZoomReset)
|
|
self.actionFind.triggered.connect(self.onActionFind)
|
|
self.actionFindNext.triggered.connect(self.onActionFindNext)
|
|
self.actionToggleWrap.toggled.connect(self.onActionToggleWrap)
|
|
self.actionCopyDefinition.triggered.connect(self.onActionCopyDefinition)
|
|
self.actionCopyAllDefinitions.triggered.connect(self.onActionCopyAllDefinitions)
|
|
self.actionCopySentence.triggered.connect(self.onActionCopySentence)
|
|
self.actionHomepage.triggered.connect(self.onActionHomepage)
|
|
self.actionFeedback.triggered.connect(self.onActionFeedback)
|
|
self.textDefinitions.anchorClicked.connect(self.onDefinitionsAnchorClicked)
|
|
self.textDefinitionSearch.returnPressed.connect(self.onDefinitionSearchReturn)
|
|
self.listDefinitions.itemDoubleClicked.connect(self.onDefinitionDoubleClicked)
|
|
self.dockDefinitions.visibilityChanged.connect(self.onVisibilityChanged)
|
|
self.dockAnki.visibilityChanged.connect(self.onVisibilityChanged)
|
|
self.updateFinder.updateResult.connect(self.onUpdaterSearchResult)
|
|
|
|
if self.preferences.generalFindUpdates:
|
|
self.updateFinder.start()
|
|
|
|
|
|
def applyPreferences(self):
|
|
if self.preferences.uiReaderState is not None:
|
|
self.restoreState(QtCore.QByteArray.fromBase64(self.preferences.uiReaderState))
|
|
if self.preferences.uiReaderPosition is not None:
|
|
self.move(QtCore.QPoint(*self.preferences.uiReaderPosition))
|
|
if self.preferences.uiReaderSize is not None:
|
|
self.resize(QtCore.QSize(*self.preferences.uiReaderSize))
|
|
|
|
self.comboTags.addItems(self.preferences.ankiTags)
|
|
self.applyPreferencesContent()
|
|
|
|
|
|
def applyPreferencesContent(self):
|
|
palette = self.textContent.palette()
|
|
palette.setColor(QtGui.QPalette.Base, QtGui.QColor(self.preferences.uiContentColorBg))
|
|
palette.setColor(QtGui.QPalette.Text, QtGui.QColor(self.preferences.uiContentColorFg))
|
|
self.textContent.setPalette(palette)
|
|
|
|
font = self.textContent.font()
|
|
font.setFamily(self.preferences.uiContentFontFamily)
|
|
font.setPointSize(self.preferences.uiContentFontSize + self.zoom)
|
|
self.textContent.setFont(font)
|
|
|
|
self.actionToggleWrap.setChecked(self.preferences.uiContentWordWrap)
|
|
|
|
|
|
def closeEvent(self, event):
|
|
self.closeFile()
|
|
self.preferences.uiReaderState = self.saveState().toBase64()
|
|
self.preferences.save()
|
|
|
|
if self.anki is not None:
|
|
self.anki.stopEditing()
|
|
|
|
if self.closed is not None:
|
|
self.closed()
|
|
|
|
|
|
def keyPressEvent(self, event):
|
|
if self.dockDefinitions.isVisible() and event.key() == QtCore.Qt.Key_Shift:
|
|
self.updateSampleFromPosition()
|
|
|
|
|
|
def dragEnterEvent(self, event):
|
|
if event.mimeData().hasUrls():
|
|
event.acceptProposedAction()
|
|
|
|
|
|
def dropEvent(self, event):
|
|
url = event.mimeData().urls()[0]
|
|
self.openFile(url.toLocalFile())
|
|
|
|
|
|
def moveEvent(self, event):
|
|
self.preferences.uiReaderPosition = (event.pos().x(), event.pos().y())
|
|
|
|
|
|
def resizeEvent(self, event):
|
|
self.preferences.uiReaderSize = (event.size().width(), event.size().height())
|
|
|
|
|
|
def onActionOpen(self):
|
|
filename = QtGui.QFileDialog.getOpenFileName(
|
|
parent=self,
|
|
caption='Select a file to open',
|
|
filter='Text files (*.txt);;Archive files (*.bz2 *.gz *.tar *.tgz);;All files (*.*)'
|
|
)
|
|
if not filename.isNull():
|
|
self.openFile(filename)
|
|
|
|
|
|
def onActionPreferences(self):
|
|
dialog = DialogPreferences(self, self.preferences, self.anki)
|
|
if dialog.exec_() == QtGui.QDialog.Accepted:
|
|
self.applyPreferencesContent()
|
|
if self.updated is not None:
|
|
self.updated()
|
|
|
|
|
|
def onActionAbout(self):
|
|
dialog = DialogAbout(self)
|
|
dialog.exec_()
|
|
|
|
|
|
def onActionZoomIn(self):
|
|
font = self.textContent.font()
|
|
if font.pointSize() < 72:
|
|
font.setPointSize(font.pointSize() + 1)
|
|
self.textContent.setFont(font)
|
|
self.zoom += 1
|
|
|
|
|
|
def onActionZoomOut(self):
|
|
font = self.textContent.font()
|
|
if font.pointSize() > 1:
|
|
font.setPointSize(font.pointSize() - 1)
|
|
self.textContent.setFont(font)
|
|
self.zoom -= 1
|
|
|
|
|
|
def onActionZoomReset(self):
|
|
if self.zoom:
|
|
font = self.textContent.font()
|
|
font.setPointSize(font.pointSize() - self.zoom)
|
|
self.textContent.setFont(font)
|
|
self.zoom = 0
|
|
|
|
|
|
def onActionFind(self):
|
|
searchText = self.state.searchText
|
|
|
|
cursor = self.textContent.textCursor()
|
|
if cursor.hasSelection():
|
|
searchText = cursor.selectedText()
|
|
|
|
searchText, ok = QtGui.QInputDialog.getText(self, 'Find', 'Search text:', text=searchText)
|
|
if searchText and ok:
|
|
self.findText(searchText)
|
|
|
|
|
|
def onActionFindNext(self):
|
|
if self.state.searchText:
|
|
self.findText(self.state.searchText)
|
|
|
|
|
|
def onActionToggleWrap(self, wrap):
|
|
mode = QtGui.QPlainTextEdit.WidgetWidth if wrap else QtGui.QPlainTextEdit.NoWrap
|
|
self.preferences.uiContentWordWrap = wrap
|
|
self.textContent.setLineWrapMode(wrap)
|
|
|
|
|
|
def onActionCopyDefinition(self):
|
|
reader_util.copyDefinitions(self.state.definitions[:1])
|
|
|
|
|
|
def onActionCopyAllDefinitions(self):
|
|
reader_util.copyDefinitions(self.state.definitions)
|
|
|
|
|
|
def onActionCopySentence(self):
|
|
content = unicode(self.textContent.toPlainText())
|
|
sentence = reader_util.findSentence(content, self.state.scanPosition)
|
|
QtGui.QApplication.clipboard().setText(sentence)
|
|
|
|
|
|
def onActionHomepage(self):
|
|
url = QtCore.QUrl(constants['urlHomepage'])
|
|
QtGui.QDesktopServices().openUrl(url)
|
|
|
|
|
|
def onActionFeedback(self):
|
|
url = QtCore.QUrl(constants['urlFeedback'])
|
|
QtGui.QDesktopServices().openUrl(url)
|
|
|
|
|
|
def onDefinitionsAnchorClicked(self, url):
|
|
command, index = unicode(url.toString()).split(':')
|
|
definition = self.state.definitions[int(index)]
|
|
|
|
if command == 'addExpression':
|
|
markup = reader_util.buildFactMarkupExpression(
|
|
definition.expression,
|
|
definition.reading,
|
|
definition.glossary,
|
|
definition.sentence
|
|
)
|
|
self.ankiAddFact(markup)
|
|
if command == 'addReading':
|
|
markup = reader_util.buildFactMarkupReading(
|
|
definition.reading,
|
|
definition.glossary,
|
|
definition.sentence
|
|
)
|
|
self.ankiAddFact(markup)
|
|
elif command == 'copyDefinition':
|
|
reader_util.copyDefinitions([definition])
|
|
|
|
|
|
def onDefinitionSearchReturn(self):
|
|
text = unicode(self.textDefinitionSearch.text())
|
|
definitions, length = self.language.wordSearch(
|
|
text,
|
|
self.preferences.searchResultMax,
|
|
self.preferences.searchGroupByExp
|
|
)
|
|
self.state.definitions = reader_util.convertDefinitions(definitions)
|
|
self.updateDefinitions()
|
|
|
|
|
|
def onDefinitionDoubleClicked(self, item):
|
|
if self.anki is not None:
|
|
row = self.listDefinitions.row(item)
|
|
self.anki.browseNote(self.addedFacts[row])
|
|
|
|
|
|
def onVisibilityChanged(self, visible):
|
|
self.actionToggleAnki.setChecked(self.dockAnki.isVisible())
|
|
self.actionToggleDefinitions.setChecked(self.dockDefinitions.isVisible())
|
|
|
|
|
|
def onUpdaterSearchResult(self, result):
|
|
if result and unicode(result) > constants['version']:
|
|
QtGui.QMessageBox.information(
|
|
self,
|
|
'Yomichan',
|
|
'A new version of Yomichan is available for download!\n\nYou can download this update ({0} > {1}) ' \
|
|
'from "Shared Plugins" in Anki or directly from the Yomichan homepage.'.format(constants['version'], result)
|
|
)
|
|
|
|
|
|
def onContentMouseMove(self, event):
|
|
QtGui.QPlainTextEdit.mouseMoveEvent(self.textContent, event)
|
|
self.updateSampleMouseEvent(event)
|
|
|
|
|
|
def onContentMousePress(self, event):
|
|
QtGui.QPlainTextEdit.mousePressEvent(self.textContent, event)
|
|
self.updateSampleMouseEvent(event)
|
|
|
|
|
|
def openFile(self, filename):
|
|
filename = unicode(filename)
|
|
try:
|
|
content = self.openFileByExtension(filename)
|
|
except IOError:
|
|
self.setStatus(u'Failed to load file {0}'.format(filename))
|
|
QtGui.QMessageBox.critical(self, 'Yomichan', 'Cannot open file for read')
|
|
return
|
|
|
|
self.closeFile()
|
|
|
|
self.state.filename = filename
|
|
self.state.scanPosition = self.preferences.filePosition(filename)
|
|
if self.state.scanPosition > len(content):
|
|
self.state.scanPosition = 0
|
|
|
|
self.updateRecentFile()
|
|
self.updateRecentFiles()
|
|
|
|
content, encoding = reader_util.decodeContent(content)
|
|
if self.preferences.generalReadingsStrip:
|
|
content = reader_util.stripContentReadings(content)
|
|
|
|
self.textContent.setPlainText(content)
|
|
if self.state.scanPosition > 0:
|
|
cursor = self.textContent.textCursor()
|
|
cursor.setPosition(self.state.scanPosition)
|
|
self.textContent.setTextCursor(cursor)
|
|
self.textContent.centerCursor()
|
|
|
|
self.setStatus(u'Loaded file {0}'.format(filename))
|
|
self.setWindowTitle(u'Yomichan - {0} ({1})'.format(os.path.split(filename)[1], encoding))
|
|
|
|
|
|
def openFileByExtension(self, filename):
|
|
self.clearArchiveFiles()
|
|
|
|
if tarfile.is_tarfile(filename):
|
|
with tarfile.open(filename, 'r:*') as tp:
|
|
files = [f for f in tp.getnames() if tp.getmember(f).isfile()]
|
|
names = [f.decode('utf-8') for f in files]
|
|
|
|
self.updateArchiveFiles(filename, names)
|
|
|
|
content = unicode()
|
|
if len(files) == 1:
|
|
fp = tp.extractfile(files[0])
|
|
content = fp.read()
|
|
fp.close()
|
|
elif len(files) > 1:
|
|
index, ok = self.selectFileName(names)
|
|
if ok:
|
|
fp = tp.extractfile(files[index])
|
|
content = fp.read()
|
|
fp.close()
|
|
self.state.archiveIndex = index
|
|
else:
|
|
self.state.archiveIndex = None
|
|
with open(filename, 'rb') as fp:
|
|
content = fp.read()
|
|
|
|
return content
|
|
|
|
|
|
def selectFileName(self, names):
|
|
if self.state.archiveIndex is not None:
|
|
return self.state.archiveIndex, True
|
|
|
|
item, ok = QtGui.QInputDialog.getItem(
|
|
self,
|
|
'Yomichan',
|
|
'Select file to open:',
|
|
self.formatQStringList(names),
|
|
current = 0,
|
|
editable=False
|
|
)
|
|
|
|
index, success = self.getItemIndex(item)
|
|
return index - 1, ok and success
|
|
|
|
|
|
def getItemIndex(self, item):
|
|
return item.split('.').first().toInt()
|
|
|
|
|
|
def formatQStringList(self, list):
|
|
return [self.formatQString(i, x) for i, x in enumerate(list)]
|
|
|
|
|
|
def formatQString(self, index, item):
|
|
return QtCore.QString(str(index + 1) + '. ').append(QtCore.QString(item))
|
|
|
|
|
|
def closeFile(self):
|
|
self.setWindowTitle('Yomichan')
|
|
self.textContent.setPlainText(unicode())
|
|
self.updateRecentFile(False)
|
|
self.state = self.State()
|
|
|
|
|
|
def findText(self, text):
|
|
content = self.textContent.toPlainText()
|
|
index = content.indexOf(text, self.state.searchPosition)
|
|
|
|
if index == -1:
|
|
wrap = self.state.searchPosition != 0
|
|
self.state.searchPosition = 0
|
|
if wrap:
|
|
self.findText(text)
|
|
else:
|
|
QtGui.QMessageBox.information(self, 'Yomichan', 'Search text not found')
|
|
else:
|
|
self.state.searchPosition = index + len(text)
|
|
cursor = self.textContent.textCursor()
|
|
cursor.setPosition(index, QtGui.QTextCursor.MoveAnchor)
|
|
cursor.setPosition(self.state.searchPosition, QtGui.QTextCursor.KeepAnchor)
|
|
self.textContent.setTextCursor(cursor)
|
|
|
|
self.state.searchText = text
|
|
|
|
|
|
def ankiAddFact(self, markup):
|
|
if self.anki is None:
|
|
return False
|
|
|
|
fields = reader_util.replaceMarkupInFields(self.preferences.ankiFields, markup)
|
|
tagsSplit = reader_util.splitTags(unicode(self.comboTags.currentText()))
|
|
tagsJoined = ' '.join(tagsSplit)
|
|
|
|
tagIndex = self.comboTags.findText(tagsJoined)
|
|
if tagIndex > 0:
|
|
self.comboTags.removeItem(tagIndex)
|
|
if tagIndex != 0:
|
|
self.comboTags.insertItem(0, tagsJoined)
|
|
self.preferences.updateFactTags(tagsJoined)
|
|
|
|
factId = self.anki.addNote(self.preferences.ankiDeck, self.preferences.ankiModel, fields, tagsSplit)
|
|
if factId is None:
|
|
return False
|
|
|
|
expression, reading = markup['%e'], markup['%r']
|
|
summary = expression
|
|
if reading:
|
|
summary = u'{0} [{1}]'.format(expression, reading)
|
|
|
|
self.addedFacts.append(factId)
|
|
self.listDefinitions.addItem(summary)
|
|
self.listDefinitions.setCurrentRow(self.listDefinitions.count() - 1)
|
|
self.setStatus(u'Added expression {0}; {1} new fact(s) total'.format(expression, len(self.addedFacts)))
|
|
|
|
self.updateDefinitions()
|
|
return True
|
|
|
|
|
|
def ankiIsFactValid(self, markup):
|
|
if self.anki is None:
|
|
return False
|
|
|
|
fields = reader_util.replaceMarkupInFields(self.preferences.ankiFields, markup)
|
|
return self.anki.canAddNote(self.preferences.ankiDeck, self.preferences.ankiModel, fields)
|
|
|
|
|
|
def updateSampleMouseEvent(self, event):
|
|
cursor = self.textContent.cursorForPosition(event.pos())
|
|
self.state.scanPosition = cursor.position()
|
|
requested = event.buttons() & QtCore.Qt.MidButton or event.modifiers() & QtCore.Qt.ShiftModifier
|
|
if self.dockDefinitions.isVisible() and requested:
|
|
self.updateSampleFromPosition()
|
|
|
|
|
|
def updateSampleFromPosition(self):
|
|
samplePosStart = self.state.scanPosition
|
|
samplePosEnd = self.state.scanPosition + self.preferences.searchScanMax
|
|
|
|
cursor = self.textContent.textCursor()
|
|
content = unicode(self.textContent.toPlainText())
|
|
contentSample = content[samplePosStart:samplePosEnd]
|
|
|
|
if not contentSample or unicode.isspace(contentSample[0]):
|
|
cursor.clearSelection()
|
|
self.textContent.setTextCursor(cursor)
|
|
return
|
|
|
|
contentSampleFlat = contentSample.replace('\n', unicode())
|
|
definitionsMatched, lengthMatched = self.language.wordSearch(
|
|
contentSampleFlat,
|
|
self.preferences.searchResultMax,
|
|
self.preferences.searchGroupByExp
|
|
)
|
|
sentence = reader_util.findSentence(content, samplePosStart)
|
|
|
|
self.state.definitions = reader_util.convertDefinitions(definitionsMatched, sentence)
|
|
self.updateDefinitions()
|
|
|
|
lengthSelect = 0
|
|
if lengthMatched:
|
|
for c in contentSample:
|
|
lengthSelect += 1
|
|
if c != '\n':
|
|
lengthMatched -= 1
|
|
if lengthMatched <= 0:
|
|
break
|
|
|
|
cursor.setPosition(samplePosStart, QtGui.QTextCursor.MoveAnchor)
|
|
cursor.setPosition(samplePosStart + lengthSelect, QtGui.QTextCursor.KeepAnchor)
|
|
self.textContent.setTextCursor(cursor)
|
|
|
|
|
|
def clearArchiveFiles(self):
|
|
self.menuOpenArchive.clear()
|
|
self.menuOpenArchive.setEnabled(False)
|
|
|
|
|
|
def updateArchiveFiles(self, filename, names):
|
|
self.menuOpenArchive.setEnabled(True)
|
|
for name in self.formatQStringList(names):
|
|
index, ok = self.getItemIndex(name)
|
|
if ok:
|
|
index = index - 1
|
|
self.menuOpenArchive.addAction(name, lambda fn=filename, idx=index: self.openFileInArchive(fn, idx))
|
|
else:
|
|
self.menuOpenArchive.addAction(name, lambda fn=filename: self.openFile(fn))
|
|
|
|
|
|
def openFileInArchive(self, filename, index):
|
|
self.state.scanPosition = 0
|
|
self.state.archiveIndex = index
|
|
self.openFile(filename)
|
|
|
|
|
|
def clearRecentFiles(self):
|
|
self.preferences.clearRecentFiles()
|
|
self.updateRecentFiles()
|
|
|
|
|
|
def updateRecentFiles(self):
|
|
self.menuOpenRecent.clear()
|
|
|
|
filenames = self.preferences.recentFiles()
|
|
if not filenames:
|
|
return
|
|
|
|
for filename in filenames:
|
|
self.menuOpenRecent.addAction(filename, lambda fn=filename: self.openFile(fn))
|
|
|
|
self.menuOpenRecent.addSeparator()
|
|
self.menuOpenRecent.addAction('Clear file history', self.clearRecentFiles)
|
|
|
|
|
|
def updateRecentFile(self, addIfNeeded=True):
|
|
if self.state.filename:
|
|
if addIfNeeded or self.state.filename in self.preferences.recentFiles():
|
|
self.preferences.updateRecentFile(self.state.filename, self.state.scanPosition)
|
|
|
|
|
|
def updateDefinitions(self):
|
|
html = reader_util.buildDefinitionsHtml(self.state.definitions, self.ankiIsFactValid)
|
|
self.textDefinitions.setHtml(html)
|
|
|
|
|
|
def setStatus(self, status):
|
|
self.statusBar.showMessage(status)
|