def delete(self):
"""
Shows a warning, and then deletes currently selected indexes.
"""
if not settings.dontShowDeleteWarning:
msg = QMessageBox(
QMessageBox.Warning,
qApp.translate("outlineBasics", "About to remove"),
qApp.translate(
"outlineBasics",
"<p><b>You're about to delete {} item(s).</b></p><p>Are you sure?</p>"
).format(len(self.getSelection())),
QMessageBox.Yes | QMessageBox.Cancel)
chk = QCheckBox("&Don't show this warning in the future.")
msg.setCheckBox(chk)
ret = msg.exec()
if ret == QMessageBox.Cancel:
return
if chk.isChecked():
settings.dontShowDeleteWarning = True
self.model().removeIndexes(self.getSelection())
def merge(self):
"""
Merges selected items together.
Call context: Multiple selection, same parent.
"""
# Get selection
indexes = self.getSelection()
# Get items
items = [i.internalPointer() for i in indexes if i.isValid()]
# Remove folders
items = [i for i in items if not i.isFolder()]
# Check that we have at least 2 items
if len(items) < 2:
statusMessage(qApp.translate("outlineBasics",
"Select at least two items. Folders are ignored."),
importance=2)
return
# Check that all share the same parent
p = items[0].parent()
for i in items:
if i.parent() != p:
statusMessage(qApp.translate("outlineBasics",
"All items must be on the same level (share the same parent)."),
importance=2)
return
# Sort items by row
items = sorted(items, key=lambda i: i.row())
items[0].mergeWith(items[1:])
def previewWidget(self):
t = QTabWidget()
t.setDocumentMode(True)
t.setStyleSheet("""
QTabBar::tab{
background-color: #BBB;
padding: 3px 25px;
border: none;
}
QTabBar::tab:selected, QTabBar::tab:hover{
background-color:skyblue;
}
""")
w0 = QPlainTextEdit()
w0.setFrameShape(QFrame.NoFrame)
w0.setReadOnly(True)
w1 = QPlainTextEdit()
w1.setFrameShape(QFrame.NoFrame)
w1.setReadOnly(True)
t.addTab(w0, qApp.translate("Export", "Markdown source"))
t.addTab(w1, qApp.translate("Export", "HTML Source"))
if webView:
w2 = webView()
t.addTab(w2, qApp.translate("Export", "HTML Output"))
t.setCurrentIndex(2)
return t
def previewWidget(self):
t = QTabWidget()
t.setDocumentMode(True)
t.setStyleSheet("""
QTabBar::tab{
background-color: #BBB;
padding: 3px 25px;
border: none;
}
QTabBar::tab:selected, QTabBar::tab:hover{
background-color:skyblue;
}
""")
w0 = QPlainTextEdit()
w0.setFrameShape(QFrame.NoFrame)
w0.setReadOnly(True)
w1 = QPlainTextEdit()
w1.setFrameShape(QFrame.NoFrame)
w1.setReadOnly(True)
t.addTab(w0, qApp.translate("Export", "Markdown source"))
t.addTab(w1, qApp.translate("Export", "HTML Source"))
if webView:
w2 = webView()
t.addTab(w2, qApp.translate("Export", "HTML Output"))
t.setCurrentIndex(2)
return t
def output(self, settingsWidget):
settings = settingsWidget.getSettings()
try:
return self.concatenate(mainWindow().mdlOutline.rootItem, settings)
except re.error as e:
QMessageBox.warning(mainWindow().dialog, qApp.translate("Export", "Error"),
qApp.translate("Export", "Could not process regular expression: \n{}").format(str(e)))
return ""
def output(self, settingsWidget):
settings = settingsWidget.getSettings()
try:
return self.concatenate(mainWindow().mdlOutline.rootItem, settings)
except re.error as e:
QMessageBox.warning(mainWindow().dialog, qApp.translate("Export", "Error"),
qApp.translate("Export", "Error processing regular expression : \n{}").format(str(e)))
return ""
def startImport(cls,
filePath,
parentItem,
settingsWidget,
fromString=None):
"""
Import/export outline cards in OPML format.
"""
ret = False
if filePath != "":
# We have a filePath, so we read the file
try:
with open(filePath, 'rb') as opmlFile:
#opmlContent = cls.saveNewlines(opmlFile.read())
opmlContent = opmlFile.read()
except:
QMessageBox.critical(
settingsWidget, qApp.translate("Import", "OPML Import"),
qApp.translate("Import", "File open failed."))
return None
elif fromString == "":
# We have neither filePath nor fromString, so we leave
return None
else:
# We load from string
opmlContent = bytes(fromString, "utf-8")
parsed = ET.fromstring(opmlContent)
opmlNode = parsed
bodyNode = opmlNode.find("body")
items = []
if bodyNode != None:
outlineEls = bodyNode.findall("outline")
if outlineEls != None:
for element in outlineEls:
items.extend(cls.parseItems(element, parentItem))
ret = True
if not ret:
QMessageBox.critical(
settingsWidget, qApp.translate("Import", "OPML Import"),
qApp.translate(
"Import", "This does not appear to be a valid OPML file."))
return None
return items
def stats(self):
wc = self.data(Outline.wordCount.value)
goal = self.data(Outline.goal.value)
progress = self.data(Outline.goalPercentage.value)
if not wc:
wc = 0
if goal:
return qApp.translate("outlineModel", "{} words / {} ({})").format(
locale.format("%d", wc, grouping=True),
locale.format("%d", goal, grouping=True),
"{}%".format(str(int(progress * 100))))
else:
return qApp.translate("outlineModel", "{} words").format(
locale.format("%d", wc, grouping=True))
def stats(self):
wc = self.data(enums.Outline.wordCount)
goal = self.data(enums.Outline.goal)
progress = self.data(enums.Outline.goalPercentage)
if not wc:
wc = 0
if goal:
return qApp.translate("outlineItem", "{} words / {} ({})").format(
locale.format("%d", wc, grouping=True),
locale.format("%d", goal, grouping=True),
"{}%".format(str(int(progress * 100))))
else:
return qApp.translate("outlineItem", "{} words").format(
locale.format("%d", wc, grouping=True))
def startImport(cls, filePath, parentItem, settingsWidget, fromString=None):
"""
Import/export outline cards in OPML format.
"""
ret = False
if filePath != "":
# We have a filePath, so we read the file
try:
with open(filePath, 'rb') as opmlFile:
#opmlContent = cls.saveNewlines(opmlFile.read())
opmlContent = opmlFile.read()
except:
QMessageBox.critical(settingsWidget,
qApp.translate("Import", "OPML Import"),
qApp.translate("Import", "File open failed."))
return None
elif fromString == "":
# We have neither filePath nor fromString, so we leave
return None
else:
# We load from string
opmlContent = bytes(fromString, "utf-8")
parsed = ET.fromstring(opmlContent)
opmlNode = parsed
bodyNode = opmlNode.find("body")
items = []
if bodyNode is not None:
outlineEls = bodyNode.findall("outline")
if outlineEls is not None:
for element in outlineEls:
items.extend(cls.parseItems(element, parentItem))
ret = True
if not ret:
QMessageBox.critical(
settingsWidget,
qApp.translate("Import", "OPML Import"),
qApp.translate("Import", "This does not appear to be a valid OPML file."))
return None
return items
def getExportFilename(self, settingsWidget, varName=None, filter=None):
if varName == None:
varName = self.exportVarName
if filter == None:
filter = self.exportFilter
settings = settingsWidget.getSettings()
s = settings.get("Output", {})
if varName in s:
filename = s[varName]
else:
filename = ""
filename, filter = getSaveFileNameWithSuffix(
settingsWidget.parent(),
caption=qApp.translate("Export", "Choose output file…"),
filter=filter,
directory=filename,
defaultSuffix=self.exportDefaultSuffix)
if filename:
s[varName] = filename
settingsWidget.settings["Output"] = s
# Save settings
settingsWidget.writeSettings()
return filename
def convert(self, src, args, outputfile=None):
args = [self.cmd] + args
if outputfile:
args.append("--output={}".format(outputfile))
qApp.setOverrideCursor(QCursor(Qt.WaitCursor))
p = subprocess.Popen(args,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
if not type(src) == bytes:
src = src.encode("utf-8") # assumes utf-8
stdout, stderr = p.communicate(src)
qApp.restoreOverrideCursor()
if stderr:
err = stderr.decode("utf-8")
print(err)
QMessageBox.critical(mainWindow().dialog,
qApp.translate("Export", "Error"), err)
return None
return stdout.decode("utf-8")
class pandocExporter(basicExporter):
name = "Pandoc"
description = qApp.translate(
"Export",
"""<p>A universal document convertor. Can be used to convert markdown to a wide range of other
formats.</p>
<p>Website: <a href="http://www.pandoc.org">http://pandoc.org/</a></p>
""")
cmd = "pandoc"
def __init__(self):
basicExporter.__init__(self)
self.exportTo = [
markdown(self),
latex(self),
HTML(self),
ePub(self),
OpenDocument(self),
DocX(self),
PDF(self),
reST(self),
]
def version(self):
if self.isValid():
r = self.run(["-v"])
return r.split("\n")[0]
else:
return ""
def convert(self, src, args, outputfile=None):
args = [self.cmd] + args
if outputfile:
args.append("--output={}".format(outputfile))
qApp.setOverrideCursor(QCursor(Qt.WaitCursor))
p = subprocess.Popen(args,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
if not type(src) == bytes:
src = src.encode("utf-8") # assumes utf-8
stdout, stderr = p.communicate(src)
qApp.restoreOverrideCursor()
if stderr:
err = stderr.decode("utf-8")
print(err)
QMessageBox.critical(mainWindow().dialog,
qApp.translate("Export", "Error"), err)
return None
return stdout.decode("utf-8")
class mmdExporter(basicExporter):
name = "MultiMarkdown"
description = qApp.translate(
"Export", """<p>A superset of markdown.</p>
<p>Website: <a href="http://fletcherpenney.net/multimarkdown/">http://fletcherpenney.net/multimarkdown/</a></p>
""")
exportTo = [
basicFormat(
"HTML",
"A little known format modestly used. You know, web sites for example.",
"text-html"),
basicFormat("latex", "", "text-x-tex"),
basicFormat("Flat XML", "", "text-xml"),
basicFormat("ePub",
"Books that don't kill trees.",
icon="application-epub+zip"),
]
cmd = "multimarkdown"
def version(self):
if self.isValid():
r = self.run(["-v"])
return r.split("\n")[1]
else:
return ""
def main():
from PyQt5 import QtWebEngineWidgets # To avoid error must be amountd before QCoreApplication
dir(QtWebEngineWidgets)
mem = MemXulpymoney()
mem.run()
mem.frmAccess = frmAccess("xulpymoney", "frmAccess")
mem.frmAccess.setResources(":/xulpymoney/books.png",
":/xulpymoney/xulpymoney.png")
mem.frmAccess.databaseCreated.connect(on_database_created)
mem.frmAccess.setLabel(
qApp.translate("Mem", "Please login to the Xulpymoney database"))
mem.frmAccess.exec_()
if mem.frmAccess.result() == QDialog.Accepted:
mem.setConnection(mem.frmAccess.con, "Qt")
mem.load_db_data()
mem.settings = mem.frmAccess.settings
if mem.isProductsMaintenanceMode():
mem.frmMain = frmMainProductsMaintenance(mem)
else:
mem.frmMain = frmMain(mem)
mem.frmMain.show()
info("Xulpymoney start time was {}".format(datetime.now() -
mem.inittime))
exit(mem.app.exec_())
def getLastAccessedDirectory(self):
sttgs = QSettings()
lastDirectory = sttgs.value("lastAccessedDirectory", defaultValue=".", type=str)
if lastDirectory != '.':
print(qApp.translate("lastAccessedDirectoryInfo", "Last accessed directory \"{}\" loaded.").format(
lastDirectory))
return lastDirectory
def getLastAccessedDirectory(self):
sttgs = QSettings()
lastDirectory = sttgs.value("lastAccessedDirectory", defaultValue=".", type=str)
if lastDirectory != '.':
print(qApp.translate("lastAccessedDirectoryInfo", "Last accessed directory \"{}\" loaded.").format(
lastDirectory))
return lastDirectory
def convert(self, src, args, outputfile=None):
if self.isValid() == 2:
run = self.cmd
elif self.isValid() == 1:
run = self.customPath
else:
LOGGER.error("No command for pandoc.")
return None
args = [run] + args
if outputfile:
args.append("--output={}".format(outputfile))
for name, col, var in [
("Title", 0, "title"),
("Subtitle", 1, "subtitle"),
("Serie", 2, ""),
("Volume", 3, ""),
("Genre", 4, ""),
("License", 5, ""),
("Author", 6, "author"),
("Email", 7, ""),
]:
item = mainWindow().mdlFlatData.item(0, col)
if var and item and item.text().strip():
args.append("--variable={}:{}".format(var, item.text().strip()))
# Add title metadata required for pandoc >= 2.x
title = "Untitled"
if mainWindow().mdlFlatData.item(0, 0):
title = mainWindow().mdlFlatData.item(0, 0).text().strip()
args.append("--metadata=title:{}".format(title))
qApp.setOverrideCursor(QCursor(Qt.WaitCursor))
p = subprocess.Popen(
args,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
if not type(src) == bytes:
src = src.encode("utf-8") # assumes utf-8
stdout, stderr = p.communicate(src)
qApp.restoreOverrideCursor()
if stderr or p.returncode != 0:
err = "ERROR on export" + "\n" \
+ "Return code" + ": %d\n" % (p.returncode) \
+ "Command and parameters" + ":\n%s\n" % (p.args) \
+ "Stderr content" + ":\n" + stderr.decode("utf-8")
LOGGER.error(err)
QMessageBox.critical(mainWindow().dialog, qApp.translate("Export", "Error"), err)
return None
return stdout.decode("utf-8")
def settingsWidget(self, widget):
"""
Takes a QWidget that can be modified and must be returned.
"""
# Add group
group = self.addGroup(widget.toolBox.widget(0),
qApp.translate("Import", "Pandoc import"))
self.addSetting(
"info", "label",
qApp.translate(
"Import", """<b>Info:</b> Manuskript can
import from <b>markdown</b> or <b>OPML</b>. Pandoc will
convert your document to either (see option below), and
then it will be imported in manuskript. One or the other
might give better result depending on your document.
<br/> """))
self.addSetting("formatTo",
"combo",
qApp.translate("Import", "Import using:"),
vals="markdown|OPML")
self.addSetting("wrap",
"combo",
qApp.translate("Import", "Wrap lines:"),
vals="auto|none|preserve",
default="none",
tooltip=qApp.translate(
"Import", """<p>Should pandoc create
cosmetic / non-semantic line-breaks?</p><p>
<b>auto</b>: wraps at 72 characters.<br>
<b>none</b>: no line wrap.<br>
<b>preserve</b>: tries to preserves line wrap from the
original document.</p>"""))
for s in self.settings:
self.settings[s].widget(group)
self.mdImporter = markdownImporter()
widget = self.mdImporter.settingsWidget(widget)
self.opmlImporter = opmlImporter()
widget = self.opmlImporter.settingsWidget(widget)
return widget
def createNewText(self):
item = self._index.internalPointer()
newItem = outlineItem(title=qApp.translate("outlineBasics", "New"),
_type=settings.defaultTextType)
self._index.model().insertItem(newItem,
item.row() + 1,
item.parent().index())
self.setCurrentModelIndex(newItem.index())
class ePub(abstractOutput):
name = "ePub"
description = qApp.translate("Export", """Books that don't kill trees.""")
icon = "application-epub+zip"
exportVarName = "lastPandocePub"
toFormat = "epub"
exportFilter = "ePub files (*.epub);; Any files (*)"
class reST(abstractPlainText):
name = "reST"
description = qApp.translate("Export", """reStructuredText is a lightweight markup language.""")
exportVarName = "lastPandocreST"
toFormat = "rst"
icon = "text-plain"
exportFilter = "reST files (*.rst);; Any files (*)"
def tooltip(ref):
"""Returns a tooltip in HTML for the reference ``ref``."""
infos = shortInfos(ref)
if not infos:
return qApp.translate("references", "<b>Unknown reference:</b> {}.").format(ref)
if infos == -1:
return qApp.translate("references", "Not a reference: {}.").format(ref)
if infos["type"] == TextLetter:
if infos["text_type"] == "folder":
tt = qApp.translate("references", "Folder: <b>{}</b>").format(infos["title"])
else:
tt = qApp.translate("references", "Text: <b>{}</b>").format(infos["title"])
tt += "<br><i>{}</i>".format(infos["path"])
return tt
elif infos["type"] == CharacterLetter:
return qApp.translate("references", "Character: <b>{}</b>").format(infos["title"])
elif infos["type"] == PlotLetter:
return qApp.translate("references", "Plot: <b>{}</b>").format(infos["title"])
elif infos["type"] == WorldLetter:
return qApp.translate("references", "World: <b>{name}</b>{path}").format(
name=infos["title"],
path=" <span style='color:gray;'>({})</span>".format(infos["path"]) if infos["path"] else "")
def startImport(self,
filePath,
parentItem,
settingsWidget,
fromString=None):
"""
Import/export outline cards in mind map free plane.
"""
ret = False
if filePath != "":
# We have a filePath, so we read the file
try:
with open(filePath, 'rb') as f:
content = f.read()
except:
return None
elif fromString == "":
# We have neither filePath nor fromString, so we leave
return None
else:
# We load from string
content = bytes(fromString, "utf-8")
root = ET.fromstring(content)
node = root.find("node")
items = []
if node is not None:
items.extend(self.parseItems(node, parentItem))
ret = True
if not ret:
QMessageBox.critical(
settingsWidget, qApp.translate("Import", "Mind Map Import"),
qApp.translate(
"Import",
"This does not appear to be a valid Mind Map file."))
return None
return items
def tooltip(ref):
"""Returns a tooltip in HTML for the reference ``ref``."""
infos = shortInfos(ref)
if not infos:
return qApp.translate("references",
"<b>Unknown reference:</b> {}.").format(ref)
if infos == -1:
return qApp.translate("references", "Not a reference: {}.").format(ref)
if infos["type"] == TextLetter:
if infos["text_type"] == "folder":
tt = qApp.translate("references",
"Folder: <b>{}</b>").format(infos["title"])
else:
tt = qApp.translate("references",
"Text: <b>{}</b>").format(infos["title"])
tt += "<br><i>{}</i>".format(infos["path"])
return tt
elif infos["type"] == CharacterLetter:
return qApp.translate("references",
"Character: <b>{}</b>").format(infos["title"])
elif infos["type"] == PlotLetter:
return qApp.translate("references",
"Plot: <b>{}</b>").format(infos["title"])
elif infos["type"] == WorldLetter:
return qApp.translate(
"references", "World: <b>{name}</b>{path}").format(
name=infos["title"],
path=" <span style='color:gray;'>({})</span>".format(
infos["path"]) if infos["path"] else "")
def settingsWidget(self, widget):
"""
Takes a QWidget that can be modified and must be returned.
"""
# Add group
group = self.addGroup(widget.toolBox.widget(0),
qApp.translate("Import", "Mind Map import"))
self.addSetting("importTipAs", "combo",
qApp.translate("Import", "Import tip as:"),
vals="Text|Folder",
)
for s in self.settings:
self.settings[s].widget(group)
return widget
class DocX(abstractOutput):
name = "DocX"
description = qApp.translate("Export",
"Microsoft Office (.docx) document.")
exportVarName = "lastPandocDocX"
toFormat = "docx"
icon = "application-vnd.openxmlformats-officedocument.wordprocessingml.document"
exportFilter = "DocX files (*.docx);; Any files (*)"
class OpenDocument(abstractOutput):
name = "OpenDocument"
description = qApp.translate(
"Export", "OpenDocument format. Used by LibreOffice for example.")
exportVarName = "lastPandocODT"
toFormat = "odt"
icon = "application-vnd.oasis.opendocument.text"
exportFilter = "OpenDocument files (*.odt);; Any files (*)"
class latex(abstractPlainText):
name = "LaTeX"
description = qApp.translate("Export", """LaTeX is a word processor and document markup language used to create
beautiful documents.""")
exportVarName = "lastPandocLatex"
toFormat = "latex"
icon = "text-x-tex"
exportFilter = "Tex files (*.tex);; Any files (*)"
class markdown(abstractPlainText):
name = "Markdown"
description = qApp.translate("Export", """Export to markdown, using pandoc. Allows more formatting options
than the basic manuskript exporter.""")
icon = "text-x-markdown"
exportVarName = "lastPandocMarkdown"
toFormat = "markdown"
exportFilter = "Markdown files (*.md);; Any files (*)"
class OPML(abstractPlainText):
name = "OPML"
description = qApp.translate("Export", """The purpose of this format is to provide a way to exchange information
between outliners and Internet services that can be browsed or controlled
through an outliner.""")
exportVarName = "lastPandocOPML"
toFormat = "opml"
icon = "text-x-opml+xml"
exportFilter = "OPML files (*.opml);; Any files (*)"
def settingsWidget(self, widget):
"""
Takes a QWidget that can be modified and must be returned.
"""
# Add group
group = self.addGroup(widget.toolBox.widget(0),
qApp.translate("Import", "Markdown import"))
#group = cls.addPage(widget, "Folder import")
self.addSetting("info", "label",
qApp.translate("Import", """<b>Info:</b> A very simple
parser that will go through a markdown document and
create items for each titles.<br/> """))
for s in self.settings:
self.settings[s].widget(group)
return widget
class PDF(abstractOutput):
"""PDF Viewer using PDF.js. Cf. https://github.com/mozilla/pdf.js/wiki/Setup-PDF.js-in-a-website"""
name = "PDF"
description = qApp.translate("Export", "Needs LaTeX to be installed.")
InvalidBecause = qApp.translate(
"Export",
"""a valid LaTeX installation. Pandoc recommendations can be found on:
<a href="https://pandoc.org/installing.html">pandoc.org/installing.html</a>. If you want Unicode support, you need XeLaTeX."""
)
icon = "application-pdf"
exportVarName = "lastPandocPDF"
toFormat = "pdf"
exportFilter = "PDF files (*.pdf);; Any files (*)"
exportDefaultSuffix = ".pdf"
requires = {
"Settings": True,
"Preview": True,
}
def isValid(self):
path = shutil.which("pdflatex") or shutil.which("xelatex")
return path is not None
def output(self, settingsWidget, outputfile=None):
args = settingsWidget.runnableSettings()
args.remove("--to=pdf")
args.append("--to=latex")
src = self.src(settingsWidget)
return self.exporter.convert(src, args, outputfile)
def previewWidget(self):
return PDFViewer()
def preview(self, settingsWidget, previewWidget):
filename = tempFile("msk_pdfpreview.pdf")
settingsWidget.writeSettings()
content = self.output(settingsWidget, outputfile=filename)
previewWidget.loadPDF(filename)
def addItem(self, _type="folder"):
if len(self.selectedIndexes()) == 0:
parent = self.rootIndex()
else:
parent = self.currentIndex()
if _type == "text":
_type = settings.defaultTextType
item = outlineItem(title=qApp.translate("outlineBasics", "New"), _type=_type)
self.model().appendItem(item, parent)
def on_database_created(connectionqt):
from xulpymoney.database_update import database_update
from xulpymoney.version import __versiondatetime__
from xulpymoney.ui.myqwidgets import qmessagebox
database_update(connectionqt, "xulpymoney", __versiondatetime__, "Console")
connectionqt.commit()
qmessagebox(
qApp.translate(
"Mem",
"Xulpymoney have been correctly installed. Please login again"))
exit(qApp.exec_())
def addItem(self, _type="folder"):
if len(self.selectedIndexes()) == 0:
parent = self.rootIndex()
else:
parent = self.currentIndex()
if _type == "text":
_type = settings.defaultTextType
item = outlineItem(title=qApp.translate("outlineBasics", "New"), _type=_type)
self.model().appendItem(item, parent)
def __init__(self, _format, parent=None):
exporterSettings.__init__(self, _format, parent)
# Adds markdown syntax highlighter setting
w = self.toolBox.widget(self.toolBox.count() - 1)
self.grpMarkdown = QGroupBox(self.tr("Markdown"))
self.grpMarkdown.setLayout(QVBoxLayout())
self.chkMarkdownHighlighter = QCheckBox(qApp.translate("Export", "Preview with highlighter."))
self.grpMarkdown.layout().addWidget(self.chkMarkdownHighlighter)
w.layout().insertWidget(w.layout().count() - 1, self.grpMarkdown)
def settingsWidget(self, widget):
"""
Takes a QWidget that can be modified and must be returned.
"""
# Add group
group = self.addGroup(widget.toolBox.widget(0),
qApp.translate("Import", "Mind Map import"))
self.addSetting(
"importTipAs",
"combo",
qApp.translate("Import", "Import tip as:"),
vals="Text|Folder",
)
for s in self.settings:
self.settings[s].widget(group)
return widget
def settingsWidget(self, widget):
"""
Takes a QWidget that can be modified and must be returned.
"""
# Add group
group = self.addGroup(widget.toolBox.widget(0),
qApp.translate("Import", "Pandoc import"))
self.addSetting("info", "label",
qApp.translate("Import", """<b>Info:</b> Manuskript can
import from <b>markdown</b> or <b>OPML</b>. Pandoc will
convert your document to either (see option below), and
then it will be imported in manuskript. One or the other
might give better result depending on your document.
<br/> """))
self.addSetting("formatTo", "combo",
qApp.translate("Import", "Import using:"),
vals="markdown|OPML")
self.addSetting("wrap", "combo",
qApp.translate("Import", "Wrap lines:"),
vals="auto|none|preserve",
default="none",
tooltip=qApp.translate("Import", """<p>Should pandoc create
cosmetic / non-semantic line-breaks?</p><p>
<b>auto</b>: wraps at 72 characters.<br>
<b>none</b>: no line wrap.<br>
<b>preserve</b>: tries to preserves line wrap from the
original document.</p>"""))
for s in self.settings:
self.settings[s].widget(group)
self.mdImporter = markdownImporter()
widget = self.mdImporter.settingsWidget(widget)
self.opmlImporter = opmlImporter()
widget = self.opmlImporter.settingsWidget(widget)
return widget
def settingsWidget(self, widget):
"""
Takes a QWidget that can be modified and must be returned.
"""
# Add group
group = self.addGroup(widget.toolBox.widget(0),
qApp.translate("Import", "Markdown import"))
#group = cls.addPage(widget, "Folder import")
self.addSetting(
"info", "label",
qApp.translate(
"Import", """<b>Info:</b> A very simple
parser that will go through a markdown document and
create items for each titles.<br/> """))
for s in self.settings:
self.settings[s].widget(group)
return widget
def settingsWidget(self, widget):
"""
Takes a QWidget that can be modified and must be returned.
"""
# Add group
group = self.addGroup(widget.toolBox.widget(0),
qApp.translate("Import", "Folder import"))
#group = cls.addPage(widget, "Folder import")
self.addSetting("info", "label",
qApp.translate("Import", """<p><b>Info:</b> Imports a whole
directory structure. Folders are added as folders, and
plaintext documents within (you chose which ones by extension)
are added as scene.</p>
<p>Only text files are supported (not images, binary or others).</p>"""))
self.addSetting("ext", "text",
qApp.translate("Import", "Include only those extensions:"),
default="*.txt, *.md",
tooltip=qApp.translate("Import", "Comma separated values")),
self.addSetting("sortItems", "checkbox",
qApp.translate("Import", "Sort items by name"),
default=True),
self.addSetting("separateFolderFiles", "checkbox",
qApp.translate("Import", "Import folder then files"),
default=True),
self.addSettingsTo(group)
return widget
def tooltip(ref):
"""Returns a tooltip in HTML for the reference ``ref``."""
match = re.fullmatch(RegEx, ref)
if not match:
return qApp.translate("references", "Not a reference: {}.").format(ref)
_type = match.group(1)
_ref = match.group(2)
if _type == TextLetter:
m = mainWindow().mdlOutline
idx = m.getIndexByID(_ref)
if not idx.isValid():
return qApp.translate("references", "Unknown reference: {}.").format(ref)
item = idx.internalPointer()
if item.isFolder():
tt = qApp.translate("references", "Folder: <b>{}</b>").format(item.title())
else:
tt = qApp.translate("references", "Text: <b>{}</b>").format(item.title())
tt += "<br><i>{}</i>".format(item.path())
return tt
elif _type == PersoLetter:
m = mainWindow().mdlPersos
item = m.item(int(_ref), Perso.name.value)
if item:
return qApp.translate("references", "Character: <b>{}</b>").format(item.text())
elif _type == PlotLetter:
m = mainWindow().mdlPlots
name = m.getPlotNameByID(_ref)
if name:
return qApp.translate("references", "Plot: <b>{}</b>").format(name)
elif _type == WorldLetter:
m = mainWindow().mdlWorld
item = m.itemByID(_ref)
if item:
name = item.text()
path = m.path(item)
return qApp.translate("references", "World: <b>{name}</b>{path}").format(
name=name,
path=" <span style='color:gray;'>({})</span>".format(path) if path else "")
return qApp.translate("references", "<b>Unknown reference:</b> {}.").format(ref)
def startImport(self, filePath, parentItem, settingsWidget, fromString=None):
"""
Import/export outline cards in mind map free plane.
"""
ret = False
if filePath != "":
# We have a filePath, so we read the file
try:
with open(filePath, 'rb') as f:
content = f.read()
except:
return None
elif fromString == "":
# We have neither filePath nor fromString, so we leave
return None
else:
# We load from string
content = bytes(fromString, "utf-8")
root = ET.fromstring(content)
node = root.find("node")
items = []
if node is not None:
items.extend(self.parseItems(node, parentItem))
ret = True
if not ret:
QMessageBox.critical(
settingsWidget,
qApp.translate("Import", "Mind Map Import"),
qApp.translate("Import", "This does not appear to be a valid Mind Map file."))
return None
return items
def delete(self):
"""
Shows a warning, and then deletes currently selected indexes.
"""
if not settings.dontShowDeleteWarning:
msg = QMessageBox(QMessageBox.Warning,
qApp.translate("outlineBasics", "About to remove"),
qApp.translate("outlineBasics",
"<p><b>You're about to delete {} item(s).</b></p><p>Are you sure?</p>"
).format(len(self.getSelection())),
QMessageBox.Yes | QMessageBox.Cancel)
chk = QCheckBox("&Don't show this warning in the future.")
msg.setCheckBox(chk)
ret = msg.exec()
if ret == QMessageBox.Cancel:
return
if chk.isChecked():
settings.dontShowDeleteWarning = True
self.model().removeIndexes(self.getSelection())
def convert(self, src, args, outputfile=None):
args = [self.cmd] + args
if outputfile:
args.append("--output={}".format(outputfile))
for name, col, var in [
("Title", 0, "title"),
("Subtitle", 1, "subtitle"),
("Serie", 2, ""),
("Volume", 3, ""),
("Genre", 4, ""),
("License", 5, ""),
("Author", 6, "author"),
("Email", 7, ""),
]:
item = mainWindow().mdlFlatData.item(0, col)
if var and item and item.text().strip():
args.append("--variable={}:{}".format(var, item.text().strip()))
# Add title metatadata required for pandoc >= 2.x
args.append("--metadata=title:{}".format(mainWindow().mdlFlatData.item(0, 0).text().strip()))
qApp.setOverrideCursor(QCursor(Qt.WaitCursor))
p = subprocess.Popen(
args,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
if not type(src) == bytes:
src = src.encode("utf-8") # assumes utf-8
stdout, stderr = p.communicate(src)
qApp.restoreOverrideCursor()
if stderr or p.returncode != 0:
err = "ERROR on export" + "\n" \
+ "Return code" + ": %d\n" % (p.returncode) \
+ "Command and parameters" + ":\n%s\n" % (p.args) \
+ "Stderr content" + ":\n" + stderr.decode("utf-8")
print(err)
QMessageBox.critical(mainWindow().dialog, qApp.translate("Export", "Error"), err)
return None
return stdout.decode("utf-8")
def listReferences(ref, title=qApp.translate("references", "Referenced in:")):
oM = mainWindow().mdlOutline
listRefs = ""
lst = findReferencesTo(ref)
for t in lst:
idx = oM.getIndexByID(t)
listRefs += "<li><a href='{link}'>{text}</a></li>".format(
link=textReference(t),
text=oM.data(idx, Outline.title))
return "<h2>{title}</h2><ul>{ref}</ul>".format(
title=title,
ref=listRefs) if listRefs else ""
def getExportFilename(self, settingsWidget, varName=None, filter=None):
if varName is None:
varName = self.exportVarName
if filter is None:
filter = self.exportFilter
settings = settingsWidget.getSettings()
s = settings.get("Output", {})
if varName in s:
filename = s[varName]
else:
filename = ""
filename, filter = QFileDialog.getSaveFileName(settingsWidget.parent(),
caption=qApp.translate("Export", "Choose output file..."),
filter=filter,
directory=filename)
if filename:
s[varName] = filename
settingsWidget.settings["Output"] = s
# Auto adds extension if necessary
try:
# Extract the extension from "Some name (*.ext)"
ext = filter.split("(")[1].split(")")[0]
ext = ext.split(".")[1]
if " " in ext: # In case there are multiple extensions: "Images (*.png *.jpg)"
ext = ext.split(" ")[0]
except:
ext = ""
if ext and filename[-len(ext)-1:] != ".{}".format(ext):
filename += "." + ext
# Save settings
settingsWidget.writeSettings()
return filename
def convert(self, src, _from="markdown", to="html", args=None, outputfile=None):
if not self.isValid:
print("ERROR: pandocConverter is called but not valid.")
return ""
cmd = [self.runCmd()]
cmd += ["--from={}".format(_from)]
cmd += ["--to={}".format(to)]
if args:
cmd += args
if outputfile:
cmd.append("--output={}".format(outputfile))
qApp.setOverrideCursor(QCursor(Qt.WaitCursor))
p = subprocess.Popen(
cmd,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
if not type(src) == bytes:
src = src.encode("utf-8") # assumes utf-8
stdout, stderr = p.communicate(src)
qApp.restoreOverrideCursor()
if stderr:
err = stderr.decode("utf-8")
print(err)
QMessageBox.critical(mainWindow().dialog,
qApp.translate("Export", "Error"), err)
return None
return stdout.decode("utf-8")
def makePopupMenu(self):
index = self.currentIndex()
sel = self.getSelection()
clipboard = qApp.clipboard()
menu = QMenu(self)
# Get index under cursor
pos = self.viewport().mapFromGlobal(QCursor.pos())
mouseIndex = self.indexAt(pos)
# Get index's title
if mouseIndex.isValid():
title = mouseIndex.internalPointer().title()
elif self.rootIndex().parent().isValid():
# mouseIndex is the background of an item, so we check the parent
mouseIndex = self.rootIndex().parent()
title = mouseIndex.internalPointer().title()
else:
title = qApp.translate("outlineBasics", "Root")
if len(title) > 25:
title = title[:25] + "…"
# Open Item action
self.actOpen = QAction(QIcon.fromTheme("go-right"),
qApp.translate("outlineBasics", "Open {}".format(title)),
menu)
self.actOpen.triggered.connect(self.openItem)
menu.addAction(self.actOpen)
# Open item(s) in new tab
if mouseIndex in sel and len(sel) > 1:
actionTitle = qApp.translate("outlineBasics", "Open {} items in new tabs").format(len(sel))
self._indexesToOpen = sel
else:
actionTitle = qApp.translate("outlineBasics", "Open {} in a new tab").format(title)
self._indexesToOpen = [mouseIndex]
self.actNewTab = QAction(QIcon.fromTheme("go-right"), actionTitle, menu)
self.actNewTab.triggered.connect(self.openItemsInNewTabs)
menu.addAction(self.actNewTab)
menu.addSeparator()
# Add text / folder
self.actAddFolder = QAction(QIcon.fromTheme("folder-new"),
qApp.translate("outlineBasics", "New &Folder"),
menu)
self.actAddFolder.triggered.connect(self.addFolder)
menu.addAction(self.actAddFolder)
self.actAddText = QAction(QIcon.fromTheme("document-new"),
qApp.translate("outlineBasics", "New &Text"),
menu)
self.actAddText.triggered.connect(self.addText)
menu.addAction(self.actAddText)
menu.addSeparator()
# Copy, cut, paste, duplicate
self.actCut = QAction(QIcon.fromTheme("edit-cut"),
qApp.translate("outlineBasics", "C&ut"), menu)
self.actCut.triggered.connect(self.cut)
menu.addAction(self.actCut)
self.actCopy = QAction(QIcon.fromTheme("edit-copy"),
qApp.translate("outlineBasics", "&Copy"), menu)
self.actCopy.triggered.connect(self.copy)
menu.addAction(self.actCopy)
self.actPaste = QAction(QIcon.fromTheme("edit-paste"),
qApp.translate("outlineBasics", "&Paste"), menu)
self.actPaste.triggered.connect(self.paste)
menu.addAction(self.actPaste)
# Rename / duplicate / remove items
self.actDelete = QAction(QIcon.fromTheme("edit-delete"),
qApp.translate("outlineBasics", "&Delete"),
menu)
self.actDelete.triggered.connect(self.delete)
menu.addAction(self.actDelete)
self.actRename = QAction(QIcon.fromTheme("edit-rename"),
qApp.translate("outlineBasics", "&Rename"),
menu)
self.actRename.triggered.connect(self.rename)
menu.addAction(self.actRename)
menu.addSeparator()
# POV
self.menuPOV = QMenu(qApp.translate("outlineBasics", "Set POV"), menu)
mw = mainWindow()
a = QAction(QIcon.fromTheme("dialog-no"), qApp.translate("outlineBasics", "None"), self.menuPOV)
a.triggered.connect(lambda: self.setPOV(""))
self.menuPOV.addAction(a)
self.menuPOV.addSeparator()
menus = []
for i in [qApp.translate("outlineBasics", "Main"),
qApp.translate("outlineBasics", "Secondary"),
qApp.translate("outlineBasics", "Minor")]:
m = QMenu(i, self.menuPOV)
menus.append(m)
self.menuPOV.addMenu(m)
mpr = QSignalMapper(self.menuPOV)
for i in range(mw.mdlCharacter.rowCount()):
a = QAction(mw.mdlCharacter.icon(i), mw.mdlCharacter.name(i), self.menuPOV)
a.triggered.connect(mpr.map)
mpr.setMapping(a, int(mw.mdlCharacter.ID(i)))
imp = toInt(mw.mdlCharacter.importance(i))
menus[2 - imp].addAction(a)
mpr.mapped.connect(self.setPOV)
menu.addMenu(self.menuPOV)
# Status
self.menuStatus = QMenu(qApp.translate("outlineBasics", "Set Status"), menu)
# a = QAction(QIcon.fromTheme("dialog-no"), qApp.translate("outlineBasics", "None"), self.menuStatus)
# a.triggered.connect(lambda: self.setStatus(""))
# self.menuStatus.addAction(a)
# self.menuStatus.addSeparator()
mpr = QSignalMapper(self.menuStatus)
for i in range(mw.mdlStatus.rowCount()):
a = QAction(mw.mdlStatus.item(i, 0).text(), self.menuStatus)
a.triggered.connect(mpr.map)
mpr.setMapping(a, i)
self.menuStatus.addAction(a)
mpr.mapped.connect(self.setStatus)
menu.addMenu(self.menuStatus)
# Labels
self.menuLabel = QMenu(qApp.translate("outlineBasics", "Set Label"), menu)
mpr = QSignalMapper(self.menuLabel)
for i in range(mw.mdlLabels.rowCount()):
a = QAction(mw.mdlLabels.item(i, 0).icon(),
mw.mdlLabels.item(i, 0).text(),
self.menuLabel)
a.triggered.connect(mpr.map)
mpr.setMapping(a, i)
self.menuLabel.addAction(a)
mpr.mapped.connect(self.setLabel)
menu.addMenu(self.menuLabel)
menu.addSeparator()
# Custom icons
if self.menuCustomIcons:
menu.addMenu(self.menuCustomIcons)
else:
self.menuCustomIcons = QMenu(qApp.translate("outlineBasics", "Set Custom Icon"), menu)
a = QAction(qApp.translate("outlineBasics", "Restore to default"), self.menuCustomIcons)
a.triggered.connect(lambda: self.setCustomIcon(""))
self.menuCustomIcons.addAction(a)
self.menuCustomIcons.addSeparator()
txt = QLineEdit()
txt.textChanged.connect(self.filterLstIcons)
txt.setPlaceholderText("Filter icons")
txt.setStyleSheet("QLineEdit { background: transparent; border: none; }")
act = QWidgetAction(self.menuCustomIcons)
act.setDefaultWidget(txt)
self.menuCustomIcons.addAction(act)
self.lstIcons = QListWidget()
for i in customIcons():
item = QListWidgetItem()
item.setIcon(QIcon.fromTheme(i))
item.setData(Qt.UserRole, i)
item.setToolTip(i)
self.lstIcons.addItem(item)
self.lstIcons.itemClicked.connect(self.setCustomIconFromItem)
self.lstIcons.setViewMode(self.lstIcons.IconMode)
self.lstIcons.setUniformItemSizes(True)
self.lstIcons.setResizeMode(self.lstIcons.Adjust)
self.lstIcons.setMovement(self.lstIcons.Static)
self.lstIcons.setStyleSheet("background: transparent; background: none;")
self.filterLstIcons("")
act = QWidgetAction(self.menuCustomIcons)
act.setDefaultWidget(self.lstIcons)
self.menuCustomIcons.addAction(act)
menu.addMenu(self.menuCustomIcons)
# Disabling stuff
if not clipboard.mimeData().hasFormat("application/xml"):
self.actPaste.setEnabled(False)
if len(sel) == 0:
self.actCopy.setEnabled(False)
self.actCut.setEnabled(False)
self.actRename.setEnabled(False)
self.actDelete.setEnabled(False)
self.menuPOV.setEnabled(False)
self.menuStatus.setEnabled(False)
self.menuLabel.setEnabled(False)
self.menuCustomIcons.setEnabled(False)
if len(sel) > 1:
self.actRename.setEnabled(False)
return menu
def parseItems(self, underElement, parentItem=None):
items = []
# Title
title = underElement.get('TEXT', "").replace("\n", " ")
if not title:
title = qApp.translate("Import", "Untitled")
item = outlineItem(parent=parentItem, title=title)
items.append(item)
# URL
url = underElement.get('LINK', None)
# Rich text content
content = ""
content = underElement.find("richcontent")
if content is not None:
# In Freemind, can be note or node
# Note: it's a note
# Node: it's the title of the node, in rich text
content_type = content.get("TYPE", "NOTE")
content = ET.tostring(content.find("html"))
if content and content_type == "NODE":
# Content is title
# convert rich text title (in html) to plain text
title = HTML2PlainText(content) #.replace("\n", " ").strip()
# Count the number of lines
lines = [l.strip() for l in title.split("\n") if l.strip()]
# If there is one line, we use it as title.
# Otherwise we leave it to be inserted as a note.
if len(lines) == 1:
item.setData(Outline.title, "".join(lines))
content = ""
if content:
# Set the note content as text value
content = HTML2MD(content)
item.setData(Outline.notes, content)
if url:
# Set the url in notes
item.setData(Outline.notes,
item.data(Outline.notes) + "\n\n" + url)
children = underElement.findall('node')
# Process children
if children is not None and len(children) > 0:
for c in children:
items.extend(self.parseItems(c, item))
# Process if no children
elif self.getSetting("importTipAs").value() == "Text":
# Transform item to text
item.setData(Outline.type, 'md')
# Move notes to text
if item.data(Outline.notes):
item.setData(Outline.text, item.data(Outline.notes))
item.setData(Outline.notes, "")
return items
def infos(ref):
"""Returns a full paragraph in HTML format
containing detailed infos about the reference ``ref``.
"""
match = re.fullmatch(RegEx, ref)
if not match:
return qApp.translate("references", "Not a reference: {}.").format(ref)
_type = match.group(1)
_ref = match.group(2)
# A text or outline item
if _type == TextLetter:
m = mainWindow().mdlOutline
idx = m.getIndexByID(_ref)
if not idx.isValid():
return qApp.translate("references", "Unknown reference: {}.").format(ref)
item = idx.internalPointer()
# Titles
pathTitle = qApp.translate("references", "Path:")
statsTitle = qApp.translate("references", "Stats:")
POVTitle = qApp.translate("references", "POV:")
statusTitle = qApp.translate("references", "Status:")
labelTitle = qApp.translate("references", "Label:")
ssTitle = qApp.translate("references", "Short summary:")
lsTitle = qApp.translate("references", "Long summary:")
notesTitle = qApp.translate("references", "Notes:")
# The POV of the scene
POV = ""
if item.POV():
POV = "<a href='{ref}'>{text}</a>".format(
ref=characterReference(item.POV()),
text=mainWindow().mdlCharacter.getCharacterByID(item.POV()).name())
# The status of the scene
status = item.status()
if status:
status = mainWindow().mdlStatus.item(int(status), 0).text()
else:
status = ""
# The label of the scene
label = item.label()
if label:
label = mainWindow().mdlLabels.item(int(label), 0).text()
else:
label = ""
# The path of the scene
path = item.pathID()
pathStr = []
for _id, title in path:
pathStr.append("<a href='{ref}'>{text}</a>".format(
ref=textReference(_id),
text=title))
path = " > ".join(pathStr)
# Summaries and notes
ss = item.data(Outline.summarySentence)
ls = item.data(Outline.summaryFull)
notes = item.data(Outline.notes)
text = """<h1>{title}</h1>
<p><b>{pathTitle}</b> {path}</p>
<p><b>{statsTitle}</b> {stats}<br>
{POV}
{status}
{label}</p>
{ss}
{ls}
{notes}
{references}
""".format(
title=item.title(),
pathTitle=pathTitle,
path=path,
statsTitle=statsTitle,
stats=item.stats(),
POV="<b>{POVTitle}</b> {POV}<br>".format(
POVTitle=POVTitle,
POV=POV) if POV else "",
status="<b>{statusTitle}</b> {status}<br>".format(
statusTitle=statusTitle,
status=status) if status else "",
label="<b>{labelTitle}</b> {label}</p>".format(
labelTitle=labelTitle,
label=label) if label else "",
ss="<p><b>{ssTitle}</b> {ss}</p>".format(
ssTitle=ssTitle,
ss=ss.replace("\n", "<br>")) if ss.strip() else "",
ls="<p><b>{lsTitle}</b><br>{ls}</p>".format(
lsTitle=lsTitle,
ls=ls.replace("\n", "<br>")) if ls.strip() else "",
notes="<p><b>{notesTitle}</b><br>{notes}</p>".format(
notesTitle=notesTitle,
notes=linkifyAllRefs(notes)) if notes.strip() else "",
references=listReferences(ref)
)
return text
# A character
elif _type == CharacterLetter:
m = mainWindow().mdlCharacter
c = m.getCharacterByID(int(_ref))
if c is None:
return qApp.translate("references", "Unknown reference: {}.").format(ref)
index = c.index()
name = c.name()
# Titles
basicTitle = qApp.translate("references", "Basic info")
detailedTitle = qApp.translate("references", "Detailed info")
POVof = qApp.translate("references", "POV of:")
# Goto (link)
goto = qApp.translate("references", "Go to {}.")
goto = goto.format(refToLink(ref))
# basic infos
basic = []
for i in [
(Character.motivation, qApp.translate("references", "Motivation"), False),
(Character.goal, qApp.translate("references", "Goal"), False),
(Character.conflict, qApp.translate("references", "Conflict"), False),
(Character.epiphany, qApp.translate("references", "Epiphany"), False),
(Character.summarySentence, qApp.translate("references", "Short summary"), True),
(Character.summaryPara, qApp.translate("references", "Longer summary"), True),
]:
val = m.data(index.sibling(index.row(), i[0].value))
if val:
basic.append("<b>{title}:</b>{n}{val}".format(
title=i[1],
n="\n" if i[2] else " ",
val=val))
basic = "<br>".join(basic)
# detailed infos
detailed = []
for _name, _val in c.listInfos():
detailed.append("<b>{}:</b> {}".format(
_name,
_val))
detailed = "<br>".join(detailed)
# list scenes of which it is POV
oM = mainWindow().mdlOutline
lst = oM.findItemsByPOV(_ref)
listPOV = ""
for t in lst:
idx = oM.getIndexByID(t)
listPOV += "<li><a href='{link}'>{text}</a></li>".format(
link=textReference(t),
text=oM.data(idx, Outline.title))
text = """<h1>{name}</h1>
{goto}
{basicInfos}
{detailedInfos}
{POV}
{references}
""".format(
name=name,
goto=goto,
basicInfos="<h2>{basicTitle}</h2>{basic}".format(
basicTitle=basicTitle,
basic=basic) if basic else "",
detailedInfos="<h2>{detailedTitle}</h2>{detailed}".format(
detailedTitle=detailedTitle,
detailed=detailed) if detailed else "",
POV="<h2>{POVof}</h2><ul>{listPOV}</ul>".format(
POVof=POVof,
listPOV=listPOV) if listPOV else "",
references=listReferences(ref)
)
return text
# A plot
elif _type == PlotLetter:
m = mainWindow().mdlPlots
index = m.getIndexFromID(_ref)
name = m.getPlotNameByID(_ref)
if not index.isValid():
return qApp.translate("references", "Unknown reference: {}.").format(ref)
# Titles
descriptionTitle = qApp.translate("references", "Description")
resultTitle = qApp.translate("references", "Result")
charactersTitle = qApp.translate("references", "Characters")
stepsTitle = qApp.translate("references", "Resolution steps")
# Goto (link)
goto = qApp.translate("references", "Go to {}.")
goto = goto.format(refToLink(ref))
# Description
description = m.data(index.sibling(index.row(),
Plot.description))
# Result
result = m.data(index.sibling(index.row(),
Plot.result))
# Characters
pM = mainWindow().mdlCharacter
item = m.item(index.row(), Plot.characters)
characters = ""
if item:
for r in range(item.rowCount()):
ID = item.child(r, 0).text()
characters += "<li><a href='{link}'>{text}</a>".format(
link=characterReference(ID),
text=pM.getCharacterByID(ID).name())
# Resolution steps
steps = ""
item = m.item(index.row(), Plot.steps)
if item:
for r in range(item.rowCount()):
title = item.child(r, PlotStep.name).text()
summary = item.child(r, PlotStep.summary).text()
meta = item.child(r, PlotStep.meta).text()
if meta:
meta = " <span style='color:gray;'>({})</span>".format(meta)
steps += "<li><b>{title}</b>{summary}{meta}</li>".format(
title=title,
summary=": {}".format(summary) if summary else "",
meta=meta if meta else "")
text = """<h1>{name}</h1>
{goto}
{characters}
{description}
{result}
{steps}
{references}
""".format(
name=name,
goto=goto,
description="<h2>{title}</h2>{text}".format(
title=descriptionTitle,
text=description) if description else "",
result="<h2>{title}</h2>{text}".format(
title=resultTitle,
text=result) if result else "",
characters="<h2>{title}</h2><ul>{lst}</ul>".format(
title=charactersTitle,
lst=characters) if characters else "",
steps="<h2>{title}</h2><ul>{steps}</ul>".format(
title=stepsTitle,
steps=steps) if steps else "",
references=listReferences(ref)
)
return text
# A World item
elif _type == WorldLetter:
m = mainWindow().mdlWorld
index = m.indexByID(_ref)
name = m.name(index)
if not index.isValid():
return qApp.translate("references", "Unknown reference: {}.").format(ref)
# Titles
descriptionTitle = qApp.translate("references", "Description")
passionTitle = qApp.translate("references", "Passion")
conflictTitle = qApp.translate("references", "Conflict")
# Goto (link)
goto = qApp.translate("references", "Go to {}.")
goto = goto.format(refToLink(ref))
# Description
description = basicFormat(m.description(index))
# Passion
passion = basicFormat(m.passion(index))
# Conflict
conflict = basicFormat(m.conflict(index))
text = """<h1>{name}</h1>
{goto}
{description}
{passion}
{conflict}
{references}
""".format(
name=name,
goto=goto,
description="<h2>{title}</h2>{text}".format(
title=descriptionTitle,
text=description) if description else "",
passion="<h2>{title}</h2>{text}".format(
title=passionTitle,
text=passion) if passion else "",
conflict="<h2>{title}</h2><ul>{lst}</ul>".format(
title=conflictTitle,
lst=conflict) if conflict else "",
references=listReferences(ref)
)
return text
else:
return qApp.translate("references", "Unknown reference: {}.").format(ref)
# --!-- coding: utf8 --!--
import collections
from PyQt5.QtWidgets import qApp
from manuskript.exporter.arbo import arboExporter
from manuskript.exporter.html import htmlExporter
from manuskript.exporter.odt import odtExporter
formats = collections.OrderedDict([
# Format
# Readable name
# Class
# QFileDialog filter
('html', (
qApp.translate("exporter", "HTML"),
htmlExporter,
qApp.translate("exporter", "HTML Document (*.html)"))),
('arbo', (
qApp.translate("exporter", "Arborescence"),
arboExporter,
None)),
('odt', (
qApp.translate("exporter", "OpenDocument (LibreOffice)"),
odtExporter,
qApp.translate("exporter", "OpenDocument (*.odt)"))),
('epub', (
"ePub (not yet)",
None,
None)),
])
def createNewText(self):
item = self._index.internalPointer()
newItem = outlineItem(title=qApp.translate("outlineBasics", "New"), _type=settings.defaultTextType)
self._index.model().insertItem(newItem, item.row() + 1, item.parent().index())
self.setCurrentModelIndex(newItem.index())
def makePopupMenu(self):
index = self.currentIndex()
sel = self.getSelection()
clipboard = qApp.clipboard()
menu = QMenu(self)
# Add / remove items
self.actAddFolder = QAction(QIcon.fromTheme("folder-new"), qApp.translate("outlineBasics", "New Folder"), menu)
self.actAddFolder.triggered.connect(self.addFolder)
menu.addAction(self.actAddFolder)
self.actAddText = QAction(QIcon.fromTheme("document-new"), qApp.translate("outlineBasics", "New Text"), menu)
self.actAddText.triggered.connect(self.addText)
menu.addAction(self.actAddText)
self.actDelete = QAction(QIcon.fromTheme("edit-delete"), qApp.translate("outlineBasics", "Delete"), menu)
self.actDelete.triggered.connect(self.delete)
menu.addAction(self.actDelete)
menu.addSeparator()
# Copy, cut, paste
self.actCopy = QAction(QIcon.fromTheme("edit-copy"), qApp.translate("outlineBasics", "Copy"), menu)
self.actCopy.triggered.connect(self.copy)
menu.addAction(self.actCopy)
self.actCut = QAction(QIcon.fromTheme("edit-cut"), qApp.translate("outlineBasics", "Cut"), menu)
self.actCut.triggered.connect(self.cut)
menu.addAction(self.actCut)
self.actPaste = QAction(QIcon.fromTheme("edit-paste"), qApp.translate("outlineBasics", "Paste"), menu)
self.actPaste.triggered.connect(self.paste)
menu.addAction(self.actPaste)
menu.addSeparator()
# POV
self.menuPOV = QMenu(qApp.translate("outlineBasics", "Set POV"), menu)
mw = mainWindow()
a = QAction(QIcon.fromTheme("dialog-no"), qApp.translate("outlineBasics", "None"), self.menuPOV)
a.triggered.connect(lambda: self.setPOV(""))
self.menuPOV.addAction(a)
self.menuPOV.addSeparator()
menus = []
for i in [self.tr("Main"), self.tr("Secondary"), self.tr("Minor")]:
m = QMenu(i, self.menuPOV)
menus.append(m)
self.menuPOV.addMenu(m)
mpr = QSignalMapper(self.menuPOV)
for i in range(mw.mdlPersos.rowCount()):
a = QAction(mw.mdlPersos.icon(i), mw.mdlPersos.name(i), self.menuPOV)
a.triggered.connect(mpr.map)
mpr.setMapping(a, int(mw.mdlPersos.ID(i)))
imp = toInt(mw.mdlPersos.importance(i))
menus[2 - imp].addAction(a)
mpr.mapped.connect(self.setPOV)
menu.addMenu(self.menuPOV)
# Status
self.menuStatus = QMenu(qApp.translate("outlineBasics", "Set Status"), menu)
# a = QAction(QIcon.fromTheme("dialog-no"), qApp.translate("outlineBasics", "None"), self.menuStatus)
# a.triggered.connect(lambda: self.setStatus(""))
# self.menuStatus.addAction(a)
# self.menuStatus.addSeparator()
mpr = QSignalMapper(self.menuStatus)
for i in range(mw.mdlStatus.rowCount()):
a = QAction(mw.mdlStatus.item(i, 0).text(), self.menuStatus)
a.triggered.connect(mpr.map)
mpr.setMapping(a, i)
self.menuStatus.addAction(a)
mpr.mapped.connect(self.setStatus)
menu.addMenu(self.menuStatus)
# Labels
self.menuLabel = QMenu(qApp.translate("outlineBasics", "Set Label"), menu)
mpr = QSignalMapper(self.menuLabel)
for i in range(mw.mdlLabels.rowCount()):
a = QAction(mw.mdlLabels.item(i, 0).icon(),
mw.mdlLabels.item(i, 0).text(),
self.menuLabel)
a.triggered.connect(mpr.map)
mpr.setMapping(a, i)
self.menuLabel.addAction(a)
mpr.mapped.connect(self.setLabel)
menu.addMenu(self.menuLabel)
if len(sel) > 0 and index.isValid() and not index.internalPointer().isFolder() \
or not clipboard.mimeData().hasFormat("application/xml"):
self.actPaste.setEnabled(False)
if len(sel) > 0 and index.isValid() and not index.internalPointer().isFolder():
self.actAddFolder.setEnabled(False)
self.actAddText.setEnabled(False)
if len(sel) == 0:
self.actCopy.setEnabled(False)
self.actCut.setEnabled(False)
self.actDelete.setEnabled(False)
self.menuPOV.setEnabled(False)
self.menuStatus.setEnabled(False)
self.menuLabel.setEnabled(False)
return menu
