re-add accidentally deleted files
This commit is contained in:
parent
e08ec49968
commit
752571b90f
115
yomi_base/japanese/dictionary.py
Normal file
115
yomi_base/japanese/dictionary.py
Normal file
@ -0,0 +1,115 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# Copyright (C) 2013 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 operator
|
||||
import sqlite3
|
||||
|
||||
|
||||
class Dictionary:
|
||||
def __init__(self, filename, index=True):
|
||||
self.db = sqlite3.connect(filename)
|
||||
self.indices = set()
|
||||
|
||||
|
||||
def findTerm(self, text, wildcards=False):
|
||||
self.requireIndex('Vocab', 'expression')
|
||||
self.requireIndex('Vocab', 'reading')
|
||||
self.requireIndex('VocabGloss', 'vocabId')
|
||||
|
||||
cursor = self.db.cursor()
|
||||
|
||||
definitions = []
|
||||
cursor.execute('SELECT * FROM Vocab WHERE expression {0} ? OR reading=?'.format('LIKE' if wildcards else '='), (text, text))
|
||||
for vocabId, expression, reading, tags in cursor.fetchall():
|
||||
tags = tags.split()
|
||||
|
||||
cursor.execute('SELECT glossary From VocabGloss WHERE vocabId=?', (vocabId,))
|
||||
glossary = map(operator.itemgetter(0), cursor)
|
||||
|
||||
#
|
||||
# TODO: Handle addons through data.
|
||||
#
|
||||
|
||||
addons = []
|
||||
for tag in tags:
|
||||
if tag.startswith('v5') and tag != 'v5':
|
||||
addons.append('v5')
|
||||
elif tag.startswith('vs-'):
|
||||
addons.append('vs')
|
||||
|
||||
definitions.append({
|
||||
'id': vocabId,
|
||||
'expression': expression,
|
||||
'reading': reading,
|
||||
'glossary': glossary,
|
||||
'tags': tags + addons,
|
||||
'addons': addons
|
||||
})
|
||||
|
||||
return definitions
|
||||
|
||||
|
||||
def findKanji(self, text):
|
||||
assert len(text) == 1
|
||||
|
||||
self.requireIndex('Kanji', 'character')
|
||||
self.requireIndex('KanjiGloss', 'kanjiId')
|
||||
|
||||
cursor = self.db.cursor()
|
||||
|
||||
cursor.execute('SELECT * FROM Kanji WHERE character=? LIMIT 1', text)
|
||||
query = cursor.fetchone()
|
||||
if query is None:
|
||||
return
|
||||
|
||||
kanjiId, character, kunyomi, onyomi = query
|
||||
cursor.execute('SELECT glossary From KanjiGloss WHERE kanjiId=?', (kanjiId,))
|
||||
glossary = map(operator.itemgetter(0), cursor)
|
||||
|
||||
return {
|
||||
'id': kanjiId,
|
||||
'character': character,
|
||||
'kunyomi': [] if kunyomi is None else kunyomi.split(),
|
||||
'onyomi': [] if onyomi is None else onyomi.split(),
|
||||
'glossary': glossary
|
||||
}
|
||||
|
||||
|
||||
def requireIndex(self, table, column):
|
||||
name = 'index_{0}_{1}'.format(table, column)
|
||||
if not self.hasIndex(name):
|
||||
self.buildIndex(name, table, column)
|
||||
|
||||
|
||||
def buildIndex(self, name, table, column):
|
||||
cursor = self.db.cursor()
|
||||
cursor.execute('CREATE INDEX {0} ON {1}({2})'.format(name, table, column))
|
||||
self.db.commit()
|
||||
|
||||
|
||||
def hasIndex(self, name):
|
||||
if name in self.indices:
|
||||
return True
|
||||
|
||||
cursor = self.db.cursor()
|
||||
cursor.execute('SELECT * FROM sqlite_master WHERE name=?', (name,))
|
||||
if len(cursor.fetchall()) == 0:
|
||||
return False
|
||||
|
||||
self.indices.update([name])
|
||||
return True
|
||||
96
yomi_base/japanese/translate.py
Normal file
96
yomi_base/japanese/translate.py
Normal file
@ -0,0 +1,96 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# Copyright (C) 2013 Alex Yatskov
|
||||
# This module is based on Rikaichan code written by Jonathan Zarate
|
||||
#
|
||||
# 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 re
|
||||
|
||||
|
||||
class Translator:
|
||||
def __init__(self, deinflector, dictionary):
|
||||
self.deinflector = deinflector
|
||||
self.dictionary = dictionary
|
||||
|
||||
|
||||
def findTerm(self, text, wildcards=False):
|
||||
if wildcards:
|
||||
text = re.sub(u'[\*＊]', u'%', text)
|
||||
text = re.sub(u'[\?？]', u'_', text)
|
||||
|
||||
groups = {}
|
||||
for i in xrange(len(text), 0, -1):
|
||||
term = text[:i]
|
||||
|
||||
dfs = self.deinflector.deinflect(term, lambda term: [d['tags'] for d in self.dictionary.findTerm(term)])
|
||||
if dfs is None:
|
||||
continue
|
||||
|
||||
for df in dfs:
|
||||
self.processTerm(groups, **df)
|
||||
|
||||
definitions = groups.values()
|
||||
definitions = sorted(
|
||||
definitions,
|
||||
reverse=True,
|
||||
key=lambda d: (
|
||||
len(d['source']),
|
||||
'P' in d['tags'],
|
||||
-len(d['rules']),
|
||||
d['expression']
|
||||
)
|
||||
)
|
||||
|
||||
length = 0
|
||||
for result in definitions:
|
||||
length = max(length, len(result['source']))
|
||||
|
||||
return definitions, length
|
||||
|
||||
|
||||
def findKanji(self, text):
|
||||
processed = {}
|
||||
results = []
|
||||
for c in text:
|
||||
if c not in processed:
|
||||
match = self.dictionary.findKanji(c)
|
||||
if match is not None:
|
||||
results.append(match)
|
||||
processed[c] = match
|
||||
|
||||
return results
|
||||
|
||||
|
||||
def processTerm(self, groups, source, tags, rules=[], root='', wildcards=False):
|
||||
for entry in self.dictionary.findTerm(root, wildcards):
|
||||
if entry['id'] in groups:
|
||||
continue
|
||||
|
||||
matched = len(tags) == 0
|
||||
for tag in tags:
|
||||
if tag in entry['tags']:
|
||||
matched = True
|
||||
break
|
||||
|
||||
if matched:
|
||||
groups[entry['id']] = {
|
||||
'expression': entry['expression'],
|
||||
'reading': entry['reading'],
|
||||
'glossary': entry['glossary'],
|
||||
'tags': entry['tags'],
|
||||
'source': source,
|
||||
'rules': rules
|
||||
}
|
||||
78
yomi_base/preference_data.py
Normal file
78
yomi_base/preference_data.py
Normal file
@ -0,0 +1,78 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# Copyright (C) 2013 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 codecs
|
||||
import json
|
||||
import operator
|
||||
import os
|
||||
|
||||
|
||||
class Preferences(object):
|
||||
def __init__(self):
|
||||
self.filename = os.path.expanduser(u'~/.yomichan.json')
|
||||
self.defaults = os.path.join(os.path.dirname(__file__), u'defaults.json')
|
||||
self.settings = {}
|
||||
|
||||
|
||||
def __getitem__(self, name):
|
||||
return self.settings.get(name)
|
||||
|
||||
|
||||
def __setitem__(self, name, value):
|
||||
self.settings[name] = value
|
||||
|
||||
|
||||
def load(self):
|
||||
with codecs.open(self.defaults, 'rb', 'utf-8') as fp:
|
||||
self.settings = json.load(fp)
|
||||
|
||||
try:
|
||||
if os.path.exists(self.filename):
|
||||
with codecs.open(self.filename, 'rb', 'utf-8') as fp:
|
||||
self.settings.update(json.load(fp))
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
|
||||
def save(self):
|
||||
with codecs.open(self.filename, 'wb', 'utf-8') as fp:
|
||||
json.dump(self.settings, fp, indent=4, sort_keys=True)
|
||||
|
||||
|
||||
def filePosition(self, filename):
|
||||
matches = filter(lambda f: f['path'] == filename, self['recentFiles'])
|
||||
return 0 if len(matches) == 0 else matches[0]['position']
|
||||
|
||||
|
||||
def recentFiles(self):
|
||||
return map(operator.itemgetter('path'), self['recentFiles'])
|
||||
|
||||
|
||||
def updateFactTags(self, tags):
|
||||
if tags in self['tags']:
|
||||
self['tags'].remove(tags)
|
||||
self['tags'].insert(0, tags)
|
||||
|
||||
|
||||
def updateRecentFile(self, filename, position):
|
||||
self['recentFiles'] = filter(lambda f: f['path'] != filename, self['recentFiles'])
|
||||
self['recentFiles'].insert(0, {'path': filename, 'position': position})
|
||||
|
||||
|
||||
def clearRecentFiles(self):
|
||||
self['recentFiles'] = []
|
||||
226
yomi_base/preferences.py
Normal file
226
yomi_base/preferences.py
Normal file
@ -0,0 +1,226 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# Copyright (C) 2013 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/>.
|
||||
|
||||
|
||||
from PyQt4 import QtGui, QtCore
|
||||
import copy
|
||||
import gen.preferences_ui
|
||||
|
||||
|
||||
class DialogPreferences(QtGui.QDialog, gen.preferences_ui.Ui_DialogPreferences):
|
||||
def __init__(self, parent, preferences, anki):
|
||||
QtGui.QDialog.__init__(self, parent)
|
||||
self.setupUi(self)
|
||||
|
||||
self.accepted.connect(self.onAccept)
|
||||
self.buttonColorBg.clicked.connect(self.onButtonColorBgClicked)
|
||||
self.buttonColorFg.clicked.connect(self.onButtonColorFgClicked)
|
||||
self.comboBoxDeck.currentIndexChanged.connect(self.onDeckChanged)
|
||||
self.comboBoxModel.currentIndexChanged.connect(self.onModelChanged)
|
||||
self.comboFontFamily.currentFontChanged.connect(self.onFontFamilyChanged)
|
||||
self.radioButtonKanji.toggled.connect(self.onProfileChanged)
|
||||
self.radioButtonVocab.toggled.connect(self.onProfileChanged)
|
||||
self.spinFontSize.valueChanged.connect(self.onFontSizeChanged)
|
||||
self.tableFields.itemChanged.connect(self.onFieldsChanged)
|
||||
|
||||
self.preferences = preferences
|
||||
self.anki = anki
|
||||
|
||||
self.dataToDialog()
|
||||
|
||||
|
||||
def dataToDialog(self):
|
||||
self.checkCheckForUpdates.setChecked(self.preferences['checkForUpdates'])
|
||||
self.checkRememberTextContent.setChecked(self.preferences['rememberTextContent'])
|
||||
self.checkAllowEditing.setChecked(self.preferences['allowEditing'])
|
||||
self.checkLoadRecentFile.setChecked(self.preferences['loadRecentFile'])
|
||||
self.checkStripReadings.setChecked(self.preferences['stripReadings'])
|
||||
self.spinScanLength.setValue(self.preferences['scanLength'])
|
||||
self.checkEnableAnkiConnect.setChecked(self.preferences['enableAnkiConnect'])
|
||||
|
||||
self.updateSampleText()
|
||||
font = self.textSample.font()
|
||||
self.comboFontFamily.setCurrentFont(font)
|
||||
self.spinFontSize.setValue(font.pointSize())
|
||||
|
||||
if self.anki is not None:
|
||||
self.tabAnki.setEnabled(True)
|
||||
self.profiles = copy.deepcopy(self.preferences['profiles'])
|
||||
self.profileToDialog()
|
||||
|
||||
|
||||
def dialogToData(self):
|
||||
self.preferences['checkForUpdates'] = self.checkCheckForUpdates.isChecked()
|
||||
self.preferences['rememberTextContent'] = self.checkRememberTextContent.isChecked()
|
||||
self.preferences['allowEditing'] = self.checkAllowEditing.isChecked()
|
||||
self.preferences['loadRecentFile'] = self.checkLoadRecentFile.isChecked()
|
||||
self.preferences['scanLength'] = self.spinScanLength.value()
|
||||
self.preferences['stripReadings'] = self.checkStripReadings.isChecked()
|
||||
self.preferences['enableAnkiConnect'] = self.checkEnableAnkiConnect.isChecked()
|
||||
self.preferences['firstRun'] = False
|
||||
|
||||
if self.anki is not None:
|
||||
self.dialogToProfile()
|
||||
self.preferences['profiles'] = self.profiles
|
||||
|
||||
|
||||
def dialogToProfile(self):
|
||||
self.setActiveProfile({
|
||||
'deck': unicode(self.comboBoxDeck.currentText()),
|
||||
'model': unicode(self.comboBoxModel.currentText()),
|
||||
'fields': self.ankiFields()
|
||||
})
|
||||
|
||||
|
||||
def profileToDialog(self):
|
||||
profile, name = self.activeProfile()
|
||||
|
||||
deck = u'' if profile is None else profile['deck']
|
||||
model = u'' if profile is None else profile['model']
|
||||
|
||||
self.comboBoxDeck.blockSignals(True)
|
||||
self.comboBoxDeck.clear()
|
||||
self.comboBoxDeck.addItems(self.anki.deckNames())
|
||||
self.comboBoxDeck.setCurrentIndex(self.comboBoxDeck.findText(deck))
|
||||
self.comboBoxDeck.blockSignals(False)
|
||||
|
||||
self.comboBoxModel.blockSignals(True)
|
||||
self.comboBoxModel.clear()
|
||||
self.comboBoxModel.addItems(self.anki.modelNames())
|
||||
self.comboBoxModel.setCurrentIndex(self.comboBoxModel.findText(model))
|
||||
self.comboBoxModel.blockSignals(False)
|
||||
|
||||
allowedTags = {
|
||||
'vocab': ['expression', 'reading', 'glossary', 'sentence'],
|
||||
'kanji': ['character', 'onyomi', 'kunyomi', 'glossary'],
|
||||
}[name]
|
||||
|
||||
allowedTags = map(lambda t: '<strong>{' + t + '}<strong>', allowedTags)
|
||||
self.labelTags.setText('Allowed tags are {0}'.format(', '.join(allowedTags)))
|
||||
|
||||
self.updateAnkiFields()
|
||||
|
||||
|
||||
def updateSampleText(self):
|
||||
palette = self.textSample.palette()
|
||||
palette.setColor(QtGui.QPalette.Base, QtGui.QColor(self.preferences['bgColor']))
|
||||
palette.setColor(QtGui.QPalette.Text, QtGui.QColor(self.preferences['fgColor']))
|
||||
self.textSample.setPalette(palette)
|
||||
|
||||
font = self.textSample.font()
|
||||
font.setFamily(self.preferences['fontFamily'])
|
||||
font.setPointSize(self.preferences['fontSize'])
|
||||
self.textSample.setFont(font)
|
||||
|
||||
|
||||
def setAnkiFields(self, fields, fieldsPrefs):
|
||||
if fields is None:
|
||||
fields = []
|
||||
|
||||
self.tableFields.blockSignals(True)
|
||||
self.tableFields.setRowCount(len(fields))
|
||||
|
||||
for i, name in enumerate(fields):
|
||||
columns = []
|
||||
|
||||
itemName = QtGui.QTableWidgetItem(name)
|
||||
itemName.setFlags(QtCore.Qt.ItemIsSelectable)
|
||||
columns.append(itemName)
|
||||
|
||||
itemValue = QtGui.QTableWidgetItem(fieldsPrefs.get(name, u''))
|
||||
columns.append(itemValue)
|
||||
|
||||
for j, column in enumerate(columns):
|
||||
self.tableFields.setItem(i, j, column)
|
||||
|
||||
self.tableFields.blockSignals(False)
|
||||
|
||||
|
||||
def ankiFields(self):
|
||||
result = {}
|
||||
|
||||
for i in range(0, self.tableFields.rowCount()):
|
||||
itemName = unicode(self.tableFields.item(i, 0).text())
|
||||
itemValue = unicode(self.tableFields.item(i, 1).text())
|
||||
result[itemName] = itemValue
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def onAccept(self):
|
||||
self.dialogToData()
|
||||
|
||||
|
||||
def onButtonColorFgClicked(self):
|
||||
color, ok = QtGui.QColorDialog.getRgba(self.preferences['fgColor'], self)
|
||||
if ok:
|
||||
self.preferences['fgColor'] = color
|
||||
self.updateSampleText()
|
||||
|
||||
|
||||
def onButtonColorBgClicked(self):
|
||||
color, ok = QtGui.QColorDialog.getRgba(self.preferences['bgColor'], self)
|
||||
if ok:
|
||||
self.preferences['bgColor'] = color
|
||||
self.updateSampleText()
|
||||
|
||||
|
||||
def onFontFamilyChanged(self, font):
|
||||
self.preferences['fontFamily'] = unicode(font.family())
|
||||
self.updateSampleText()
|
||||
|
||||
|
||||
def onFontSizeChanged(self, size):
|
||||
self.preferences['fontSize'] = size
|
||||
self.updateSampleText()
|
||||
|
||||
|
||||
def onModelChanged(self, index):
|
||||
self.updateAnkiFields()
|
||||
self.dialogToProfile()
|
||||
|
||||
|
||||
def onDeckChanged(self, index):
|
||||
self.dialogToProfile()
|
||||
|
||||
|
||||
def onFieldsChanged(self, item):
|
||||
self.dialogToProfile()
|
||||
|
||||
|
||||
def onProfileChanged(self, data):
|
||||
self.profileToDialog()
|
||||
|
||||
|
||||
def updateAnkiFields(self):
|
||||
modelName = self.comboBoxModel.currentText()
|
||||
fieldNames = self.anki.modelFieldNames(modelName) or []
|
||||
|
||||
profile, name = self.activeProfile()
|
||||
fields = {} if profile is None else profile['fields']
|
||||
|
||||
self.setAnkiFields(fieldNames, fields)
|
||||
|
||||
|
||||
def activeProfile(self):
|
||||
name = 'vocab' if self.radioButtonVocab.isChecked() else 'kanji'
|
||||
return self.profiles.get(name), name
|
||||
|
||||
|
||||
def setActiveProfile(self, profile):
|
||||
name = 'vocab' if self.radioButtonVocab.isChecked() else 'kanji'
|
||||
self.profiles[name] = profile
|
||||
604
yomi_base/reader.py
Normal file
604
yomi_base/reader.py
Normal file
@ -0,0 +1,604 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# Copyright (C) 2013 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/>.
|
||||
|
||||
|
||||
from PyQt4 import QtGui, QtCore
|
||||
import about
|
||||
import constants
|
||||
import gen.reader_ui
|
||||
import os
|
||||
import preferences
|
||||
import reader_util
|
||||
import updates
|
||||
|
||||
|
||||
class MainWindowReader(QtGui.QMainWindow, gen.reader_ui.Ui_MainWindowReader):
|
||||
class State:
|
||||
def __init__(self):
|
||||
self.filename = u''
|
||||
self.searchText = u''
|
||||
self.kanjiDefs = []
|
||||
self.vocabDefs = []
|
||||
self.scanPosition = 0
|
||||
self.searchPosition = 0
|
||||
|
||||
|
||||
def __init__(self, parent, preferences, language, filename=None, anki=None, closed=None):
|
||||
QtGui.QMainWindow.__init__(self, parent)
|
||||
self.setupUi(self)
|
||||
|
||||
self.textContent.mouseMoveEvent = self.onContentMouseMove
|
||||
self.textContent.mousePressEvent = self.onContentMousePress
|
||||
self.dockAnki.setEnabled(anki is not None)
|
||||
|
||||
self.facts = []
|
||||
self.anki = anki
|
||||
self.closed = closed
|
||||
self.language = language
|
||||
self.preferences = preferences
|
||||
self.state = self.State()
|
||||
self.updates = updates.UpdateFinder()
|
||||
self.zoom = 0
|
||||
|
||||
self.applyPreferences()
|
||||
self.updateRecentFiles()
|
||||
self.updateVocabDefs()
|
||||
self.updateKanjiDefs()
|
||||
|
||||
if filename is not None:
|
||||
self.openFile(filename)
|
||||
elif self.preferences['rememberTextContent']:
|
||||
self.textContent.setPlainText(self.preferences['textContent'])
|
||||
elif self.preferences['loadRecentFile']:
|
||||
filenames = self.preferences.recentFiles()
|
||||
if len(filenames) > 0 and os.path.isfile(filenames[0]):
|
||||
self.openFile(filenames[0])
|
||||
|
||||
self.actionAbout.triggered.connect(self.onActionAbout)
|
||||
self.actionFind.triggered.connect(self.onActionFind)
|
||||
self.actionFindNext.triggered.connect(self.onActionFindNext)
|
||||
self.actionHomepage.triggered.connect(self.onActionHomepage)
|
||||
self.actionKindleDeck.triggered.connect(self.onActionKindleDeck)
|
||||
self.actionWordList.triggered.connect(self.onActionWordList)
|
||||
self.actionOpen.triggered.connect(self.onActionOpen)
|
||||
self.actionPreferences.triggered.connect(self.onActionPreferences)
|
||||
self.actionToggleWrap.toggled.connect(self.onActionToggleWrap)
|
||||
self.actionZoomIn.triggered.connect(self.onActionZoomIn)
|
||||
self.actionZoomOut.triggered.connect(self.onActionZoomOut)
|
||||
self.actionZoomReset.triggered.connect(self.onActionZoomReset)
|
||||
self.dockAnki.visibilityChanged.connect(self.onVisibilityChanged)
|
||||
self.dockKanji.visibilityChanged.connect(self.onVisibilityChanged)
|
||||
self.dockVocab.visibilityChanged.connect(self.onVisibilityChanged)
|
||||
self.listDefinitions.itemDoubleClicked.connect(self.onDefinitionDoubleClicked)
|
||||
self.textKanjiDefs.anchorClicked.connect(self.onKanjiDefsAnchorClicked)
|
||||
self.textKanjiSearch.returnPressed.connect(self.onKanjiDefSearchReturn)
|
||||
self.textVocabDefs.anchorClicked.connect(self.onVocabDefsAnchorClicked)
|
||||
self.textVocabSearch.returnPressed.connect(self.onVocabDefSearchReturn)
|
||||
self.updates.updateResult.connect(self.onUpdaterSearchResult)
|
||||
|
||||
if self.preferences['checkForUpdates']:
|
||||
self.updates.start()
|
||||
|
||||
|
||||
def applyPreferences(self):
|
||||
if self.preferences['windowState'] is not None:
|
||||
self.restoreState(QtCore.QByteArray.fromBase64(self.preferences['windowState']))
|
||||
if self.preferences['windowPosition'] is not None:
|
||||
self.move(QtCore.QPoint(*self.preferences['windowPosition']))
|
||||
if self.preferences['windowSize'] is not None:
|
||||
self.resize(QtCore.QSize(*self.preferences['windowSize']))
|
||||
|
||||
self.comboTags.addItems(self.preferences['tags'])
|
||||
self.applyPreferencesContent()
|
||||
|
||||
if self.preferences['firstRun']:
|
||||
QtGui.QMessageBox.information(
|
||||
self,
|
||||
'Yomichan',
|
||||
'This may be the first time you are running Yomichan.\n' \
|
||||
'Please take some time to configure this extension.'
|
||||
)
|
||||
|
||||
self.onActionPreferences()
|
||||
|
||||
|
||||
def applyPreferencesContent(self):
|
||||
palette = self.textContent.palette()
|
||||
palette.setColor(QtGui.QPalette.Base, QtGui.QColor(self.preferences['bgColor']))
|
||||
palette.setColor(QtGui.QPalette.Text, QtGui.QColor(self.preferences['fgColor']))
|
||||
self.textContent.setPalette(palette)
|
||||
|
||||
self.textContent.setReadOnly(not self.preferences['allowEditing'])
|
||||
self.textContent.setAttribute(QtCore.Qt.WA_InputMethodEnabled)
|
||||
|
||||
font = self.textContent.font()
|
||||
font.setFamily(self.preferences['fontFamily'])
|
||||
font.setPointSize(self.preferences['fontSize'] + self.zoom)
|
||||
self.textContent.setLineWrapMode(QtGui.QPlainTextEdit.WidgetWidth if self.preferences['wordWrap'] else QtGui.QPlainTextEdit.NoWrap)
|
||||
self.textContent.setFont(font)
|
||||
|
||||
self.actionToggleWrap.setChecked(self.preferences['wordWrap'])
|
||||
|
||||
|
||||
def closeEvent(self, event):
|
||||
self.closeFile()
|
||||
self.preferences['windowState'] = str(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 event.key() == QtCore.Qt.Key_Shift:
|
||||
self.updateSampleFromPosition()
|
||||
elif ord('0') <= event.key() <= ord('9'):
|
||||
index = event.key() - ord('0') - 1
|
||||
if index < 0:
|
||||
index = 9
|
||||
if event.modifiers() & QtCore.Qt.ShiftModifier:
|
||||
if event.modifiers() & QtCore.Qt.ControlModifier:
|
||||
self.executeKanjiCommand('addKanji', index)
|
||||
else:
|
||||
if event.modifiers() & QtCore.Qt.ControlModifier:
|
||||
self.executeVocabCommand('addVocabExp', index)
|
||||
if event.modifiers() & QtCore.Qt.AltModifier:
|
||||
self.executeVocabCommand('addVocabReading', index)
|
||||
elif event.key() == ord('[') and self.state.scanPosition > 0:
|
||||
self.state.scanPosition -= 1
|
||||
self.updateSampleFromPosition()
|
||||
elif event.key() == ord(']') and self.state.scanPosition < len(self.textContent.toPlainText()) - 1:
|
||||
self.state.scanPosition += 1
|
||||
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['windowPosition'] = event.pos().x(), event.pos().y()
|
||||
|
||||
|
||||
def resizeEvent(self, event):
|
||||
self.preferences['windowSize'] = 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);;All files (*.*)'
|
||||
)
|
||||
if filename:
|
||||
self.openFile(filename)
|
||||
|
||||
|
||||
def onActionKindleDeck(self):
|
||||
filename = QtGui.QFileDialog.getOpenFileName(
|
||||
parent=self,
|
||||
caption='Select a Kindle deck to import',
|
||||
filter='Deck files (*.db)'
|
||||
)
|
||||
if filename:
|
||||
words = reader_util.extractKindleDeck(filename)
|
||||
self.importWordList(words)
|
||||
|
||||
|
||||
def onActionWordList(self):
|
||||
filename = QtGui.QFileDialog.getOpenFileName(
|
||||
parent=self,
|
||||
caption='Select a word list file to import',
|
||||
filter='Text files (*.txt);;All files (*.*)'
|
||||
)
|
||||
if filename:
|
||||
words = reader_util.extractWordList(filename)
|
||||
self.importWordList(words)
|
||||
|
||||
|
||||
def onActionPreferences(self):
|
||||
dialog = preferences.DialogPreferences(self, self.preferences, self.anki)
|
||||
if dialog.exec_() == QtGui.QDialog.Accepted:
|
||||
self.applyPreferencesContent()
|
||||
|
||||
|
||||
def onActionAbout(self):
|
||||
dialog = about.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):
|
||||
self.preferences['wordWrap'] = wrap
|
||||
mode = QtGui.QPlainTextEdit.WidgetWidth if self.preferences['wordWrap'] else QtGui.QPlainTextEdit.NoWrap
|
||||
self.textContent.setLineWrapMode(mode)
|
||||
|
||||
|
||||
def onActionHomepage(self):
|
||||
url = QtCore.QUrl('https://foosoft.net/projects/yomichan')
|
||||
QtGui.QDesktopServices().openUrl(url)
|
||||
|
||||
|
||||
def onVocabDefsAnchorClicked(self, url):
|
||||
command, index = unicode(url.toString()).split(':')
|
||||
self.executeVocabCommand(command, int(index))
|
||||
|
||||
|
||||
def onKanjiDefsAnchorClicked(self, url):
|
||||
command, index = unicode(url.toString()).split(':')
|
||||
self.executeKanjiCommand(command, int(index))
|
||||
|
||||
|
||||
def onVocabDefSearchReturn(self):
|
||||
text = unicode(self.textVocabSearch.text())
|
||||
self.state.vocabDefs, length = self.language.findTerm(text, True)
|
||||
self.updateVocabDefs()
|
||||
if self.dockKanji.isVisible():
|
||||
self.state.kanjiDefs = self.language.findKanji(text)
|
||||
self.updateKanjiDefs()
|
||||
|
||||
|
||||
def onKanjiDefSearchReturn(self):
|
||||
text = unicode(self.textKanjiSearch.text())
|
||||
self.state.kanjiDefs = self.language.findKanji(text)
|
||||
self.updateKanjiDefs()
|
||||
|
||||
|
||||
def onDefinitionDoubleClicked(self, item):
|
||||
if self.anki is not None:
|
||||
row = self.listDefinitions.row(item)
|
||||
self.anki.browseNote(self.facts[row])
|
||||
|
||||
|
||||
def onVisibilityChanged(self, visible):
|
||||
self.actionToggleAnki.setChecked(self.dockAnki.isVisible())
|
||||
self.actionToggleVocab.setChecked(self.dockVocab.isVisible())
|
||||
self.actionToggleKanji.setChecked(self.dockKanji.isVisible())
|
||||
|
||||
|
||||
def onUpdaterSearchResult(self, versions):
|
||||
if versions['latest'] > constants.c['appVersion']:
|
||||
dialog = updates.DialogUpdates(self, versions)
|
||||
dialog.exec_()
|
||||
|
||||
|
||||
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):
|
||||
try:
|
||||
filename = unicode(filename)
|
||||
with open(filename) as fp:
|
||||
content = fp.read()
|
||||
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['stripReadings']:
|
||||
content = reader_util.stripReadings(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.basename(filename), encoding))
|
||||
|
||||
|
||||
def closeFile(self):
|
||||
if self.preferences['rememberTextContent']:
|
||||
self.preferences['textContent'] = unicode(self.textContent.toPlainText())
|
||||
|
||||
self.setWindowTitle('Yomichan')
|
||||
self.textContent.setPlainText(u'')
|
||||
self.updateRecentFile(False)
|
||||
self.state = self.State()
|
||||
|
||||
|
||||
def findText(self, text):
|
||||
content = unicode(self.textContent.toPlainText())
|
||||
index = content.find(unicode(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, profile, markup):
|
||||
if markup is None:
|
||||
return False
|
||||
|
||||
if self.anki is None:
|
||||
return False
|
||||
|
||||
profile = self.preferences['profiles'].get(profile)
|
||||
if profile is None:
|
||||
return False
|
||||
|
||||
fields = reader_util.formatFields(profile['fields'], 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(profile['deck'], profile['model'], fields, tagsSplit, None)
|
||||
if factId is None:
|
||||
return False
|
||||
|
||||
self.facts.append(factId)
|
||||
self.listDefinitions.addItem(markup['summary'])
|
||||
self.listDefinitions.setCurrentRow(self.listDefinitions.count() - 1)
|
||||
self.setStatus(u'Added fact {0}; {1} new fact(s) total'.format(markup['summary'], len(self.facts)))
|
||||
|
||||
self.updateVocabDefs(scroll=True)
|
||||
self.updateKanjiDefs(scroll=True)
|
||||
return True
|
||||
|
||||
|
||||
def ankiIsFactValid(self, profile, markup):
|
||||
if markup is None:
|
||||
return False
|
||||
|
||||
if self.anki is None:
|
||||
return False
|
||||
|
||||
profile = self.preferences['profiles'].get(profile)
|
||||
if profile is None:
|
||||
return False
|
||||
|
||||
fields = reader_util.formatFields(profile['fields'], markup)
|
||||
return self.anki.canAddNote(profile['deck'], profile['model'], fields)
|
||||
|
||||
|
||||
def executeVocabCommand(self, command, index):
|
||||
if index >= len(self.state.vocabDefs):
|
||||
return
|
||||
|
||||
definition = self.state.vocabDefs[index]
|
||||
if command == 'addVocabExp':
|
||||
markup = reader_util.markupVocabExp(definition)
|
||||
self.ankiAddFact('vocab', markup)
|
||||
if command == 'addVocabReading':
|
||||
markup = reader_util.markupVocabReading(definition)
|
||||
self.ankiAddFact('vocab', markup)
|
||||
elif command == 'copyVocabDef':
|
||||
reader_util.copyVocabDef(definition)
|
||||
|
||||
|
||||
def executeKanjiCommand(self, command, index):
|
||||
if index >= len(self.state.kanjiDefs):
|
||||
return
|
||||
|
||||
definition = self.state.kanjiDefs[index]
|
||||
if command == 'addKanji':
|
||||
markup = reader_util.markupKanji(definition)
|
||||
self.ankiAddFact('kanji', markup)
|
||||
elif command == 'copyKanjiDef':
|
||||
reader_util.copyKanjiDef(definition)
|
||||
|
||||
|
||||
def updateSampleMouseEvent(self, event):
|
||||
cursor = self.textContent.cursorForPosition(event.pos())
|
||||
self.state.scanPosition = cursor.position()
|
||||
if event.buttons() & QtCore.Qt.MidButton or event.modifiers() & QtCore.Qt.ShiftModifier:
|
||||
self.updateSampleFromPosition()
|
||||
|
||||
|
||||
def updateSampleFromPosition(self):
|
||||
samplePosStart = self.state.scanPosition
|
||||
samplePosEnd = self.state.scanPosition + self.preferences['scanLength']
|
||||
|
||||
content = unicode(self.textContent.toPlainText())
|
||||
contentSample = content[samplePosStart:samplePosEnd]
|
||||
contentSampleFlat = contentSample.replace(u'\n', u'')
|
||||
|
||||
cursor = self.textContent.textCursor()
|
||||
|
||||
if len(contentSampleFlat) == 0:
|
||||
cursor.clearSelection()
|
||||
self.textContent.setTextCursor(cursor)
|
||||
return
|
||||
|
||||
lengthMatched = 0
|
||||
if self.dockVocab.isVisible():
|
||||
self.state.vocabDefs, lengthMatched = self.language.findTerm(contentSampleFlat)
|
||||
sentence = reader_util.findSentence(content, samplePosStart)
|
||||
for definition in self.state.vocabDefs:
|
||||
definition['sentence'] = sentence
|
||||
self.updateVocabDefs()
|
||||
|
||||
if self.dockKanji.isVisible():
|
||||
if lengthMatched == 0:
|
||||
self.state.kanjiDefs = self.language.findKanji(contentSampleFlat[0])
|
||||
if len(self.state.kanjiDefs) > 0:
|
||||
lengthMatched = 1
|
||||
else:
|
||||
self.state.kanjiDefs = self.language.findKanji(contentSampleFlat[:lengthMatched])
|
||||
self.updateKanjiDefs()
|
||||
|
||||
lengthSelect = 0
|
||||
for c in contentSample:
|
||||
if lengthMatched <= 0:
|
||||
break
|
||||
lengthSelect += 1
|
||||
if c != u'\n':
|
||||
lengthMatched -= 1
|
||||
|
||||
cursor.setPosition(samplePosStart, QtGui.QTextCursor.MoveAnchor)
|
||||
cursor.setPosition(samplePosStart + lengthSelect, QtGui.QTextCursor.KeepAnchor)
|
||||
self.textContent.setTextCursor(cursor)
|
||||
|
||||
|
||||
def clearRecentFiles(self):
|
||||
self.preferences.clearRecentFiles()
|
||||
self.updateRecentFiles()
|
||||
|
||||
|
||||
def updateRecentFiles(self):
|
||||
self.menuOpenRecent.clear()
|
||||
|
||||
filenames = self.preferences.recentFiles()
|
||||
if len(filenames) == 0:
|
||||
return
|
||||
|
||||
for filename in filenames:
|
||||
self.menuOpenRecent.addAction(filename, lambda f=filename: self.openFile(f))
|
||||
|
||||
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 updateDefs(self, defs, builder, control, **options):
|
||||
scrollbar = control.verticalScrollBar()
|
||||
position = scrollbar.sliderPosition()
|
||||
|
||||
html = builder(defs, self.ankiIsFactValid)
|
||||
control.setHtml(html)
|
||||
|
||||
if options.get('scroll', False):
|
||||
scrollbar.setSliderPosition(position)
|
||||
|
||||
|
||||
def updateVocabDefs(self, **options):
|
||||
self.updateDefs(
|
||||
self.state.vocabDefs,
|
||||
reader_util.buildVocabDefs,
|
||||
self.textVocabDefs,
|
||||
**options
|
||||
)
|
||||
|
||||
|
||||
def updateKanjiDefs(self, **options):
|
||||
self.updateDefs(
|
||||
self.state.kanjiDefs,
|
||||
reader_util.buildKanjiDefs,
|
||||
self.textKanjiDefs,
|
||||
**options
|
||||
)
|
||||
|
||||
|
||||
def importWordList(self, words):
|
||||
self.state.vocabDefs = []
|
||||
self.state.kanjiDefs = []
|
||||
|
||||
for word in words:
|
||||
if self.dockVocab.isVisible():
|
||||
self.state.vocabDefs += self.language.dictionary.findTerm(word)
|
||||
|
||||
if self.dockKanji.isVisible():
|
||||
self.state.kanjiDefs += self.language.findKanji(word)
|
||||
|
||||
self.updateVocabDefs(scroll=True)
|
||||
self.updateKanjiDefs(scroll=True)
|
||||
|
||||
|
||||
def setStatus(self, status):
|
||||
self.statusBar.showMessage(status)
|
||||
293
yomi_base/reader_util.py
Normal file
293
yomi_base/reader_util.py
Normal file
@ -0,0 +1,293 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# Copyright (C) 2013 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/>.
|
||||
|
||||
|
||||
from PyQt4 import QtGui
|
||||
import re
|
||||
import codecs
|
||||
import sqlite3
|
||||
|
||||
|
||||
def decodeContent(content):
|
||||
encodings = ['utf-8', 'shift_jis', 'euc-jp', 'utf-16']
|
||||
errors = {}
|
||||
|
||||
for encoding in encodings:
|
||||
try:
|
||||
return content.decode(encoding), encoding
|
||||
except UnicodeDecodeError, e:
|
||||
errors[encoding] = e[2]
|
||||
|
||||
encoding = sorted(errors, key=errors.get, reverse=True)[0]
|
||||
return content.decode(encoding, 'replace'), encoding
|
||||
|
||||
|
||||
def stripReadings(content):
|
||||
return re.sub(u'《[^》]+》', u'', content)
|
||||
|
||||
|
||||
def findSentence(content, position):
|
||||
quotesFwd = {u'「': u'」', u'『': u'』', u"'": u"'", u'"': u'"'}
|
||||
quotesBwd = {u'」': u'「', u'』': u'『', u"'": u"'", u'"': u'"'}
|
||||
terminators = u'。．.？?！!'
|
||||
|
||||
quoteStack = []
|
||||
|
||||
start = 0
|
||||
for i in xrange(position, start, -1):
|
||||
c = content[i]
|
||||
|
||||
if not quoteStack and (c in terminators or c in quotesFwd or c == '\n'):
|
||||
start = i + 1
|
||||
break
|
||||
|
||||
if quoteStack and c == quoteStack[0]:
|
||||
quoteStack.pop()
|
||||
elif c in quotesBwd:
|
||||
quoteStack.insert(0, quotesBwd[c])
|
||||
|
||||
quoteStack = []
|
||||
|
||||
end = len(content)
|
||||
for i in xrange(position, end):
|
||||
c = content[i]
|
||||
|
||||
if not quoteStack:
|
||||
if c in terminators:
|
||||
end = i + 1
|
||||
break
|
||||
elif c in quotesBwd:
|
||||
end = i
|
||||
break
|
||||
|
||||
if quoteStack and c == quoteStack[0]:
|
||||
quoteStack.pop()
|
||||
elif c in quotesFwd:
|
||||
quoteStack.insert(0, quotesFwd[c])
|
||||
|
||||
return content[start:end].strip()
|
||||
|
||||
|
||||
def formatFields(fields, markup):
|
||||
result = {}
|
||||
for field, value in fields.items():
|
||||
try:
|
||||
result[field] = value.format(**markup)
|
||||
except KeyError:
|
||||
pass
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def splitTags(tags):
|
||||
return filter(lambda tag: tag.strip(), re.split('[;,\s]', tags))
|
||||
|
||||
|
||||
def markupVocabExp(definition):
|
||||
if definition['reading']:
|
||||
summary = u'{expression} [{reading}]'.format(**definition)
|
||||
else:
|
||||
summary = u'{expression}'.format(**definition)
|
||||
|
||||
return {
|
||||
'expression': definition['expression'],
|
||||
'reading': definition['reading'] or u'',
|
||||
'glossary': '; '.join(definition['glossary']),
|
||||
'sentence': definition.get('sentence'),
|
||||
'summary': summary
|
||||
}
|
||||
|
||||
|
||||
def markupVocabReading(definition):
|
||||
if definition['reading']:
|
||||
return {
|
||||
'expression': definition['reading'],
|
||||
'reading': u'',
|
||||
'glossary': '; '.join(definition['glossary']),
|
||||
'sentence': definition.get('sentence'),
|
||||
'summary': definition['reading']
|
||||
}
|
||||
|
||||
|
||||
def copyVocabDef(definition):
|
||||
glossary = '; '.join(definition['glossary'])
|
||||
if definition['reading']:
|
||||
result = u'{0}\t{1}\t{2}\n'.format(definition['expression'], definition['reading'], glossary)
|
||||
else:
|
||||
result = u'{0}\t{1}\n'.format(definition['expression'], glossary)
|
||||
|
||||
QtGui.QApplication.clipboard().setText(result)
|
||||
|
||||
|
||||
def markupKanji(definition):
|
||||
return {
|
||||
'character': definition['character'],
|
||||
'onyomi': ', '.join(definition['onyomi']),
|
||||
'kunyomi': ', '.join(definition['kunyomi']),
|
||||
'glossary': ', '.join(definition['glossary']),
|
||||
'summary': definition['character']
|
||||
}
|
||||
|
||||
|
||||
def copyKanjiDef(definition):
|
||||
result = u'{0}\t{1}\t{2}\t{3}'.format(
|
||||
definition['character'],
|
||||
', '.join(definition['kunyomi']),
|
||||
', '.join(definition['onyomi']),
|
||||
', '.join(definition['glossary'])
|
||||
)
|
||||
|
||||
QtGui.QApplication.clipboard().setText(result)
|
||||
|
||||
|
||||
def buildDefHeader():
|
||||
palette = QtGui.QApplication.palette()
|
||||
toolTipBg = palette.color(QtGui.QPalette.Window).name()
|
||||
toolTipFg = palette.color(QtGui.QPalette.WindowText).name()
|
||||
|
||||
return u'''
|
||||
<html><head><style>
|
||||
body {{ background-color: {0}; color: {1}; font-size: 11pt; }}
|
||||
span.expression {{ font-size: 15pt; }}
|
||||
</style></head><body>'''.format(toolTipBg, toolTipFg)
|
||||
|
||||
|
||||
def buildDefFooter():
|
||||
return '</body></html>'
|
||||
|
||||
|
||||
def buildEmpty():
|
||||
return u'''
|
||||
<p>No definitions to display.</p>
|
||||
<p>Mouse over text with the <em>middle mouse button</em> or <em>shift key</em> pressed to search.</p>
|
||||
<p>You can also also input terms in the search box below.'''
|
||||
|
||||
|
||||
def buildVocabDef(definition, index, query):
|
||||
reading = u''
|
||||
if definition['reading']:
|
||||
reading = u'<span class="reading">[{0}]<br></span>'.format(definition['reading'])
|
||||
|
||||
rules = u''
|
||||
if definition.get('rules'):
|
||||
rules = ' < '.join(definition['rules'])
|
||||
rules = '<span class="rules">({0})<br></span>'.format(rules)
|
||||
|
||||
links = '<a href="copyVocabDef:{0}"><img src="://img/img/icon_copy_definition.png" align="right"></a>'.format(index)
|
||||
if query is not None:
|
||||
if query('vocab', markupVocabExp(definition)):
|
||||
links += '<a href="addVocabExp:{0}"><img src="://img/img/icon_add_expression.png" align="right"></a>'.format(index)
|
||||
if query('vocab', markupVocabReading(definition)):
|
||||
links += '<a href="addVocabReading:{0}"><img src="://img/img/icon_add_reading.png" align="right"></a>'.format(index)
|
||||
|
||||
glossary = u'<ol>'
|
||||
for g in definition['glossary']:
|
||||
glossary += u'<li>{0}</li>'.format(g)
|
||||
glossary += u'</ol>'
|
||||
|
||||
expression = u'<span class="expression">'
|
||||
if 'P' in definition['tags']:
|
||||
expression += u'<strong>{}</strong>'.format(definition['expression'])
|
||||
else:
|
||||
expression += definition['expression']
|
||||
expression += u'</span>'
|
||||
|
||||
html = u'''
|
||||
<span class="links">{links}</span>
|
||||
{expression}
|
||||
<span class="reading">{reading}</span>
|
||||
<span class="rules">{rules}</span>
|
||||
<span class="glossary">{glossary}<br></span>
|
||||
<br clear="all">'''.format(
|
||||
links = links,
|
||||
expression = expression,
|
||||
reading = reading,
|
||||
glossary = glossary,
|
||||
rules = rules
|
||||
)
|
||||
|
||||
return html
|
||||
|
||||
|
||||
def buildVocabDefs(definitions, query):
|
||||
html = buildDefHeader()
|
||||
if len(definitions) > 0:
|
||||
for i, definition in enumerate(definitions):
|
||||
html += buildVocabDef(definition, i, query)
|
||||
else:
|
||||
html += buildEmpty()
|
||||
|
||||
return html + buildDefFooter()
|
||||
|
||||
|
||||
def buildKanjiDef(definition, index, query):
|
||||
links = '<a href="copyKanjiDef:{0}"><img src="://img/img/icon_copy_definition.png" align="right"></a>'.format(index)
|
||||
if query is not None and query('kanji', markupKanji(definition)):
|
||||
links += '<a href="addKanji:{0}"><img src="://img/img/icon_add_expression.png" align="right"></a>'.format(index)
|
||||
|
||||
readings = ', '.join(definition['kunyomi'] + definition['onyomi'])
|
||||
glossary = ', '.join(definition['glossary'])
|
||||
|
||||
html = u'''
|
||||
<span class="links">{links}</span>
|
||||
<span class="expression">{expression}<br></span>
|
||||
<span class="reading">[{reading}]<br></span>
|
||||
<span class="glossary">{glossary}<br></span>
|
||||
<br clear="all">'''.format(
|
||||
links = links,
|
||||
expression = definition['character'],
|
||||
reading = readings,
|
||||
glossary = glossary
|
||||
)
|
||||
|
||||
return html
|
||||
|
||||
|
||||
def buildKanjiDefs(definitions, query):
|
||||
html = buildDefHeader()
|
||||
|
||||
if len(definitions) > 0:
|
||||
for i, definition in enumerate(definitions):
|
||||
html += buildKanjiDef(definition, i, query)
|
||||
else:
|
||||
html += buildEmpty()
|
||||
|
||||
return html + buildDefFooter()
|
||||
|
||||
|
||||
def extractKindleDeck(filename):
|
||||
words = []
|
||||
|
||||
try:
|
||||
with sqlite3.connect(unicode(filename)) as db:
|
||||
for row in db.execute('select word from WORDS'):
|
||||
words.append(row[0])
|
||||
except sqlite3.OperationalError:
|
||||
pass
|
||||
|
||||
return words
|
||||
|
||||
|
||||
def extractWordList(filename):
|
||||
words = []
|
||||
|
||||
with codecs.open(unicode(filename), 'rb', 'utf-8') as fp:
|
||||
words = re.split('[;,\s]', fp.read())
|
||||
|
||||
return filter(None, words)
|
||||
72
yomi_base/updates.py
Normal file
72
yomi_base/updates.py
Normal file
@ -0,0 +1,72 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# Copyright (C) 2013 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/>.
|
||||
|
||||
|
||||
from PyQt4 import QtCore, QtGui
|
||||
import constants
|
||||
import gen.updates_ui
|
||||
import json
|
||||
import urllib2
|
||||
|
||||
|
||||
class DialogUpdates(QtGui.QDialog, gen.updates_ui.Ui_DialogUpdates):
|
||||
def __init__(self, parent, versions):
|
||||
QtGui.QDialog.__init__(self, parent)
|
||||
self.setupUi(self)
|
||||
|
||||
self.updateHtml(versions)
|
||||
self.labelUpdates.setText(
|
||||
unicode(self.labelUpdates.text()).format(
|
||||
constants.c['appVersion'],
|
||||
versions['latest']
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
def updateHtml(self, versions):
|
||||
html = '<html><body>'
|
||||
|
||||
for update in versions['updates']:
|
||||
version = update.get('version')
|
||||
if version > constants.c['appVersion']:
|
||||
html += '<strong>Version {0}</strong>'.format(version)
|
||||
html += '<ul>'
|
||||
for feature in update['features']:
|
||||
html += '<li>{0}</li>'.format(feature)
|
||||
html += '</ul>'
|
||||
|
||||
self.textBrowser.setHtml(html)
|
||||
|
||||
|
||||
class UpdateFinder(QtCore.QThread):
|
||||
updateResult = QtCore.pyqtSignal(dict)
|
||||
|
||||
def run(self):
|
||||
latest = constants.c['appVersion']
|
||||
updates = []
|
||||
|
||||
try:
|
||||
fp = urllib2.urlopen('https://foosoft.net/projects/yomichan/dl/updates.json')
|
||||
updates = json.loads(fp.read())
|
||||
fp.close()
|
||||
|
||||
for update in updates:
|
||||
latest = max(latest, update.get('version'))
|
||||
except:
|
||||
pass
|
||||
finally:
|
||||
self.updateResult.emit({'latest': latest, 'updates': updates})
|
||||
97
yomichan.py
Executable file
97
yomichan.py
Executable file
@ -0,0 +1,97 @@
|
||||
#!/usr/bin/env python2
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# Copyright (C) 2013 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/>.
|
||||
|
||||
|
||||
from PyQt4 import QtGui
|
||||
from yomi_base import japanese
|
||||
from yomi_base.anki_connect import AnkiConnect
|
||||
from yomi_base.preference_data import Preferences
|
||||
from yomi_base.reader import MainWindowReader
|
||||
import sys
|
||||
|
||||
|
||||
class Yomichan:
|
||||
def __init__(self):
|
||||
self.language = japanese.initLanguage()
|
||||
|
||||
self.preferences = Preferences()
|
||||
self.preferences.load()
|
||||
|
||||
|
||||
class YomichanPlugin(Yomichan):
|
||||
def __init__(self):
|
||||
Yomichan.__init__(self)
|
||||
|
||||
self.toolIconVisible = False
|
||||
self.window = None
|
||||
self.anki = anki_bridge.Anki()
|
||||
self.parent = self.anki.window()
|
||||
self.ankiConnect = AnkiConnect(self.anki, self.preferences)
|
||||
|
||||
separator = QtGui.QAction(self.parent)
|
||||
separator.setSeparator(True)
|
||||
self.anki.addUiAction(separator)
|
||||
|
||||
action = QtGui.QAction(QtGui.QIcon(':/img/img/icon_logo_32.png'), '&Yomichan...', self.parent)
|
||||
action.setIconVisibleInMenu(True)
|
||||
action.setShortcut('Ctrl+Y')
|
||||
action.triggered.connect(self.onShowRequest)
|
||||
self.anki.addUiAction(action)
|
||||
|
||||
|
||||
def onShowRequest(self):
|
||||
if self.window:
|
||||
self.window.setVisible(True)
|
||||
self.window.activateWindow()
|
||||
else:
|
||||
self.window = MainWindowReader(
|
||||
self.parent,
|
||||
self.preferences,
|
||||
self.language,
|
||||
None,
|
||||
self.anki,
|
||||
self.onWindowClose
|
||||
)
|
||||
self.window.show()
|
||||
|
||||
|
||||
def onWindowClose(self):
|
||||
self.window = None
|
||||
|
||||
|
||||
class YomichanStandalone(Yomichan):
|
||||
def __init__(self):
|
||||
Yomichan.__init__(self)
|
||||
|
||||
self.application = QtGui.QApplication(sys.argv)
|
||||
self.window = MainWindowReader(
|
||||
None,
|
||||
self.preferences,
|
||||
self.language,
|
||||
filename=sys.argv[1] if len(sys.argv) >= 2 else None
|
||||
)
|
||||
|
||||
self.window.show()
|
||||
self.application.exec_()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
instance = YomichanStandalone()
|
||||
else:
|
||||
from yomi_base import anki_bridge
|
||||
instance = YomichanPlugin()
|
||||
Loading…
Reference in New Issue
Block a user