def populateFromMarkup(self, markup):
with Lib.BlockSignals(self):
self.documentStartEdit.setPlainText(markup.DocumentStart)
self.documentEndEdit.setPlainText(markup.DocumentEnd)
self.noteEdit.setPlainText(markup.Note)
self.sectionStartEdit.setPlainText(markup.SectionStart)
self.sectionEndEdit.setPlainText(markup.SectionEnd)
self.mainStartEdit.setPlainText(markup.MainStart)
self.mainEndEdit.setPlainText(markup.MainEnd)
self.sub1StartEdit.setPlainText(markup.Sub1Start)
self.sub1EndEdit.setPlainText(markup.Sub1End)
self.sub2StartEdit.setPlainText(markup.Sub2Start)
self.sub2EndEdit.setPlainText(markup.Sub2End)
self.sub3StartEdit.setPlainText(markup.Sub3Start)
self.sub3EndEdit.setPlainText(markup.Sub3End)
self.sub4StartEdit.setPlainText(markup.Sub4Start)
self.sub4EndEdit.setPlainText(markup.Sub4End)
self.sub5StartEdit.setPlainText(markup.Sub5Start)
self.sub5EndEdit.setPlainText(markup.Sub5End)
self.sub6StartEdit.setPlainText(markup.Sub6Start)
self.sub6EndEdit.setPlainText(markup.Sub6End)
self.sub7StartEdit.setPlainText(markup.Sub7Start)
self.sub7EndEdit.setPlainText(markup.Sub7End)
self.sub8StartEdit.setPlainText(markup.Sub8Start)
self.sub8EndEdit.setPlainText(markup.Sub8End)
self.sub9StartEdit.setPlainText(markup.Sub9Start)
self.sub9EndEdit.setPlainText(markup.Sub9End)
def goHome(self, ctrl=False):
if not self.cache:
return
self.selectedLino = 0
with Lib.BlockSignals(self.scrollbar):
self.scrollbar.setValue(0)
self.refresh()
def _setGroupOrPagesOrder(self, gid=None):
self.filterTextComboBox.setEditable(False)
self.filterTextComboBox.setEnabled(True)
items = []
filter = FilterKind(
self.filterComboBox.itemData(self.filterComboBox.currentIndex()))
if filter is FilterKind.IN_NORMAL_GROUP:
items = list(self.state.model.normalGroups())
elif filter is FilterKind.IN_LINKED_GROUP:
items = list(self.state.model.linkedGroups())
elif filter is FilterKind.PAGES_ORDER:
items = [(int(x), x.text) for x in PagesOrderKind]
if self.prevFilter not in {
FilterKind.IN_NORMAL_GROUP, FilterKind.IN_LINKED_GROUP,
FilterKind.PAGES_ORDER
}:
self.matchTexts = []
for i in range(self.filterTextComboBox.count()):
self.matchTexts.append(self.filterTextComboBox.itemText(i))
with Lib.BlockSignals(self.filterTextComboBox):
index = None
self.filterTextComboBox.clear()
for i, (itemId, name) in enumerate(items):
self.filterTextComboBox.addItem(name, itemId)
if gid is not None and gid == itemId:
index = i
if index is not None:
self.filterTextComboBox.setCurrentIndex(index)
self.setMatch()
def viewEntry(self, eid=None):
# Either we are editing or viewing (see also cancelAdd())
if self.mode is not ModeKind.ADD or eid is None:
if eid is None:
eid = self.viewAllPanel.view.selectedEid
with Lib.BlockSignals(self.entryPanel):
self.entryPanel.setEntry(self.model.entry(eid))
self.setMode(ModeKind.VIEW)
def combine(self):
pages = self.combinedPagesLabel.text()
if pages != self.originalPagesLabel.text():
with Lib.BlockSignals(self.state.model):
self.state.model.editEntry(self.entry, self.entry.saf,
self.entry.sortas, self.entry.term,
pages)
self.skip()
def refreshEntry(self, eid):
entry = self.model.entry(eid, withIndent=True, withXrefIndicator=True)
if entry is not None:
with Lib.BlockSignals(self.entryPanel):
self.entryPanel.setEntry(entry)
self.viewAllPanel.view.updateCache(entry)
self.viewFilteredPanel.requery()
self.viewFilteredPanel.view.updateCache(entry)
self.updateUi()
def updateUi(self):
self.sortAsEdit.setEnabled(self.customRadioButton.isChecked())
with Lib.BlockSignals(self.sortAsEdit):
for i, radioButton in enumerate(self.radioButtons):
if radioButton.isChecked():
self.sortAsEdit.setText(self.candidates[i].candidate)
self.sortAsEdit.selectAll()
break
self.okButton.setEnabled(
not self.customRadioButton.isChecked() or
(self.customRadioButton.isChecked() and
bool(self.sortAsEdit.toPlainText())))
def cancelAdd(self):
prefix = self.state.entryPanel.termEdit.toPlainText()
with Lib.BlockSignals(self.state.entryPanel):
self.state.entryPanel.clearForm()
self.state.setMode(ModeKind.VIEW)
if not self.state.window.gotoActions.gotoPrefix(prefix):
eid = self.state.viewAllPanel.view.selectedEid
if eid is not None:
self.state.window.gotoActions.gotoEid(eid)
if bool(self.state.model):
editor = self.state.entryPanel.pagesEdit
editor.setFocus()
cursor = editor.textCursor()
cursor.movePosition(QTextCursor.End)
editor.setTextCursor(cursor)
def gotoEid(self, eid):
if self.state.model.hasEntry(eid):
for offset, (indent, entryEid) in enumerate(
self.state.model.entries(offset=0, limit=UNLIMITED)):
if entryEid == eid:
halfPage = self.scrollbar.pageStep() // 2
if offset > halfPage: # Keep some context
offset -= halfPage
else:
offset = 0
with Lib.BlockSignals(self.scrollbar):
self.scrollbar.setValue(offset)
self.selectedLino = None
self.selectedEid = eid
break
self.refresh()
def delete(self):
widget = QApplication.focusWidget()
if self.state.mode in {ModeKind.NO_INDEX, ModeKind.CHANGE}:
return # Can't delete if there's no index or big changes
if self.state.mode in {ModeKind.ADD, ModeKind.EDIT}:
self.save() # Save outstanding changes & set to view mode first
if self.state.entryPanel.entry is None:
return # Should never happen
eid = self.state.entryPanel.entry.eid
if eid is None:
return # Should never happen
eids = list(self.state.model.deletableEntries(eid))
if not eids:
return # Should never happen
message = "Delete entry “{}”".format(self.state.model.term(eid))
if len(eids) == 2:
message += ", and its subentry"
elif len(eids) > 2:
count = Lib.spellNumber(len(eids) - 1, limit=20)
message += ", and its {} subentries".format(count)
message += (", and any related cross-references, and also "
"remove from any groups")
with Lib.Qt.DisableUI(*self.window.widgets(), forModalDialog=True):
reply = QMessageBox.question(
self.window,
"Delete Entry — {}".format(QApplication.applicationName()),
"<p>{}?".format(message), QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes)
if reply == QMessageBox.Yes:
self.state.model.deleteEntry(eid, message[0].lower() + message[1:])
with Lib.BlockSignals(self.state.entryPanel):
self.state.entryPanel.clearForm()
self.state.window.refreshBookmarks()
self.state.viewFilteredPanel.setMatch()
selectedEid = self.state.viewAllPanel.view.selectedEid
if len(self.state.model):
if selectedEid == eid:
self.state.viewAllPanel.view.goUp()
elif selectedEid is None:
self.state.viewAllPanel.view.goEnd()
else:
self.state.viewEntry(selectedEid)
Lib.restoreFocus(widget)
def _calculateSortAs(self, term, candidates):
widget = QApplication.focusWidget()
if len(candidates) == 1:
sortas = candidates[0].candidate
saf = candidates[0].saf
else:
result = Forms.SortAs.Result()
with Lib.Qt.DisableUI(*self.window.widgets(), forModalDialog=True):
form = Forms.SortAs.Form(self, term, candidates, result,
self.window)
form.exec_()
sortas = result.sortas
saf = result.saf
if saf == Saf.CUSTOM:
with Lib.BlockSignals(self.entryPanel.calcSortAsCheckBox):
self.entryPanel.calcSortAsCheckBox.setChecked(False)
self.entryPanel.sortAsEdit.setPlainText(sortas)
self.entryPanel.saf = saf
self.maybeSave()
Lib.restoreFocus(widget)
def findSizes(self, font):
fontDatabase = QFontDatabase()
currentSize = self.sizeComboBox.currentText()
with Lib.BlockSignals(self.sizeComboBox):
self.sizeComboBox.clear()
if fontDatabase.isSmoothlyScalable(font.family(),
fontDatabase.styleString(font)):
for size in QFontDatabase.standardSizes():
self.sizeComboBox.addItem(str(size))
else:
for size in fontDatabase.smoothSizes(
font.family(), fontDatabase.styleString(font)):
self.sizeComboBox.addItem(str(size))
self.sizeComboBox.setEditable(False)
sizeIndex = self.sizeComboBox.findText(currentSize)
if sizeIndex == -1:
self.sizeComboBox.setCurrentIndex(
max(0,
self.sizeComboBox.count() / 3))
else:
self.sizeComboBox.setCurrentIndex(sizeIndex)
def goDown(self, ctrl=False):
if not self.cache:
return
if self._onLastLine:
self.setSelectedLino(self.lineCount - 1)
return
lino = self.selectedLino + 1
if lino < self.lineCount:
self.setSelectedLino(lino)
else:
lines = max(1, self.scrollbar.pageStep() // 3)
offset = self.scrollbar.value() + lines
if offset > self.scrollbar.maximum():
lines = ((self.scrollbar.maximum() - self.scrollbar.value()) //
2)
offset = self.scrollbar.value() + lines
with Lib.BlockSignals(self.scrollbar):
self.scrollbar.setValue(offset)
excess = 1 if lines == offset else 0
self.selectedLino = self.lineCount - lines + excess
self.selectedEid = None
self.refresh()
def populateFromMarkup(self, markup):
with Lib.BlockSignals(self):
self.escapeFunctionComboBox.setCurrentIndex(
0 if markup.escapefunction == "html" else 1)
self.pageRangeSeparatorEdit.setPlainText(markup.RangeSeparator)
self.stdFontStartEdit.setPlainText(markup.StdFontStart)
self.stdFontEndEdit.setPlainText(markup.StdFontEnd)
self.altFontStartEdit.setPlainText(markup.AltFontStart)
self.altFontEndEdit.setPlainText(markup.AltFontEnd)
self.monoFontStartEdit.setPlainText(markup.MonoFontStart)
self.monoFontEndEdit.setPlainText(markup.MonoFontEnd)
self.boldStartEdit.setPlainText(markup.BoldStart)
self.boldEndEdit.setPlainText(markup.BoldEnd)
self.italicStartEdit.setPlainText(markup.ItalicStart)
self.italicEndEdit.setPlainText(markup.ItalicEnd)
self.subscriptStartEdit.setPlainText(markup.SubscriptStart)
self.subscriptEndEdit.setPlainText(markup.SubscriptEnd)
self.superscriptStartEdit.setPlainText(markup.SuperscriptStart)
self.superscriptEndEdit.setPlainText(markup.SuperscriptEnd)
self.underlineStartEdit.setPlainText(markup.UnderlineStart)
self.underlineEndEdit.setPlainText(markup.UnderlineEnd)
self.strikeoutStartEdit.setPlainText(markup.StrikeoutStart)
self.strikeoutEndEdit.setPlainText(markup.StrikeoutEnd)
def query(self):
filter = FilterKind(
self.filterComboBox.itemData(self.filterComboBox.currentIndex()))
if filter in {
FilterKind.IN_NORMAL_GROUP, FilterKind.IN_LINKED_GROUP,
FilterKind.PAGES_ORDER
}:
self._setGroupOrPagesOrder()
elif filter in {
FilterKind.ENTRIES_WITH_PAGES, FilterKind.TERMS_MATCHING,
FilterKind.NOTES_MATCHING
}:
self.filterTextComboBox.setEditable(True)
self.filterTextComboBox.setEnabled(True)
if self.matchTexts:
with Lib.BlockSignals(self.filterTextComboBox):
self.filterTextComboBox.clear()
self.filterTextComboBox.addItems(self.matchTexts)
self.matchTexts = []
self.setMatch()
else:
self.filterTextComboBox.setEnabled(False)
self.view.query(filter)
self.prevFilter = filter
def setMatch(self, match=None):
filter = FilterKind(
self.filterComboBox.itemData(self.filterComboBox.currentIndex()))
if match is None:
match = self.filterTextComboBox.currentText()
arg = match
if filter in {
FilterKind.IN_NORMAL_GROUP, FilterKind.IN_LINKED_GROUP,
FilterKind.PAGES_ORDER
}:
arg = self.filterTextComboBox.itemData(
self.filterTextComboBox.currentIndex())
elif filter is FilterKind.ENTRIES_WITH_PAGES:
arg = Pages.searchablePages(match)
self.view.query(filter, arg)
if match:
with Lib.BlockSignals(self.filterTextComboBox):
index = self.filterTextComboBox.findText(match)
if index == -1:
self.filterTextComboBox.addItem(match)
self.filterTextIndex = (self.filterTextComboBox.count() -
1)
else:
self.filterTextIndex = index
