class CardStats(object):
def __init__(self, mw):
self.mw = mw
self.shown = False
addHook("showQuestion", self._update)
addHook("deckClosing", self.hide)
addHook("reviewCleanup", self.hide)
def show(self):
if not self.shown:
self.web = AnkiWebView(self.mw)
self.web.setMaximumWidth(400)
self.shown = self.mw.addDockable(_("Card Info"), self.web)
self.shown.connect(self.shown, SIGNAL("visibilityChanged(bool)"),
self._visChange)
self._update()
def hide(self):
if self.shown:
self.mw.rmDockable(self.shown)
self.shown = None
def _visChange(self, vis):
if not vis:
# schedule removal for after evt has finished
self.mw.progress.timer(100, self.hide, False)
def _update(self):
if not self.shown:
return
txt = ""
r = self.mw.reviewer
d = self.mw.deck
if r.card:
txt += _("<h1>Current</h1>")
txt += d.cardStats(r.card)
lc = r.lastCard()
if lc:
txt += _("<h1>Last</h1>")
txt += d.cardStats(lc)
if not txt:
txt = _("No current card or last card.")
self.web.setHtml("""
<html><head>
<style>table { font-size: 12px; } h1 { font-size: 14px; }</style>
</head><body><center>%s</center></body></html>"""%txt)
class CardStats(object):
def __init__(self, mw):
self.mw = mw
self.shown = False
addHook("showQuestion", self._update)
addHook("deckClosing", self.hide)
addHook("reviewCleanup", self.hide)
def show(self):
if not self.shown:
self.web = AnkiWebView(self.mw)
self.web.setMaximumWidth(400)
self.shown = self.mw.addDockable(_("Card Info"), self.web)
self.shown.connect(self.shown, SIGNAL("visibilityChanged(bool)"),
self._visChange)
self._update()
def hide(self):
if self.shown:
self.mw.rmDockable(self.shown)
self.shown = None
def _visChange(self, vis):
if not vis:
# schedule removal for after evt has finished
self.mw.progress.timer(100, self.hide, False)
def _update(self):
if not self.shown:
return
txt = ""
r = self.mw.reviewer
d = self.mw.deck
if r.card:
txt += _("<h1>Current</h1>")
txt += d.cardStats(r.card)
lc = r.lastCard()
if lc:
txt += _("<h1>Last</h1>")
txt += d.cardStats(lc)
if not txt:
txt = _("No current card or last card.")
self.web.setHtml("""
<html><head>
<style>table { font-size: 12px; } h1 { font-size: 14px; }</style>
</head><body><center>%s</center></body></html>""" % txt)
class KanjiGridAuto:
def __init__(self, mw):
if mw:
self.menuAction = QAction("Generate Kanji Grid Automatic", mw)
self.menuAction.triggered.connect(self.setup)
mw.form.menuTools.addSeparator()
mw.form.menuTools.addAction(self.menuAction)
def generate(self, units, timeNow, autoModTime, saveMode=False):
#deckname = mw.col.decks.name(self.did).rsplit('::',1)[-1]
if saveMode: cols = _wide
else: cols = _thin
self.html = "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\"/>\n"
self.html += "<html><head><title>Anki Kanji Grid</title></head><body bgcolor=\"#FFF\">\n"
#self.html += "<span style=\"font-size: 3em;color: #888;\">Kanji Grid - %s</span><br>\n" % deckname
self.html += "<span style=\"font-size: 3em;color: #888;\">Kanji Grid - " + autoModTime + "</span><br>\n"
self.html += "<div style=\"margin-bottom: 24pt;padding: 20pt;\"><p style=\"float: left\">Key:</p>"
self.html += "<style type=\"text/css\">table {font-size:16px; font-family:meiryo;}" + \
".key{display:inline-block;width:3em;}a,a:visited{color:#000;text-decoration:none;}</style>"
self.html += "<p style=\"float: right\">Weak "
for c in [n / 6.0 for n in range(6 + 1)]:
self.html += "<span class=\"key\" style=\"background-color: %s;\"> </span>" % hsvrgbstr(
c / 2)
self.html += " Strong</p></div>\n"
self.html += "<div style=\"clear: both;\"><br><hr style=\"border-style: dashed;border-color: #666;width: 60%;\"><br></div>\n"
self.html += "<center>\n"
if _group in (0, 1, 2):
if _group == 0:
_grades = _jlpt
elif _group == 1:
_grades = _jouyou
elif _group == 2:
_grades = _kanken
gc = 0
kanji = list([u.value for u in list(units.values())])
for i in range(1, len(_grades)):
self.html += "<h2 style=\"color:#888;\">%s Kanji</h2>\n" % _grades[
i][0]
table = "<table width='85%'><tr>\n"
count = -1
for unit in [units[c] for c in _grades[i][1] if c in kanji]:
if unit.count != 0 or _unseen:
score = "NaN"
count += 1
if count % cols == 0 and count != 0:
table += "</tr>\n<tr>\n"
if unit.count != 0:
bgcolour = hsvrgbstr(
scoreAdjust(unit.avg_interval / _interval) / 2)
else:
bgcolour = "#FFF"
if _tooltips:
tooltip = "Character: %s | Count: %s | " % (
unicodedata.name(unit.value), unit.count)
tooltip += "Avg Interval: %s | Score: %s | " % (
unit.avg_interval, score)
tooltip += "Background: %s | Index: %s" % (
bgcolour, count)
table += "\t<td align=center valign=top style=\"background:%s;\" title=\"%s\">" % (
bgcolour, tooltip)
else:
table += "\t<td align=center valign=top style=\"background:%s;\">" % (
bgcolour)
table += "<a href=\"http://jisho.org/kanji/details/%s\">%s</a></td>\n" % (
2 * (unit.value, ))
table += "</tr></table>\n"
n = count + 1
t = len(_grades[i][1])
gc += n
if _unseen:
table += "<details><summary>Missing kanji</summary><table style=\"max-width:75%;\"><tr>\n"
count = -1
for char in [c for c in _grades[i][1] if c not in kanji]:
score = "NaN"
count += 1
if count % cols == 0: table += "</tr>\n<tr>\n"
if _tooltips:
tooltip = "Character: %s" % (
unicodedata.name(char))
table += "\t<td align=center valign=top style=\"background:#EEE;color:#FFF;\" title=\"%s\">" % (
tooltip)
else:
table += "\t<td align=center valign=top style=\"background:#EEE;color:#FFF;\">"
table += "<a href=\"http://jisho.org/kanji/details/%s\" style=\"color:#888;\">%s</a></td>\n" % (
2 * (char, ))
if count == -1:
table += "<strong style=\"color:#CCC\">None</strong>"
table += "</tr></table></details>\n"
self.html += "<h4 style=\"color:#888;\">%d of %d - %0.2f%%</h4>\n" % (
n, t, n * 100.0 / t)
self.html += table
chars = reduce(lambda x, y: x + y, list(dict(_grades).values()))
self.html += "<h2 style=\"color:#888;\">%s Kanji</h2>" % _grades[
0][0]
table = "<table width='85%'><tr>\n"
count = -1
for unit in [
u for u in list(units.values()) if u.value not in chars
]:
if unit.count != 0 or _unseen:
score = "NaN"
count += 1
if count % cols == 0 and count != 0:
table += "</tr>\n<tr>\n"
if unit.count != 0:
bgcolour = hsvrgbstr(
scoreAdjust(unit.avg_interval / _interval) / 2)
else:
bgcolour = "#FFF"
if _tooltips:
tooltip = "Character: %s | Count: %s | " % (
unicodedata.name(unit.value), unit.count)
tooltip += "Avg Interval: %s | Score: %s | " % (
unit.avg_interval, score)
tooltip += "Background: %s | Index: %s" % (bgcolour,
count)
table += "\t<td align=center valign=top style=\"background:%s;\" title=\"%s\">" % (
bgcolour, tooltip)
else:
table += "\t<td align=center valign=top style=\"background:%s;\">" % (
bgcolour)
table += "<a href=\"http://www.csse.monash.edu.au/~jwb/cgi-bin/wwwjdic.cgi?1MMJ%s\">%s</a></td>\n" % (
2 * (unit.value, ))
table += "</tr></table>\n"
n = count + 1
self.html += "<h4 style=\"color:#888;\">%d of %d - %0.2f%%</h4>\n" % (
n, gc, 0 if gc == 0 else n * 100.0 / gc)
self.html += table
else:
table = "<table width='85%'><tr>\n"
if _group == 3: # Order found
unitsList = sorted(list(units.values()),
key=lambda unit: (unit.idx, unit.count))
if _group == 4: # Unicode index
unitsList = sorted(list(units.values()),
key=lambda unit:
(unicodedata.name(unit.value), unit.count))
if _group == 5: # Character score
unitsList = sorted(
list(units.values()),
key=lambda unit:
(scoreAdjust(unit.avg_interval / _interval), unit.count),
reverse=True)
if _group == 6: # Deck frequency
unitsList = sorted(
list(units.values()),
key=lambda unit:
(unit.count, scoreAdjust(unit.avg_interval / _interval)),
reverse=True)
count = -1
for unit in unitsList:
if unit.count != 0 or _unseen:
score = "NaN"
count += 1
if count % cols == 0 and count != 0:
table += "</tr>\n<tr>\n"
if unit.count != 0:
bgcolour = hsvrgbstr(
scoreAdjust(unit.avg_interval / _interval) / 2)
else:
bgcolour = "#FFF"
if _tooltips:
tooltip = "Character: %s | Count: %s | " % (
unicodedata.name(unit.value), unit.count)
tooltip += "Avg Interval: %s | Score: %s | " % (
unit.avg_interval, score)
tooltip += "Background: %s | Index: %s" % (bgcolour,
count)
table += "\t<td align=center valign=top style=\"background:%s;\" title=\"%s\">" % (
bgcolour, tooltip)
else:
table += "\t<td align=center valign=top style=\"background:%s;\">" % (
bgcolour)
table += "<a href=\"http://www.csse.monash.edu.au/~jwb/cgi-bin/wwwjdic.cgi?1MMJ%s\">%s</a></td>\n" % (
2 * (unit.value, ))
table += "</tr></table>\n"
self.html += "<h4 style=\"color:#888;\">%d total unique kanji</h4>\n" % (
count + 1)
self.html += table
self.html += "</center></body></html>\n"
def displaygrid(self, units, timeNow):
autoModTime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
currentTimeTemp = autoModTime.replace(":", "")
currentTime = currentTimeTemp.replace(" ", "-")
self.generate(units, timeNow, autoModTime)
self.win = QDialog(mw)
self.wv = AnkiWebView()
self.wv.setHtml(self.html)
self.wv.show()
#self.savepng(currentTime)
return 0
def savepng(self, currentTime):
global _filePathBase
mw.progress.start(immediate=True)
folder = ""
if _group == 0:
folder = "Sorted_by_jlpt/"
elif _group == 1:
folder = "Sorted_by_jouyou/"
elif _group == 2:
folder = "Sorted_by_kanken/"
elif _group == 3:
folder = "Sorted_by_order_found/"
elif _group == 4:
folder = "Sorted_by_unicode/"
elif _group == 5:
folder = "Sorted_by_score/"
elif _group == 6:
folder = "Sorted_by_frequency_in_decks/"
if (_filePathBase[-1:]) != "/": _filePathBase += "/"
filePath = _filePathBase + folder
if not os.path.exists(filePath):
os.makedirs(filePath)
fileName = filePath + currentTime + ".png"
image = QImage(self.wv.size(), QImage.Format_ARGB32)
#Actually make/render the image
painter = QPainter(image)
self.wv.render(painter)
painter.end()
image.save(fileName, "png")
mw.progress.finish()
return
def kanjigridAuto(self):
#self.did = mw.col.conf['curDeck']
#dids = [self.did]
#for name, id in mw.col.decks.children(self.did):
#dids.append(id)
#cids = mw.col.db.list("select id from cards where did in %s or odid in %s" % (ids2str(dids),ids2str(dids)))
cids = mw.col.db.list("select id from cards")
units = dict()
notes = dict()
timeNow = time.time()
for id, i in enumerate(cids):
card = mw.col.getCard(i)
if card.nid not in list(notes.keys()):
keys = list(card.note().keys())
unitKey = None
matches = None
if _literal:
matches = operator.eq
else:
matches = operator.contains
for keyword in _pattern:
for s, key in ((key.lower(), key) for key in keys):
if matches(s.lower(), keyword):
unitKey = card.note()[key]
break
notes[card.nid] = unitKey
else:
unitKey = notes[card.nid]
if unitKey != None:
for ch in unitKey:
addUnitData(units, ch, i, card, timeNow)
return units, timeNow
def makegrid(self):
global _group
(units, timeNow) = self.kanjigridAuto()
howManySorts = len(_chosenSortingMethods)
for i in range(howManySorts):
_group = _sortingMethods.index(
_chosenSortingMethods[i]
) #Only sets group equal to the index of the chosen sorting methods
if units is not None:
self.displaygrid(units, timeNow)
def setup(self):
global _pattern, _literal
global _interval, _thin, _wide
global _group, _unseen, _tooltips
swin = QDialog(mw)
#_pattern = _pattern.lower() #all fields are made lowercase before checking, so this should be lowercase too
for i in range(len(_pattern)):
_pattern[i] = _pattern[i].lower()
mw.progress.start(immediate=True)
#_pattern = field.text().lower().split()
self.makegrid()
mw.progress.finish()
class VocabularyProfile(GenericProfile):
name = "vocabulary"
displayedName = "Vocabulary"
descriptor = "VOCABULARY IN THIS TEXT (EXPORT)"
languages = ["japanese","chinese","korean"]
sortIndex = 1
allowedTags = ['expression', 'term', 'source', 'kanji', 'hanja', 'reading', 'glossary', 'sentence','line','filename','summary','traditional','language','goo','defs','refs']
def __init__(self,reader):
GenericProfile.__init__(self,reader)
self.history = []
self.currentIndex = 0
self.dockVocab = QtGui.QDockWidget(reader)
self.dockVocab.setObjectName(fromUtf8("dockVocab"))
self.dockWidgetContents = QtGui.QWidget()
self.dockWidgetContents.setObjectName(fromUtf8("dockWidgetContents"))
self.verticalLayout = QtGui.QVBoxLayout(self.dockWidgetContents)
self.verticalLayout.setObjectName(fromUtf8("verticalLayout"))
self.previousExpression = None
self.textField = AnkiWebView()
self.textField.setAcceptDrops(False)
self.textField.setObjectName("textField")
self.keyFilter = VocabKeyFilter()
self.keyFilter.obj = self
self.keyFilter.textField = self.textField
self.textField.installEventFilter(self.keyFilter)
self.verticalLayout.addWidget(self.textField)
self.dockVocab.setWidget(self.dockWidgetContents)
reader.addDockWidget(QtCore.Qt.DockWidgetArea(2), self.dockVocab)
self.dockVocab.visibilityChanged.connect(self.onVisibilityChanged)
self.dockVocab.setWindowTitle(translate("MainWindowReader", "Vocabulary", None))
self.textField.setLinkHandler(self.onAnchorClicked)
# menu entries to toggle visibility of the vocabulary dock
self.actionToggleVocab = QtGui.QAction(reader)
self.actionToggleVocab.setCheckable(True)
self.actionToggleVocab.setObjectName("actionToggleVocab")
self.actionToggleVocab.setText("&Vocabulary")
self.actionToggleVocab.setToolTip("Toggle vocabulary")
reader.menuView.insertAction(reader.menuView.actions()[2],self.actionToggleVocab)
QtCore.QObject.connect(self.actionToggleVocab, QtCore.SIGNAL("toggled(bool)"), self.dockVocab.setVisible)
self.dockVocab.installEventFilter(self.reader.keyFilter)
def updateSampleFromSelection(self):
d = {
"samplePosStart": 0,
"contentSampleFlat": self.textField.selectedText(),
"content": ""
}
self.onLookup(d,0,sentenceAndLine=False)
def fixHtml(self,html,appendToHistory=True):
if html.find(self.buildEmpty()) == -1 and appendToHistory:
self.history.append((html,list(self.definitions),self.defBody))
back = len(self.history)>1
#self.currentIndex > 0
#forward = self.currentIndex < len(self.history)-1
if back:
backHtml = "<a href='vocabulary_back:0'><<Back</a>" if back else ""
forwardHtml = ""
#"<a href='vocabulary_forward:0'>Forward>></a>" if forward else ""
return u"<div>{1} {2}</div><br>{0}".format(html,backHtml,forwardHtml)
else:
return html
def onVisibilityChanged(self,visible):
self.actionToggleVocab.setChecked(self.dockVocab.isVisible())
def onAnchorClicked(self, url):
command, index = url.split(':')
if command == "jisho":
url = QtCore.QUrl(self.reader.preferences["linkToVocab"].format(index))
QtGui.QDesktopServices().openUrl(url)
elif command == "vocabulary_back":
if len(self.history)>1:
self.history.pop()
html, definitions, body = self.history[-1]
html = self.fixHtml(html,appendToHistory=False)
self.textField.setHtml(html)
self.definitions = definitions
self.defBody = body
elif command == "vocabulary_forward":
self.textField.history().forward()
else:
if not index.startswith("void"):
index = int(index)
commands = command.split("_")
profile = commands.pop(0)
self.runCommand(commands,index)
def onLookup(self,d,lengthMatched,sentenceAndLine=True):
if self.dockVocab.isVisible():
lengthMatched = self.reader.findTerm(d)
if sentenceAndLine:
sentence, sentenceStart = reader_util.findSentence(d['content'], d['samplePosStart'])
line, lineStart = reader_util.findLine(d['content'], d['samplePosStart'])
else:
sentence = line = ""
for definition in self.definitions:
definition['sentence'] = sentence
definition['line'] = line
definition['filename'] = self.reader.state.filename
self.previousExpression = None
self.reader.updateVocabDefs('vocabulary')
return lengthMatched
def onQuery(self,query):
if self.dockVocab.isVisible():
lengthMatched = self.reader.findTerm(query,wildcards=True)
for definition in self.definitions:
definition['sentence'] = ""
definition['line'] = ""
definition['filename'] = self.reader.state.filename
self.previousExpression = None
self.reader.updateVocabDefs('vocabulary')
return lengthMatched
def onShowDialogPreferences(self,dialog):
dialog.checkHideTranslation = QtGui.QCheckBox(dialog.tabAnki)
dialog.checkHideTranslation.setObjectName(fromUtf8("checkHideTranslation"))
dialog.verticalLayout_2.addWidget(dialog.checkHideTranslation)
dialog.checkHideTranslation.setText(translate("DialogPreferences", "Hide translation, when an online dictionary entry is present", None))
GenericProfile.onShowDialogPreferences(self,dialog)
def runCommand(self,cmds,index):
if index >= len(self.definitions):
return
definition = self.definitions[index]
if cmds[0] == "copy":
if definition['reading']:
result = u'{expression}\t{reading}\t{glossary}\n'.format(**definition)
else:
result = u'{expression}\t{glossary}\n'.format(**definition)
if definition.get("defs"):
text = self.reader.textContent.toPlainText() + "\n"
self.reader.textContent.setPlainText(text +
definition.get("defs").replace(u"<br>",u"\n"))
QtGui.QApplication.clipboard().setText(result)
elif cmds[0] == "goo":
prefix = "http://dictionary.goo.ne.jp"
self.reader.link = prefix + "/srch/jn/" + definition['expression'] + "/m1u/"
page = urllib2.urlopen(
urllib2.Request(url=prefix + "/srch/jn/" + definition['expression'] + "/m1u/",
headers={'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11'})).read()
soup = BeautifulSoup.BeautifulSoup(page)
if not soup.find("div","contents-wrap-b"):
lis = soup.find("div",id="NR-main").find("div","contents-wrap-a-in search").find("ul","list-search-a").findAll("li")
for li in lis:
hiragana = li.find("dt","search-ttl-a").contents[0].replace(u"\u2010",u"").replace(u"\u30fb",u"")
idx = hiragana.find(u"\u3010")
if idx>-1:
hiragana = hiragana[:idx]
self.reader.hiragana = [hiragana,definition['reading']]
self.reader.html = soup.contents[0]
if hiragana == definition['reading']:
a = li.find("a")
link = prefix + dict(a.attrs)["href"]
page2 = urllib2.urlopen(
urllib2.Request(url=link,
headers={'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11'})).read()
soup = BeautifulSoup.BeautifulSoup(page2)
if soup.find("div","contents-wrap-b"):
definition['goo'] = '\n'.join(map(unicode,soup.findAll("ol","list-data-b")))
self.reader.preferences['onlineDicts']['goo'][definition['expression']+"["+(definition['reading'] or "")+"]"] = definition['goo']
self.updateDefinitions()
else:
if len(cmds)>1 and cmds[1] == "reading":
definition = definition.copy()
definition['summary'] = definition['reading']
definition['expression'] = definition['reading']
definition['reading'] = unicode()
if cmds[0] == "add":
self.addFact(definition)
elif cmds[0] == "overwrite":
self.overwriteFact(definition)
def markup(self, definition):
if definition.get('reading'):
summary = u'{expression}[{reading}]'.format(**definition)
else:
summary = u'{expression}'.format(**definition)
return {
'defs': definition.get("defs") or unicode(),
'refs': definition.get("refs") or unicode(),
'expression': definition['expression'],
'hanja': definition.get('hanja') or unicode(),
'reading': definition.get('reading') or unicode(),
'glossary': definition.get('glossary') or unicode(),
'gender': definition.get('gender') or unicode(),
'language': definition.get('language') or unicode(),
'sentence': definition.get('sentence') or unicode(),
'traditional': definition.get('traditional') or unicode(),
'line': definition.get('line') or unicode(),
'filename': definition.get('filename') or unicode(),
'goo': definition.get('goo') or unicode(),
'term': definition.get('term') or unicode(),
'source': definition.get('source') or unicode(),
'summary': summary
}
def buildDefBody(self, definition, index, allowOverwrite):
reading = unicode()
if(definition.get('language') == 'Japanese' and (definition['expression']+"["+(definition['reading'] or "")+"]") in self.reader.preferences['onlineDicts']['goo']):
definition['goo'] = self.reader.preferences['onlineDicts']['goo'][definition['expression']+"["+(definition['reading'] or "")+"]"]
if definition.get('reading'):
reading = u'<span class="reading">[{0}]<br>'.format(definition['reading'])
if definition.get('tags') == u'traditional':
reading += u' (trad.)'
reading += '</span>'
rules = unicode()
if definition.get('rules'):
rules = ' < '.join(definition['rules'])
rules = '<span class="rules">({0})<br></span>'.format(rules)
gender = unicode()
if definition.get('gender'):
gender = '<span class="gender">{0}<br></span>'.format(definition['gender'])
links = '<a href="vocabulary_copy:{0}"><img src="qrc:///img/img/icon_copy_definition.png" align="right"></a>'.format(index)
markupExp = self.markup(definition)
defReading = definition.copy()
if defReading.get('reading'):
defReading['expression'] = defReading['reading']
del defReading['reading']
markupReading = self.markup(defReading)
if self.ankiIsFactValid('vocabulary', markupExp, index):
links += u'<a href="vocabulary_add:{0}"><img src="qrc:///img/img/icon_add_expression.png" align="right"></a>'.format(index)
else:
if allowOverwrite:
links += u'<a href="vocabulary_overwrite:{0}"><img src="qrc:///img/img/icon_overwrite_expression.png" align="right"></a>'.format(index)
if markupReading is not None and definition.get('language') == 'Japanese':
if self.ankiIsFactValid('vocabulary', markupReading, index):
links += u'<a href="vocabulary_add_reading:{0}"><img src="qrc:///img/img/icon_add_reading.png" align="right"></a>'.format(index)
elif markupExp is not None and markupReading['summary'] != markupExp['summary']:
if allowOverwrite:
links += u'<a href="vocabulary_overwrite_reading:{0}"><img src="qrc:///img/img/icon_overwrite_reading.png" align="right"></a>'.format(index)
def glossary(hide):
if hide:
return u"""<a onclick='document.getElementById("glossary{1}").style.display="block";this.style.display="none"' href="javascript:void(0);">[Show English]<br></a><span class="glossary" id="glossary{1}" style="display:none;">{0}<br></span>""".format(definition['glossary'],index)
else:
return u'<span class="glossary" id="glossary">{0}<br></span>'.format(definition['glossary'])
foundOnlineDictEntry = False
if markupExp["defs"] != "":
dictionaryEntries = u"<span class='online'>"+ markupExp["defs"] + " " + markupExp["refs"] + "</span>"
foundOnlineDictEntry = True
else:
dictionaryEntries = ""
if(definition.get("goo")):
dictionaryEntries += u"<br><span class='online'>" + definition["goo"] + "</span><br>"
foundOnlineDictEntry = True
elif(definition.get('language') == 'Japanese'):
dictionaryEntries += u'<br><a href="vocabulary_goo:{0}">[Goo]</a><br>'.format(index)
if(definition.get('language') == 'Japanese'):
expression = u'<span class="expression"><a href="jisho:{0}">{0}</a></span>'.format(definition["expression"])
reading = reading + '<br>'
elif(definition.get('language') == 'German'):
if self.previousExpression == definition['expression']:
expression = ''
else:
expression = u'<span class="german">{0}</span><br>'.format(definition['expression'] + ' ' + gender)
self.previousExpression = definition['expression']
else:
expression = u'<span class="expression">{0}</span>'.format(definition['expression'])
reading = reading + '<br>'
html = u"""
<span class="links">{0}</span>
{1}
{2}
{3}
{4}
{5}
<br clear="all">""".format(links, expression, reading, glossary(foundOnlineDictEntry and self.reader.preferences['hideTranslation']), rules,dictionaryEntries)
if (definition.get('language') != 'German'):
html = u"<hr>" + html
return html
