class CharMap(preferences.Group):
def __init__(self, page):
super(CharMap, self).__init__(page)
layout = QVBoxLayout()
self.setLayout(layout)
self.fontLabel = QLabel()
self.fontChooser = QFontComboBox(currentFontChanged=self.changed)
self.fontSize = QDoubleSpinBox(valueChanged=self.changed)
self.fontSize.setRange(6.0, 32.0)
self.fontSize.setSingleStep(0.5)
self.fontSize.setDecimals(1)
box = QHBoxLayout()
box.addWidget(self.fontLabel)
box.addWidget(self.fontChooser, 1)
box.addWidget(self.fontSize)
layout.addLayout(box)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("Special Characters"))
self.fontLabel.setText(_("Font:"))
def loadSettings(self):
s = QSettings()
s.beginGroup("charmaptool")
font = self.font()
family = s.value("fontfamily", "", str)
if family:
font.setFamily(family)
font.setPointSizeF(s.value("fontsize", font.pointSizeF(), float))
with qutil.signalsBlocked(self.fontChooser, self.fontSize):
self.fontChooser.setCurrentFont(font)
self.fontSize.setValue(font.pointSizeF())
def saveSettings(self):
s = QSettings()
s.beginGroup("charmaptool")
s.setValue("fontfamily", self.fontChooser.currentFont().family())
s.setValue("fontsize", self.fontSize.value())
class FontLayout(QGridLayout):
"""Font selection"""
def __init__(self, value, parent=None):
QGridLayout.__init__(self)
font = tuple_to_qfont(value)
assert font is not None
# Font family
self.family = QFontComboBox(parent)
self.family.setCurrentFont(font)
self.addWidget(self.family, 0, 0, 1, -1)
# Font size
self.size = QComboBox(parent)
self.size.setEditable(True)
sizelist = list(range(6, 12)) + list(range(12, 30, 2)) + [36, 48, 72]
size = font.pointSize()
if size not in sizelist:
sizelist.append(size)
sizelist.sort()
self.size.addItems([str(s) for s in sizelist])
self.size.setCurrentIndex(sizelist.index(size))
self.addWidget(self.size, 1, 0)
# Italic or not
self.italic = QCheckBox(self.tr("Italic"), parent)
self.italic.setChecked(font.italic())
self.addWidget(self.italic, 1, 1)
# Bold or not
self.bold = QCheckBox(self.tr("Bold"), parent)
self.bold.setChecked(font.bold())
self.addWidget(self.bold, 1, 2)
def get_font(self):
font = self.family.currentFont()
font.setItalic(self.italic.isChecked())
font.setBold(self.bold.isChecked())
font.setPointSize(int(self.size.currentText()))
return qfont_to_tuple(font)
class LogTool(preferences.Group):
def __init__(self, page):
super(LogTool, self).__init__(page)
layout = QVBoxLayout()
self.setLayout(layout)
self.fontLabel = QLabel()
self.fontChooser = QFontComboBox(currentFontChanged=self.changed)
self.fontSize = QDoubleSpinBox(valueChanged=self.changed)
self.fontSize.setRange(6.0, 32.0)
self.fontSize.setSingleStep(0.5)
self.fontSize.setDecimals(1)
box = QHBoxLayout()
box.addWidget(self.fontLabel)
box.addWidget(self.fontChooser, 1)
box.addWidget(self.fontSize)
layout.addLayout(box)
self.showlog = QCheckBox(toggled=self.changed)
layout.addWidget(self.showlog)
self.rawview = QCheckBox(toggled=self.changed)
layout.addWidget(self.rawview)
self.hideauto = QCheckBox(toggled=self.changed)
layout.addWidget(self.hideauto)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("LilyPond Log"))
self.fontLabel.setText(_("Font:"))
self.showlog.setText(_("Show log when a job is started"))
self.rawview.setText(_("Display plain log output"))
self.rawview.setToolTip(
_("If checked, Frescobaldi will not shorten filenames in the log output."
""))
self.hideauto.setText(_("Hide automatic engraving jobs"))
self.hideauto.setToolTip(
_("If checked, Frescobaldi will not show the log for automatically\n"
"started engraving jobs (LilyPond->Auto-engrave)."))
def loadSettings(self):
s = QSettings()
s.beginGroup("log")
font = QFont(s.value("fontfamily", "monospace", str))
font.setPointSizeF(s.value("fontsize", 9.0, float))
with qutil.signalsBlocked(self.fontChooser, self.fontSize):
self.fontChooser.setCurrentFont(font)
self.fontSize.setValue(font.pointSizeF())
self.showlog.setChecked(s.value("show_on_start", True, bool))
self.rawview.setChecked(s.value("rawview", True, bool))
self.hideauto.setChecked(s.value("hide_auto_engrave", False, bool))
def saveSettings(self):
s = QSettings()
s.beginGroup("log")
s.setValue("fontfamily", self.fontChooser.currentFont().family())
s.setValue("fontsize", self.fontSize.value())
s.setValue("show_on_start", self.showlog.isChecked())
s.setValue("rawview", self.rawview.isChecked())
s.setValue("hide_auto_engrave", self.hideauto.isChecked())
class GlobalFontDialog(widgets.dialog.Dialog):
def __init__(self, parent=None):
super(GlobalFontDialog, self).__init__(parent)
self._messageLabel.setWordWrap(True)
layout = QGridLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.mainWidget().setLayout(layout)
self.romanLabel = QLabel()
self.romanCombo = QFontComboBox()
self.sansLabel = QLabel()
self.sansCombo = QFontComboBox()
self.typewriterLabel = QLabel()
self.typewriterCombo = QFontComboBox(
fontFilters=QFontComboBox.MonospacedFonts)
layout.addWidget(self.romanLabel, 0, 0)
layout.addWidget(self.romanCombo, 0, 1, 1, 2)
layout.addWidget(self.sansLabel, 1, 0)
layout.addWidget(self.sansCombo, 1, 1, 1, 2)
layout.addWidget(self.typewriterLabel, 2, 0)
layout.addWidget(self.typewriterCombo, 2, 1, 1, 2)
self.loadSettings()
self.finished.connect(self.saveSettings)
app.translateUI(self)
def translateUI(self):
self.setWindowTitle(app.caption(_("Global Fonts")))
self.setMessage(
_("Please select the three global fonts to use for "
r"<code>\roman</code>, <code>\sans</code>, and <code>\typewriter</code> "
"respectively."))
self.romanLabel.setText(_("Roman Font:"))
self.sansLabel.setText(_("Sans Font:"))
self.typewriterLabel.setText(_("Typewriter Font:"))
def romanFont(self):
return self.romanCombo.currentFont().family()
def setromanFont(self, family):
self.romanCombo.setCurrentFont(QFont(family))
def sansFont(self):
return self.sansCombo.currentFont().family()
def setSansFont(self, family):
self.sansCombo.setCurrentFont(QFont(family))
def typewriterFont(self):
return self.typewriterCombo.currentFont().family()
def settypewriterFont(self, family):
self.typewriterCombo.setCurrentFont(QFont(family))
def loadSettings(self):
s = QSettings()
s.beginGroup("global_font_dialog")
roman = s.value("roman", "Century Schoolbook L", str)
self.romanCombo.setCurrentFont(QFont(roman))
sans = s.value("sans", "sans-serif", str)
self.sansCombo.setCurrentFont(QFont(sans))
typewriter = s.value("typewriter", "monospace", str)
self.typewriterCombo.setCurrentFont(QFont(typewriter))
def saveSettings(self):
s = QSettings()
s.beginGroup("global_font_dialog")
s.setValue("roman", self.romanCombo.currentFont().family())
s.setValue("sans", self.sansCombo.currentFont().family())
s.setValue("typewriter", self.typewriterCombo.currentFont().family())
rotationSliderY = QSlider(Qt.Horizontal)
rotationSliderY.setTickInterval(15)
rotationSliderY.setTickPosition(QSlider.TicksAbove)
rotationSliderY.setMinimum(-90)
rotationSliderY.setValue(0)
rotationSliderY.setMaximum(90)
fontSizeSlider = QSlider(Qt.Horizontal)
fontSizeSlider.setTickInterval(10)
fontSizeSlider.setTickPosition(QSlider.TicksBelow)
fontSizeSlider.setMinimum(1)
fontSizeSlider.setValue(30)
fontSizeSlider.setMaximum(100)
fontList = QFontComboBox()
fontList.setCurrentFont(QFont('Times New Roman'))
shadowQuality = QComboBox()
shadowQuality.addItem("None")
shadowQuality.addItem("Low")
shadowQuality.addItem("Medium")
shadowQuality.addItem("High")
shadowQuality.addItem("Low Soft")
shadowQuality.addItem("Medium Soft")
shadowQuality.addItem("High Soft")
shadowQuality.setCurrentIndex(5)
rangeList = QComboBox()
rangeList.addItems(GraphModifier.years)
rangeList.addItem("All")
rangeList.setCurrentIndex(len(GraphModifier.years))
checked=True)
gridCheckBox = QCheckBox(Tr.get("Show grid", "Show grid"), checked=True)
shadowQuality = QComboBox()
shadowQuality.addItem("None")
shadowQuality.addItem("Low")
shadowQuality.addItem("Medium")
shadowQuality.addItem("High")
shadowQuality.addItem("Low Soft")
shadowQuality.addItem("Medium Soft")
shadowQuality.addItem("High Soft")
shadowQuality.setCurrentIndex(4)
fontList = QFontComboBox()
fontList.setCurrentFont(QFont('Arial'))
vLayout.addWidget(labelButton, 0, Qt.AlignTop)
vLayout.addWidget(cameraButton, 0, Qt.AlignTop)
vLayout.addWidget(itemCountButton, 0, Qt.AlignTop)
vLayout.addWidget(backgroundCheckBox)
vLayout.addWidget(gridCheckBox)
vLayout.addWidget(smoothCheckBox, 0, Qt.AlignTop)
vLayout.addWidget(QLabel(Tr.get("Change dot style", "Change dot style")))
vLayout.addWidget(itemStyleList)
vLayout.addWidget(QLabel(Tr.get("Change theme", "Change theme")))
vLayout.addWidget(themeList)
vLayout.addWidget(
QLabel(Tr.get("Adjust shadow quality", "Adjust shadow quality")))
vLayout.addWidget(shadowQuality)
vLayout.addWidget(QLabel(Tr.get("Change font", "Change font")))
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.view = TextView(self)
self.setCentralWidget(self.view)
self.toolbar = self.addToolBar('Text Effects')
# Set up the text effects tools
actionGroup = QActionGroup(self)
noneAction = QAction(QIcon("none.png"), "&Clear", self)
noneAction.setStatusTip("Clear Effects")
noneAction.triggered.connect(self.view.noEffect)
actionGroup.addAction(noneAction)
blurAction = QAction(QIcon("blur.png"), "&Blur", self)
blurAction.setStatusTip("Blur Text")
blurAction.triggered.connect(self.view.blur)
actionGroup.addAction(blurAction)
opacityAction = QAction(QIcon("opacity.png"), "&Transparency", self)
opacityAction.setStatusTip("Fade Text")
opacityAction.triggered.connect(self.view.opacity)
actionGroup.addAction(opacityAction)
shadowAction = QAction(QIcon("shadow.png"), "&Drop Shadow", self)
shadowAction.setStatusTip("Drop-shadow Text")
shadowAction.triggered.connect(self.view.shadow)
actionGroup.addAction(shadowAction)
self.toolbar.addActions(actionGroup.actions())
self.toolbar.addSeparator()
# Set up the font selection tools
boldAction = QAction(QIcon("bold.png"), "&Bold", self)
boldAction.setStatusTip("Bold Text")
boldAction.setCheckable(True)
boldAction.setChecked(True)
boldAction.triggered[bool].connect(self.view.bold)
self.toolbar.addAction(boldAction)
italicAction = QAction(QIcon("italic.png"), "&Italic", self)
italicAction.setStatusTip("Italic Text")
italicAction.setCheckable(True)
italicAction.triggered[bool].connect(self.view.italic)
self.toolbar.addAction(italicAction)
self.fontBox = QFontComboBox(self)
self.fontBox.setCurrentFont(QFont("PT Sans", 16, QFont.Bold))
self.fontBox.currentFontChanged.connect(self.view.fontFamily)
self.toolbar.addWidget(self.fontBox)
self.fontSizeBox = QComboBox(self)
self.fontSizeBox.setEditable(True)
strlist = []
intlist = QFontDatabase.standardSizes()
for item in intlist:
strlist.append(str(item))
self.fontSizeBox.addItems(strlist)
self.fontSizeBox.setCurrentText("16")
self.fontSizeBox.currentTextChanged.connect(self.view.fontSize)
self.toolbar.addWidget(self.fontSizeBox)
self.setGeometry(300, 300, 600, 500)
self.setWindowTitle('Renderer')
self.show()
class TextItemDlg(QDialog):
def __init__(self, item=None, position=None, scene=None, parent=None):
super(QDialog, self).__init__(parent)
self.item = item
self.position = position
self.scene = scene
self.editor = QTextEdit()
self.editor.setAcceptRichText(False)
self.editor.setTabChangesFocus(True)
editorLabel = QLabel("&Text:")
editorLabel.setBuddy(self.editor)
self.fontComboBox = QFontComboBox()
self.fontComboBox.setCurrentFont(QFont("Times", PointSize))
fontLabel = QLabel("&Font:")
fontLabel.setBuddy(self.fontComboBox)
self.fontSpinBox = QSpinBox()
self.fontSpinBox.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.fontSpinBox.setRange(6, 280)
self.fontSpinBox.setValue(PointSize)
fontSizeLabel = QLabel("&Size:")
fontSizeLabel.setBuddy(self.fontSpinBox)
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
if self.item is not None:
self.editor.setPlainText(self.item.toPlainText())
self.fontComboBox.setCurrentFont(self.item.font())
self.fontSpinBox.setValue(self.item.font().pointSize())
layout = QGridLayout()
layout.addWidget(editorLabel, 0, 0)
layout.addWidget(self.editor, 1, 0, 1, 6)
layout.addWidget(fontLabel, 2, 0)
layout.addWidget(self.fontComboBox, 2, 1, 1, 2)
layout.addWidget(fontSizeLabel, 2, 3)
layout.addWidget(self.fontSpinBox, 2, 4, 1, 2)
layout.addWidget(self.buttonBox, 3, 0, 1, 6)
self.setLayout(layout)
self.fontComboBox.currentFontChanged.connect(self.updateUi)
self.fontSpinBox.valueChanged.connect(self.updateUi)
self.editor.textChanged.connect(self.updateUi)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.setWindowTitle("Page Designer - {0} Text Item".format(
"Add" if self.item is None else "Edit"))
self.updateUi()
def updateUi(self):
font = self.fontComboBox.currentFont()
font.setPointSize(self.fontSpinBox.value())
self.editor.document().setDefaultFont(font)
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(
bool(self.editor.toPlainText()))
def accept(self):
if self.item is None:
self.item = TextItem("", self.position, self.scene)
font = self.fontComboBox.currentFont()
font.setPointSize(self.fontSpinBox.value())
self.item.setFont(font)
self.item.setPlainText(self.editor.toPlainText())
self.item.update()
global Dirty
Dirty = True
QDialog.accept(self)
class BarTop(QWidget):
"""
class that holds the top bar attributes
"""
def __init__(self, path_res: str, document: Document):
"""
sets up the top bar and its features
:return: returns nothing
"""
super().__init__()
logging.debug("Creating Top Bar")
self.path_res: str = path_res
self.document: Document = document
self.doc_props: DocProps = self.document.doc_props
self.combo_title_style = None
self.combo_font_style = None
self.combo_font_size = None
self.button_bold = None
self.button_ital = None
self.button_strike = None
self.button_under = None
self.combo_text_color = None
self.button_clear = None
self.combo_text_align = None
self.button_mode_switch = None
def makeMainLayout(self):
"""
You can get the layout generated with self.layout()
:return: the main layout of the top bar
"""
horizontal_layout = QHBoxLayout()
horizontal_layout.setContentsMargins(0, 0, 0, 0)
horizontal_layout.setSpacing(3)
self.setLayout(horizontal_layout)
self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
return horizontal_layout
def makeTitleStyleBox(self) -> QComboBox:
"""
Create Title Style Drop Down
"""
# ComboBox for title style
self.combo_title_style = QComboBox(self)
view = QListView(self.combo_title_style)
view.setStyleSheet("QListView::item { height : 23 px; }"
"selection-background-color: rgba(0,0,0,0.2);")
self.combo_title_style.setView(view)
self.combo_title_style.setToolTip('Styles')
self.combo_title_style.addItems(self.doc_props.dict_title_styles)
# traverses through combo_title_style items index
for x in range(view.model().rowCount()):
# mods by two to get the index with titles else gives "update" titles index
# changes font to be bold for if and italic for else
if x % 2 == 0:
font = QFont()
font.setWeight(QFont.Bold)
self.combo_title_style.setItemData(x, font, Qt.FontRole)
else:
font = QFont()
color = QBrush()
font.setItalic(True)
color.setColor(QColor("gray"))
self.combo_title_style.setItemData(x, font, Qt.FontRole)
self.combo_title_style.setItemData(x, color, Qt.ForegroundRole)
# adds separators to clean up look of QComboBox
for x in range(2, 23, 3):
size = QSize()
size.setHeight(10)
separator = QStandardItem()
separator.setSizeHint(size)
view.model().insertRow(x, separator)
view.model().item(x).setEnabled(False)
self.combo_title_style.setFocusPolicy(Qt.NoFocus)
self.combo_title_style.setMaxVisibleItems(view.model().rowCount())
self.combo_title_style.setItemData(0, "test", QtCore.Qt.ToolTipRole)
numKey = Qt.Key_1
index = 0
title_list = list(self.doc_props.dict_title_styles.keys())
for key in range(0, 13, 2):
shortcut = QShortcut(QKeySequence(Qt.CTRL + Qt.ALT + numKey), self)
shortcut.activated.connect(
partial(self.titleStyleHelper, title_list[key]))
self.combo_title_style.setItemData(
index, "Ctrl+Alt+" + str(numKey - Qt.Key_1 + 1),
QtCore.Qt.ToolTipRole)
index += 3
numKey += 1
shortcut = QShortcut(QKeySequence(Qt.CTRL + Qt.ALT + Qt.Key_0), self)
shortcut.activated.connect(
partial(self.titleStyleHelper,
self.document.doc_props.text_reset_title))
self.combo_title_style.setItemData(index, "Ctrl+Alt+0",
QtCore.Qt.ToolTipRole)
self.combo_title_style.textActivated.connect(self.titleStyleHelper)
return self.combo_title_style
def titleStyleHelper(self, state):
"""
Helper function for title style
calls function for selected title style type
:return: returns nothing
"""
if self.doc_props.text_update_title not in state and \
self.doc_props.text_reset_title not in state:
self.document.changeTitleStyle(state)
elif self.doc_props.text_update_title in state:
self.document.updateTitleStyle(state)
else:
self.document.resetTitleStyle()
self.combo_title_style.setCurrentIndex(0)
def makeComboFontStyleBox(self) -> QFontComboBox:
"""
Create Font Style DropDown
"""
# ComboBox for font sizes
self.combo_font_style = QFontComboBox(self)
self.combo_font_style.setToolTip('Change font')
self.combo_font_style.setFocusPolicy(Qt.NoFocus)
self.combo_font_style.currentFontChanged.connect(
self.document.onFontStyleChanged)
self.combo_font_style.setCurrentFont(self.document.currentFont())
return self.combo_font_style
def makeComboFontSizeBox(self) -> QComboBox:
"""
Create Font Size Dropdown
"""
# Adds functionality to the ComboBox
self.combo_font_size = QComboBox(self)
self.combo_font_size.setToolTip('Change font size')
self.combo_font_size.addItems(self.doc_props.list_font_sizes)
self.combo_font_size.setFixedWidth(60)
self.combo_font_size.setFocusPolicy(Qt.NoFocus)
self.combo_font_size.setCurrentIndex(
self.doc_props.def_font_size_index)
self.combo_font_size.currentTextChanged.connect(
self.document.onFontSizeChanged)
return self.combo_font_size
def makeBtnBold(self) -> QPushButton:
"""
Create Bold Btn
"""
# Button press to make text bold
self.button_bold = QPushButton("B", self)
self.button_bold.setToolTip('Bold your text. "Ctrl+B"')
self.button_bold.setFixedWidth(33)
self.button_bold.setStyleSheet("QPushButton { font:Bold }")
self.button_bold.setCheckable(True)
self.button_bold.setFocusPolicy(Qt.NoFocus)
self.button_bold.clicked.connect(self.document.onFontBoldChanged)
return self.button_bold
def makeBtnItal(self) -> QPushButton:
"""
Create Ital Btn
"""
# Button press to make text italic
self.button_ital = QPushButton("I", self)
self.button_ital.setToolTip('Italicise your text. "Ctrl+I"')
self.button_ital.setFixedWidth(33)
self.button_ital.setStyleSheet("QPushButton { font:Italic }")
self.button_ital.setCheckable(True)
self.button_ital.setFocusPolicy(Qt.NoFocus)
self.button_ital.clicked.connect(self.document.onFontItalChanged)
return self.button_ital
def makeBtnStrike(self) -> QPushButton:
"""
Create Strike Btn
"""
# Button press to make text strikethrough
self.button_strike = QPushButton("S", self)
self.button_strike.setToolTip('Strikeout your text. "Ctrl+Shift+5"')
self.button_strike.setFixedWidth(33)
f = self.button_strike.font()
f.setStrikeOut(True)
self.button_strike.setFont(f)
# self.button_strike.adjustSize()
self.button_strike.setStyleSheet(
"QPushButton { text-decoration: line-through }")
self.button_strike.setCheckable(True)
self.button_strike.setFocusPolicy(Qt.NoFocus)
self.button_strike.clicked.connect(self.document.onFontStrikeChanged)
return self.button_strike
def makeBtnUnder(self) -> QPushButton:
"""
Create Underline Button
"""
# Button press to underline text
self.button_under = QPushButton("U", self)
self.button_under.setToolTip('Underline your text. "Ctrl+U"')
self.button_under.setFixedWidth(33)
self.button_under.setStyleSheet(
"QPushButton { text-decoration: underline }")
self.button_under.setCheckable(True)
self.button_under.setFocusPolicy(Qt.NoFocus)
self.button_under.clicked.connect(self.document.onFontUnderChanged)
return self.button_under
def updateTextColor(self, index: int):
"""
Updates styles for font color
"""
color_list = list(self.doc_props.dict_colors.values())
style = "QComboBox::drop-down { border: 0px;}" \
"QComboBox { background-color: " + list(color_list)[index] + ";" + \
"border: 1px solid gray;" \
"border-radius: 3px;" \
"selection-background-color: rgba(0,0,0,0.2)}" \
"QComboBox QAbstractItemView { min-width:30px; }"
self.combo_text_color.setStyleSheet(style)
def makeComboFontColor(self) -> QComboBox:
"""
Create Font Color Dropdown
"""
# Button to change text color
self.combo_text_color = QComboBox(self)
color_list = self.doc_props.dict_colors.values()
self.combo_text_color.setFixedWidth(35)
self.combo_text_color.setFixedHeight(20)
model = self.combo_text_color.model()
for i, c in enumerate(color_list):
item = QtGui.QStandardItem()
item.setBackground(QtGui.QColor(c))
model.appendRow(item)
self.combo_text_color.setItemData(i, c)
self.combo_text_color.currentIndexChanged.connect(
self.document.onTextColorChanged)
self.combo_text_color.currentIndexChanged.connect(self.updateTextColor)
self.combo_text_color.setFocusPolicy(Qt.NoFocus)
self.combo_text_color.setToolTip("Change Text color.")
def_index = list(self.doc_props.dict_colors.keys()).index(
self.doc_props.def_text_color_key)
self.combo_text_color.setCurrentIndex(def_index)
self.updateTextColor(self.combo_text_color.currentIndex())
self.combo_text_color.view().setVerticalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
return self.combo_text_color
def makeClearFormatting(self) -> QPushButton:
"""
Create Clear Formatting Button
"""
# Button to Clear Formatting
self.button_clear = QPushButton(html.unescape('Ⱦ'))
self.button_clear.setToolTip('Clear Formatting. "Ctrl+0"')
self.button_clear.setFixedWidth(33)
self.button_clear.setFocusPolicy(Qt.NoFocus)
self.button_clear.clicked.connect(
self.document.clearSelectionFormatting)
return self.button_clear
def makeComboTextAlign(self) -> QComboBox:
"""
Create Text Alignment Dropdown
"""
# Adds ability to change alignment of text
self.combo_text_align = QComboBox(self)
self.combo_text_align.setToolTip('Change text alignment')
self.combo_text_align.addItems(self.doc_props.dict_text_aligns)
self.combo_text_align.setFocusPolicy(Qt.NoFocus)
self.combo_text_align.currentIndexChanged.connect(
self.document.onTextAlignmentChanged)
def_index = list(self.doc_props.dict_text_aligns).index(
self.doc_props.def_text_align_key)
self.combo_text_align.setCurrentIndex(def_index)
return self.combo_text_align
def makeBulletList(self) -> QPushButton:
"""
Create Bullet List Dropdown
"""
# Adds ability to change alignment of text
button_bullet_list = QPushButton(html.unescape('•'), self)
button_bullet_list.setToolTip('Bulleted List')
button_bullet_list.setFixedWidth(33)
button_bullet_list.setFocusPolicy(Qt.NoFocus)
button_bullet_list.clicked.connect(self.document.bulletList)
return button_bullet_list
def makeBtnFormatMode(self, callback) -> QPushButton:
"""
Create Enable Format Mode Button
"""
# Mode Switching button to the very right (after stretch)
self.button_mode_switch = QPushButton("Formatting Mode", self)
self.button_mode_switch.setToolTip("Enable Document Formatting")
# Used to keep button enabled in setFormattingMode
self.button_mode_switch.setProperty("persistent", True)
self.button_mode_switch.setCheckable(True)
self.button_mode_switch.setFocusPolicy(Qt.NoFocus)
self.button_mode_switch.clicked.connect(callback)
return self.button_mode_switch
def setFormattingButtonsEnabled(self, state):
"""
Sets all formatting options to Enabled or Disabled
:param state: boolean that sets the states
:return: returns nothing
"""
# Toggle the state of all buttons in the menu
logging.info(str(state))
a: QWidget
for a in self.children():
if not a.property("persistent"):
a.setEnabled(state)
def updateFormatOnSelectionChange(self):
"""
Selected text format reflected in the TopBar
:return: returns nothing
"""
# Block signals
a: QWidget
for a in self.children():
if not a.property("persistent"):
a.blockSignals(True)
if self.combo_title_style is not None:
title = self.document.currentCharFormat()
index = 0
title_list = list(self.doc_props.dict_title_styles.values())
# adds separator slots to the list to make the index match the list in topbar
for x in range(2, 23, 3):
title_list.insert(x, None)
if title in title_list:
index = title_list.index(title)
self.combo_title_style.setCurrentIndex(index)
# Update the font style displayed
if self.combo_font_style is not None:
self.combo_font_style.setCurrentFont(self.document.currentFont())
# Update the font size displayed
if self.combo_font_size is not None:
size = int(self.document.currentCharFormat().fontPointSize())
if size != 0:
size_index = self.doc_props.list_font_sizes.index(str(size))
self.combo_font_size.setCurrentIndex(size_index)
# Update extra formatting options
if self.button_ital is not None:
self.button_ital.setChecked(self.document.fontItalic())
if self.button_under is not None:
self.button_under.setChecked(self.document.fontUnderline())
if self.button_bold is not None:
self.button_bold.setChecked(
self.document.fontWeight() == QFont.Bold)
if self.button_strike is not None:
self.button_strike.setChecked(
self.document.currentCharFormat().fontStrikeOut())
# update the text color
if self.combo_text_color is not None:
color = self.document.currentCharFormat().foreground().color(
).name()
index = 0
color_list = list(self.doc_props.dict_colors.values())
if color in color_list:
index = color_list.index(color)
self.updateTextColor(index)
# Update the text alignment
if self.combo_text_align is not None:
align = self.document.alignment()
align_list = list(self.doc_props.dict_text_aligns.values())
if align in align_list:
align_index = align_list.index(align)
self.combo_text_align.setCurrentIndex(align_index)
# Unblock signals
a: QWidget
for a in self.children():
if not a.property("persistent"):
a.blockSignals(False)
class Browser(preferences.Group):
def __init__(self, page):
super(Browser, self).__init__(page)
layout = QGridLayout()
self.setLayout(layout)
self.languagesLabel = QLabel()
self.languages = QComboBox(currentIndexChanged=self.changed)
layout.addWidget(self.languagesLabel, 0, 0)
layout.addWidget(self.languages, 0, 1)
items = ['', '']
items.extend(language_names.languageName(l, l) for l in lilydoc.translations)
self.languages.addItems(items)
self.fontLabel = QLabel()
self.fontChooser = QFontComboBox(currentFontChanged=self.changed)
self.fontSize = QSpinBox(valueChanged=self.changed)
self.fontSize.setRange(6, 32)
self.fontSize.setSingleStep(1)
layout.addWidget(self.fontLabel, 1, 0)
layout.addWidget(self.fontChooser, 1, 1)
layout.addWidget(self.fontSize, 1, 2)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("Documentation Browser"))
self.languagesLabel.setText(_("Preferred Language:"))
self.languages.setItemText(0, _("Default"))
self.languages.setItemText(1, _("English (untranslated)"))
self.fontLabel.setText(_("Font:"))
def loadSettings(self):
s = QSettings()
s.beginGroup("documentation")
lang = s.value("language", "default", str)
if lang in lilydoc.translations:
i = lilydoc.translations.index(lang) + 2
elif lang == "C":
i = 1
else:
i = 0
self.languages.setCurrentIndex(i)
font = self.font()
family = s.value("fontfamily", "", str)
if family:
font.setFamily(family)
size = s.value("fontsize", 16, int)
with qutil.signalsBlocked(self.fontChooser, self.fontSize):
self.fontChooser.setCurrentFont(font)
self.fontSize.setValue(size)
def saveSettings(self):
s = QSettings()
s.beginGroup("documentation")
langs = ['default', 'C'] + lilydoc.translations
s.setValue("language", langs[self.languages.currentIndex()])
s.setValue("fontfamily", self.fontChooser.currentFont().family())
s.setValue("fontsize", self.fontSize.value())
class GTextToolbar(QToolBar):
"""A toolbar for the Editor UI instanciated in a window.
"""
def __init__(self, parent):
super().__init__(parent)
self.editor: GTextEditor = None
self.setIconSize(QSize(16, 16))
self._fonts = QFontComboBox(self)
self.addWidget(self._fonts)
self._ttype = QComboBox(self)
self._ttype.addItems([item.comment for item in Format])
self.addWidget(self._ttype)
self._mtype = QComboBox(self)
self._mtype.addItems(["LaTex", "MathML", "Ignore"])
self.addWidget(self._mtype)
self._fsize = QComboBox(self)
self._fsize.addItems(["7", "8", "9", "10", "11", "12", "13", "14",
"18", "24", "36", "48", "64"])
self.addWidget(self._fsize)
self.addSeparator()
self._bold = QAction(QIcon(f"{IMG_PATH}/bold.png"), "Bold", self)
self._bold.setShortcut(QKeySequence.Bold)
self._bold.setCheckable(True)
self.addAction(self._bold)
self._italic = QAction(QIcon(f"{IMG_PATH}/italic.png"), "Italic", self)
self._italic.setShortcut(QKeySequence.Italic)
self._italic.setCheckable(True)
self.addAction(self._italic)
self._underline = QAction(QIcon(f"{IMG_PATH}/underline.png"),
"Underline", self)
self._underline.setShortcut(QKeySequence.Underline)
self._underline.setCheckable(True)
self.addAction(self._underline)
self.addSeparator()
self._alignl = QAction(QIcon(f"{IMG_PATH}/alignment.png"),
"Align left", self)
self._alignl.setCheckable(True)
self.addAction(self._alignl)
self._alignc = QAction(QIcon(f"{IMG_PATH}/align_center.png"),
"Align center", self)
self._alignc.setCheckable(True)
self.addAction(self._alignc)
self._alignr = QAction(QIcon(f"{IMG_PATH}/align_right.png"),
"Align right", self)
self._alignr.setCheckable(True)
self.addAction(self._alignr)
self._alignj = QAction(QIcon(f"{IMG_PATH}/align_justify.png"),
"Justify", self)
self._alignj.setCheckable(True)
self.addAction(self._alignj)
format_group = QActionGroup(self)
format_group.setExclusive(True)
format_group.addAction(self._alignl)
format_group.addAction(self._alignc)
format_group.addAction(self._alignr)
format_group.addAction(self._alignj)
self._wrap = QAction(QIcon(f"{IMG_PATH}/wrap.png"),
"Wrap text to window", self)
self._wrap.setStatusTip("Toggle wrap text to window")
self._wrap.setCheckable(True)
self._wrap.setChecked(True)
self.addAction(self._wrap)
self.addSeparator()
self._html = QAction(QIcon(f"{IMG_PATH}/html.png"),
"Selected text as HTML", self)
self._html.setCheckable(False)
self._html.triggered.connect(self.__to_html)
self.addAction(self._html)
# Format-related widgets/actions, used to disable/enable signals.
self._format_actions = [self._fonts, self._fsize, self._bold,
self._underline, self._italic]
# No need to disable signals for alignment, as they are paragraph-wide.
self.setFocusPolicy(Qt.ClickFocus)
self.setDisabled(True)
def __align_left(self):
self.editor.setAlignment(Qt.AlignLeft)
def __align_center(self):
self.editor.setAlignment(Qt.AlignCenter)
def __align_right(self):
self.editor.setAlignment(Qt.AlignRight)
def __align_justf(self):
self.editor.setAlignment(Qt.AlignJustify)
def __wrap_text(self):
self.editor.setLineWrapMode(int(self.editor.lineWrapMode() == 0))
def __to_html(self):
text = self.editor.textCursor().selectedText()
self.editor.textCursor().insertHtml(text)
def hasFocus(self) -> bool: # pylint: disable=C0103
"""_summary_
Returns:
bool: _description_
"""
return super().hasFocus() or self._fonts.hasFocus() or \
self._fsize.hasFocus() or self._mtype.hasFocus() or \
self._ttype.hasFocus()
def update_editor(self, text_editor: GTextEditor) -> None:
"""Update the font format toolbar/actions when a new text selection
is made. This is neccessary to keep toolbars/etc. in sync with the
current edit state.
"""
self.setDisabled(text_editor is None)
if text_editor == self.editor:
return
if self.editor is not None:
self._ttype.currentIndexChanged.disconnect()
self._fonts.currentFontChanged.disconnect()
self._fsize.currentIndexChanged[str].disconnect()
self._bold.toggled.disconnect()
self._underline.toggled.disconnect()
self._italic.toggled.disconnect()
self._alignl.triggered.disconnect()
self._alignc.triggered.disconnect()
self._alignr.triggered.disconnect()
self._alignj.triggered.disconnect()
self._wrap.triggered.disconnect()
self.editor = text_editor
if self.editor is not None:
for _obj in self._format_actions:
_obj.blockSignals(True)
self._fonts.setCurrentFont(self.editor.currentFont())
self._fsize.setCurrentText(str(int(self.editor.fontPointSize())))
self._italic.setChecked(self.editor.fontItalic())
self._underline.setChecked(self.editor.fontUnderline())
self._bold.setChecked(self.editor.fontWeight() == QFont.Bold)
self._alignl.setChecked(self.editor.alignment() == Qt.AlignLeft)
self._alignc.setChecked(self.editor.alignment() == Qt.AlignCenter)
self._alignr.setChecked(self.editor.alignment() == Qt.AlignRight)
self._alignj.setChecked(self.editor.alignment() == Qt.AlignJustify)
self._ttype.setCurrentText(self.editor.get_formatting())
#self._mtype
for _obj in self._format_actions:
_obj.blockSignals(False)
self._ttype.currentIndexChanged.connect(self.editor.update_fmt)
self._fonts.currentFontChanged.connect(self.editor.setCurrentFont)
self._underline.toggled.connect(self.editor.setFontUnderline)
self._italic.toggled.connect(self.editor.setFontItalic)
self._fsize.currentIndexChanged[str].connect(
lambda s: self.editor.setFontPointSize(float(s)))
self._bold.toggled.connect(lambda x: self.editor.setFontWeight(
QFont.Bold if x else QFont.Normal))
self._alignl.triggered.connect(self.__align_left)
self._alignc.triggered.connect(self.__align_center)
self._alignr.triggered.connect(self.__align_right)
self._alignj.triggered.connect(self.__align_justf)
self._wrap.triggered.connect(self.__wrap_text)
class Browser(preferences.Group):
def __init__(self, page):
super(Browser, self).__init__(page)
layout = QGridLayout()
self.setLayout(layout)
self.languagesLabel = QLabel()
self.languages = QComboBox(currentIndexChanged=self.changed)
layout.addWidget(self.languagesLabel, 0, 0)
layout.addWidget(self.languages, 0, 1)
items = ['', '']
items.extend(
language_names.languageName(l, l) for l in lilydoc.translations)
self.languages.addItems(items)
self.fontLabel = QLabel()
self.fontChooser = QFontComboBox(currentFontChanged=self.changed)
self.fontSize = QSpinBox(valueChanged=self.changed)
self.fontSize.setRange(6, 32)
self.fontSize.setSingleStep(1)
layout.addWidget(self.fontLabel, 1, 0)
layout.addWidget(self.fontChooser, 1, 1)
layout.addWidget(self.fontSize, 1, 2)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("Documentation Browser"))
self.languagesLabel.setText(_("Preferred Language:"))
self.languages.setItemText(0, _("Default"))
self.languages.setItemText(1, _("English (untranslated)"))
self.fontLabel.setText(_("Font:"))
def loadSettings(self):
s = QSettings()
s.beginGroup("documentation")
lang = s.value("language", "default", str)
if lang in lilydoc.translations:
i = lilydoc.translations.index(lang) + 2
elif lang == "C":
i = 1
else:
i = 0
self.languages.setCurrentIndex(i)
font = self.font()
family = s.value("fontfamily", "", str)
if family:
font.setFamily(family)
size = s.value("fontsize", 16, int)
with qutil.signalsBlocked(self.fontChooser, self.fontSize):
self.fontChooser.setCurrentFont(font)
self.fontSize.setValue(size)
def saveSettings(self):
s = QSettings()
s.beginGroup("documentation")
langs = ['default', 'C'] + lilydoc.translations
s.setValue("language", langs[self.languages.currentIndex()])
s.setValue("fontfamily", self.fontChooser.currentFont().family())
s.setValue("fontsize", self.fontSize.value())
class TextoEnriquecido(QWidget):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# self.path holds the path of the currently open file.
# If none, we haven't got a file open yet (or creating new).
self.path = None
self.setupUi()
self.conectarWidgets()
def setupUi(self):
layoutPpal = QVBoxLayout(self)
layoutToolBar = QHBoxLayout()
edit_toolbar = QToolBar("Editar")
edit_toolbar.setIconSize(QSize(16, 16))
self.undo_action = QAction(QIcon(imagen('arrow-curve-180-left.png')), "Deshacer", self)
self.undo_action.setStatusTip("Deshacer ultimo cambio")
edit_toolbar.addAction(self.undo_action)
self.redo_action = QAction(QIcon(imagen('arrow-curve.png')), "Rehacer", self)
self.redo_action.setStatusTip("Rehacer ultimo cambio")
edit_toolbar.addAction(self.redo_action)
self.cut_action = QAction(QIcon(imagen('scissors.png')), "Cortar", self)
self.cut_action.setStatusTip("Cortar texto seleccionado")
self.cut_action.setShortcut(QKeySequence.Cut)
edit_toolbar.addAction(self.cut_action)
self.copy_action = QAction(QIcon(imagen('document-copy.png')), "Copiar", self)
self.copy_action.setStatusTip("Copia texto seleccionado")
self.copy_action.setShortcut(QKeySequence.Copy)
edit_toolbar.addAction(self.copy_action)
self.paste_action = QAction(QIcon(imagen('clipboard-paste-document-text.png')), "Pegar", self)
self.paste_action.setStatusTip("Pegar desde ")
self.paste_action.setShortcut(QKeySequence.Paste)
edit_toolbar.addAction(self.paste_action)
self.select_action = QAction(QIcon(imagen('selection-input.png')), "Seleccionar todo", self)
self.select_action.setStatusTip("Seleccionar todo el texto")
self.select_action.setShortcut(QKeySequence.SelectAll)
edit_toolbar.addAction(self.select_action)
self.wrap_action = QAction(QIcon(imagen('arrow-continue.png')), "Ajusta el texto a la ventana", self)
self.wrap_action.setStatusTip("Ajusta/desajusta el texto a la ventana")
self.wrap_action.setCheckable(True)
self.wrap_action.setChecked(True)
edit_toolbar.addAction(self.wrap_action)
layoutToolBar.addWidget(edit_toolbar)
toolbar_formato = QToolBar("Formato")
toolbar_formato.setIconSize(QSize(16, 16))
self.fonts = QFontComboBox()
toolbar_formato.addWidget(self.fonts)
self.fontsize = QComboBox()
self.fontsize.addItems([str(s) for s in FONT_SIZES])
toolbar_formato.addWidget(self.fontsize)
self.bold_action = QAction(QIcon(imagen('edit-bold.png')), "Negrita", self)
self.bold_action.setStatusTip("Negrita")
self.bold_action.setShortcut(QKeySequence.Bold)
self.bold_action.setCheckable(True)
toolbar_formato.addAction(self.bold_action)
self.italic_action = QAction(QIcon(imagen('edit-italic.png')), "Italica", self)
self.italic_action.setStatusTip("Italica")
self.italic_action.setShortcut(QKeySequence.Italic)
self.italic_action.setCheckable(True)
toolbar_formato.addAction(self.italic_action)
self.underline_action = QAction(QIcon(imagen('edit-underline.png')), "Subrayado", self)
self.underline_action.setStatusTip("Subrayado")
self.underline_action.setShortcut(QKeySequence.Underline)
self.underline_action.setCheckable(True)
toolbar_formato.addAction(self.underline_action)
self.alignl_action = QAction(QIcon(imagen('edit-alignment.png')), "Alinear izquierda", self)
self.alignl_action.setStatusTip("Alinear texto a la izquierda")
self.alignl_action.setCheckable(True)
toolbar_formato.addAction(self.alignl_action)
self.alignc_action = QAction(QIcon(imagen('edit-alignment-center.png')), "Alinear centrado", self)
self.alignc_action.setStatusTip("Alineacion centrada del texto")
self.alignc_action.setCheckable(True)
toolbar_formato.addAction(self.alignc_action)
self.alignr_action = QAction(QIcon(imagen('edit-alignment-right.png')), "Alinear derecha", self)
self.alignr_action.setStatusTip("Alinear texto a la derecha")
self.alignr_action.setCheckable(True)
toolbar_formato.addAction(self.alignr_action)
self.alignj_action = QAction(QIcon(imagen('edit-alignment-justify.png')), "Justificar", self)
self.alignj_action.setStatusTip("Texto justificado")
self.alignj_action.setCheckable(True)
toolbar_formato.addAction(self.alignj_action)
format_group = QActionGroup(self)
format_group.setExclusive(True)
format_group.addAction(self.alignl_action)
format_group.addAction(self.alignc_action)
format_group.addAction(self.alignr_action)
format_group.addAction(self.alignj_action)
layoutToolBar.addWidget(toolbar_formato)
layoutPpal.addLayout(layoutToolBar)
self.editor = TextEdit(tamanio=10)
self.editor.setAutoFormatting(QTextEdit.AutoAll)
# Initialize default font size.
font = QFont('Times', 12)
self.editor.setFont(font)
# We need to repeat the size to init the current format.
self.editor.setFontPointSize(12)
layoutPpal.addWidget(self.editor)
# A list of all format-related widgets/actions, so we can disable/enable signals when updating.
self._format_actions = [
self.fonts,
self.fontsize,
self.bold_action,
self.italic_action,
self.underline_action,
# We don't need to disable signals for alignment, as they are paragraph-wide.
]
# Initialize.
self.update_format()
def conectarWidgets(self):
self.fonts.currentFontChanged.connect(self.editor.setCurrentFont)
self.editor.selectionChanged.connect(self.update_format)
self.undo_action.triggered.connect(self.editor.undo)
self.redo_action.triggered.connect(self.editor.redo)
self.cut_action.triggered.connect(self.editor.cut)
self.copy_action.triggered.connect(self.editor.copy)
self.paste_action.triggered.connect(self.editor.paste)
self.select_action.triggered.connect(self.editor.selectAll)
self.wrap_action.triggered.connect(self.edit_toggle_wrap)
# Connect to the signal producing the text of the current selection. Convert the string to float
# and set as the pointsize. We could also use the index + retrieve from FONT_SIZES.
self.fontsize.currentIndexChanged[str].connect(lambda s: self.editor.setFontPointSize(float(s)) )
self.bold_action.toggled.connect(lambda x: self.editor.setFontWeight(QFont.Bold if x else QFont.Normal))
self.italic_action.toggled.connect(self.editor.setFontItalic)
self.underline_action.toggled.connect(self.editor.setFontUnderline)
self.alignl_action.triggered.connect(lambda: self.editor.setAlignment(Qt.AlignLeft))
self.alignc_action.triggered.connect(lambda: self.editor.setAlignment(Qt.AlignCenter))
self.alignr_action.triggered.connect(lambda: self.editor.setAlignment(Qt.AlignRight))
self.alignj_action.triggered.connect(lambda: self.editor.setAlignment(Qt.AlignJustify))
def block_signals(self, objects, b):
for o in objects:
o.blockSignals(b)
def update_format(self):
"""
Update the font format toolbar/actions when a new text selection is made. This is neccessary to keep
toolbars/etc. in sync with the current edit state.
:return:
"""
# Disable signals for all format widgets, so changing values here does not trigger further formatting.
self.block_signals(self._format_actions, True)
self.fonts.setCurrentFont(self.editor.currentFont())
# Nasty, but we get the font-size as a float but want it was an int
self.fontsize.setCurrentText(str(int(self.editor.fontPointSize())))
self.italic_action.setChecked(self.editor.fontItalic())
self.underline_action.setChecked(self.editor.fontUnderline())
self.bold_action.setChecked(self.editor.fontWeight() == QFont.Bold)
self.alignl_action.setChecked(self.editor.alignment() == Qt.AlignLeft)
self.alignc_action.setChecked(self.editor.alignment() == Qt.AlignCenter)
self.alignr_action.setChecked(self.editor.alignment() == Qt.AlignRight)
self.alignj_action.setChecked(self.editor.alignment() == Qt.AlignJustify)
self.block_signals(self._format_actions, False)
def edit_toggle_wrap(self):
self.editor.setLineWrapMode( 1 if self.editor.lineWrapMode() == 0 else 0 )
def file_open(self, archivo=''):
# path, _ = QFileDialog.getOpenFileName(self, "Open file", "", "HTML documents (*.html);Text documents (*.txt);All files (*.*)")
path = archivo
try:
with open(path, 'rU') as f:
text = f.read()
except Exception as e:
self.dialog_critical(str(e))
else:
self.path = path
# Qt will automatically try and guess the format as txt/html
self.editor.setText(text)
# self.update_title()
def file_save(self, path=None):
self.path = path
if self.path is None:
# If we do not have a path, we need to use Save As.
return self.file_saveas()
text = self.editor.toHtml() if splitext(self.path) in HTML_EXTENSIONS else self.editor.toPlainText()
try:
with open(self.path, 'w') as f:
f.write(text)
except Exception as e:
self.dialog_critical(str(e))
def file_saveas(self, path=None):
if not path:
# If dialog is cancelled, will return ''
return
text = self.editor.toHtml() if splitext(path) in HTML_EXTENSIONS else self.editor.toPlainText()
try:
with open(path, 'w') as f:
f.write(text)
except Exception as e:
self.dialog_critical(str(e))
else:
self.path = path
# self.update_title()
def dialog_critical(self, s):
dlg = QMessageBox(self)
dlg.setText(s)
dlg.setIcon(QMessageBox.Critical)
dlg.show()
def toHtml(self):
return self.editor.toHtml()
def toPlainText(self):
return self.editor.toPlainText()
class FontsColors(preferences.Page):
def __init__(self, dialog):
super(FontsColors, self).__init__(dialog)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.scheme = SchemeSelector(self)
layout.addWidget(self.scheme)
self.printScheme = QCheckBox()
layout.addWidget(self.printScheme)
hbox = QHBoxLayout()
self.tree = QTreeWidget(self)
self.tree.setHeaderHidden(True)
self.tree.setAnimated(True)
self.stack = QStackedWidget(self)
hbox.addWidget(self.tree)
hbox.addWidget(self.stack)
layout.addLayout(hbox)
hbox = QHBoxLayout()
self.fontLabel = QLabel()
self.fontChooser = QFontComboBox()
self.fontSize = QDoubleSpinBox()
self.fontSize.setRange(6.0, 32.0)
self.fontSize.setSingleStep(0.5)
self.fontSize.setDecimals(1)
hbox.addWidget(self.fontLabel)
hbox.addWidget(self.fontChooser, 1)
hbox.addWidget(self.fontSize)
layout.addLayout(hbox)
# add the items to our list
self.baseColorsItem = i = QTreeWidgetItem()
self.tree.addTopLevelItem(i)
self.defaultStylesItem = i = QTreeWidgetItem()
self.tree.addTopLevelItem(i)
self.defaultStyles = {}
for name in textformats.defaultStyles:
self.defaultStyles[name] = i = QTreeWidgetItem()
self.defaultStylesItem.addChild(i)
i.name = name
self.defaultStylesItem.setExpanded(True)
self.allStyles = {}
for group, styles in ly.colorize.default_mapping():
i = QTreeWidgetItem()
children = {}
self.allStyles[group] = (i, children)
self.tree.addTopLevelItem(i)
i.group = group
for name, base, clss in styles:
j = QTreeWidgetItem()
j.name = name
j.base = base
i.addChild(j)
children[name] = j
self.baseColorsWidget = BaseColors(self)
self.customAttributesWidget = CustomAttributes(self)
self.emptyWidget = QWidget(self)
self.stack.addWidget(self.baseColorsWidget)
self.stack.addWidget(self.customAttributesWidget)
self.stack.addWidget(self.emptyWidget)
self.tree.currentItemChanged.connect(self.currentItemChanged)
self.tree.setCurrentItem(self.baseColorsItem)
self.scheme.currentChanged.connect(self.currentSchemeChanged)
self.scheme.changed.connect(self.changed)
self.baseColorsWidget.changed.connect(self.baseColorsChanged)
self.customAttributesWidget.changed.connect(self.customAttributesChanged)
self.fontChooser.currentFontChanged.connect(self.fontChanged)
self.fontSize.valueChanged.connect(self.fontChanged)
self.printScheme.clicked.connect(self.printSchemeChanged)
app.translateUI(self)
def translateUI(self):
self.printScheme.setText(_("Use this scheme for printing"))
self.fontLabel.setText(_("Font:"))
self.baseColorsItem.setText(0, _("Base Colors"))
self.defaultStylesItem.setText(0, _("Default Styles"))
self.defaultStyleNames = defaultStyleNames()
self.allStyleNames = allStyleNames()
for name in textformats.defaultStyles:
self.defaultStyles[name].setText(0, self.defaultStyleNames[name])
for group, styles in ly.colorize.default_mapping():
try:
n = self.allStyleNames[group][0]
except KeyError:
n = group
self.allStyles[group][0].setText(0, n)
for name, base, clss in styles:
try:
n = self.allStyleNames[group][1][name]
except KeyError:
n = name
self.allStyles[group][1][name].setText(0, n)
def currentItemChanged(self, item, previous):
if item is self.baseColorsItem:
self.stack.setCurrentWidget(self.baseColorsWidget)
elif not item.parent():
self.stack.setCurrentWidget(self.emptyWidget)
else:
data = self.data[self.scheme.currentScheme()]
w = self.customAttributesWidget
self.stack.setCurrentWidget(w)
toptext = None
if item.parent() is self.defaultStylesItem:
# default style
w.setTitle(item.text(0))
w.setTristate(False)
w.setTextFormat(data.defaultStyles[item.name])
else:
# specific style of specific group
group, name = item.parent().group, item.name
w.setTitle("{0}: {1}".format(item.parent().text(0), item.text(0)))
inherit = item.base
if inherit:
toptext = _("(Inherits: {name})").format(name=self.defaultStyleNames[inherit])
w.setTristate(bool(inherit))
w.setTextFormat(data.allStyles[group][name])
w.setTopText(toptext)
def currentSchemeChanged(self):
scheme = self.scheme.currentScheme()
if scheme not in self.data:
self.data[scheme] = textformats.TextFormatData(scheme)
self.updateDisplay()
if self.tree.currentItem():
self.currentItemChanged(self.tree.currentItem(), None)
with qutil.signalsBlocked(self.printScheme):
self.printScheme.setChecked(scheme == self._printScheme)
def fontChanged(self):
data = self.data[self.scheme.currentScheme()]
data.font = self.fontChooser.currentFont()
data.font.setPointSizeF(self.fontSize.value())
self.updateDisplay()
self.changed.emit()
def printSchemeChanged(self):
if self.printScheme.isChecked():
self._printScheme = self.scheme.currentScheme()
else:
self._printScheme = None
self.changed.emit()
def addSchemeData(self, scheme, tfd):
self.data[scheme] = tfd
def currentSchemeData(self):
return self.data[self.scheme.currentScheme()]
def updateDisplay(self):
data = self.data[self.scheme.currentScheme()]
with qutil.signalsBlocked(self.fontChooser, self.fontSize):
self.fontChooser.setCurrentFont(data.font)
self.fontSize.setValue(data.font.pointSizeF())
with qutil.signalsBlocked(self):
# update base colors
for name in textformats.baseColors:
self.baseColorsWidget.color[name].setColor(data.baseColors[name])
# update base colors for whole treewidget
p = QApplication.palette()
p.setColor(QPalette.Base, data.baseColors['background'])
p.setColor(QPalette.Text, data.baseColors['text'])
p.setColor(QPalette.Highlight, data.baseColors['selectionbackground'])
p.setColor(QPalette.HighlightedText, data.baseColors['selectiontext'])
self.tree.setPalette(p)
def setItemTextFormat(item, f):
font = QFont(data.font)
if f.hasProperty(QTextFormat.ForegroundBrush):
item.setForeground(0, f.foreground().color())
else:
item.setForeground(0, data.baseColors['text'])
if f.hasProperty(QTextFormat.BackgroundBrush):
item.setBackground(0, f.background().color())
else:
item.setBackground(0, QBrush())
font.setWeight(f.fontWeight())
font.setItalic(f.fontItalic())
font.setUnderline(f.fontUnderline())
item.setFont(0, font)
# update looks of default styles
for name in textformats.defaultStyles:
setItemTextFormat(self.defaultStyles[name], data.defaultStyles[name])
# update looks of all the specific styles
for group, styles in ly.colorize.default_mapping():
children = self.allStyles[group][1]
for name, inherit, clss in styles:
f = QTextCharFormat(data.defaultStyles[inherit]) if inherit else QTextCharFormat()
f.merge(data.allStyles[group][name])
setItemTextFormat(children[name], f)
def baseColorsChanged(self, name):
# keep data up to date with base colors
data = self.data[self.scheme.currentScheme()]
data.baseColors[name] = self.baseColorsWidget.color[name].color()
self.updateDisplay()
self.changed.emit()
def customAttributesChanged(self):
item = self.tree.currentItem()
if not item or not item.parent():
return
data = self.data[self.scheme.currentScheme()]
if item.parent() is self.defaultStylesItem:
# a default style has been changed
data.defaultStyles[item.name] = self.customAttributesWidget.textFormat()
else:
# a specific style has been changed
group, name = item.parent().group, item.name
data.allStyles[group][name] = self.customAttributesWidget.textFormat()
self.updateDisplay()
self.changed.emit()
def import_(self, filename):
from . import import_export
import_export.importTheme(filename, self, self.scheme)
def export(self, name, filename):
from . import import_export
try:
import_export.exportTheme(self, name, filename)
except (IOError, OSError) as e:
QMessageBox.critical(self, _("Error"), _(
"Can't write to destination:\n\n{url}\n\n{error}").format(
url=filename, error=e.strerror))
def loadSettings(self):
self.data = {} # holds all data with scheme as key
self._printScheme = QSettings().value("printer_scheme", "default", str)
self.scheme.loadSettings("editor_scheme", "editor_schemes")
def saveSettings(self):
self.scheme.saveSettings("editor_scheme", "editor_schemes", "fontscolors")
for scheme in self.scheme.schemes():
if scheme in self.data:
self.data[scheme].save(scheme)
if self._printScheme:
QSettings().setValue("printer_scheme", self._printScheme)
else:
QSettings().remove("printer_scheme")
class comic_export_setting_dialog(QDialog):
acbfStylesList = [
"speech", "commentary", "formal", "letter", "code", "heading", "audio",
"thought", "sign", "sound", "emphasis", "strong"
]
def __init__(self):
super().__init__()
self.setLayout(QVBoxLayout())
self.setWindowTitle(i18n("Export settings"))
buttons = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
mainWidget = QTabWidget()
self.layout().addWidget(mainWidget)
self.layout().addWidget(buttons)
# Set basic crop settings
# Set which layers to remove before export.
mainExportSettings = QWidget()
mainExportSettings.setLayout(QVBoxLayout())
groupExportCrop = QGroupBox(i18n("Crop settings"))
formCrop = QFormLayout()
groupExportCrop.setLayout(formCrop)
self.chk_toOutmostGuides = QCheckBox(i18n("Crop to outmost guides"))
self.chk_toOutmostGuides.setChecked(True)
self.chk_toOutmostGuides.setToolTip(
i18n(
"This will crop to the outmost guides if possible and otherwise use the underlying crop settings."
))
formCrop.addRow("", self.chk_toOutmostGuides)
btn_fromSelection = QPushButton(
i18n("Set margins from active selection"))
btn_fromSelection.clicked.connect(self.slot_set_margin_from_selection)
# This doesn't work.
formCrop.addRow("", btn_fromSelection)
self.spn_marginLeft = QSpinBox()
self.spn_marginLeft.setMaximum(99999)
self.spn_marginLeft.setSuffix(" px")
formCrop.addRow(i18n("Left:"), self.spn_marginLeft)
self.spn_marginTop = QSpinBox()
self.spn_marginTop.setMaximum(99999)
self.spn_marginTop.setSuffix(" px")
formCrop.addRow(i18n("Top:"), self.spn_marginTop)
self.spn_marginRight = QSpinBox()
self.spn_marginRight.setMaximum(99999)
self.spn_marginRight.setSuffix(" px")
formCrop.addRow(i18n("Right:"), self.spn_marginRight)
self.spn_marginBottom = QSpinBox()
self.spn_marginBottom.setMaximum(99999)
self.spn_marginBottom.setSuffix(" px")
formCrop.addRow(i18n("Bottom:"), self.spn_marginBottom)
groupExportLayers = QGroupBox(i18n("Layers"))
formLayers = QFormLayout()
groupExportLayers.setLayout(formLayers)
self.cmbLabelsRemove = labelSelector()
formLayers.addRow(i18n("Label for removal:"), self.cmbLabelsRemove)
self.ln_text_layer_name = QLineEdit()
self.ln_text_layer_name.setToolTip(
i18n(
"These are keywords that can be used to identify text layers. A layer only needs to contain the keyword to be recognised. Keywords should be comma seperated."
))
self.ln_panel_layer_name = QLineEdit()
self.ln_panel_layer_name.setToolTip(
i18n(
"These are keywords that can be used to identify panel layers. A layer only needs to contain the keyword to be recognised. Keywords should be comma seperated."
))
formLayers.addRow(i18n("Text Layer Key:"), self.ln_text_layer_name)
formLayers.addRow(i18n("Panel Layer Key:"), self.ln_panel_layer_name)
mainExportSettings.layout().addWidget(groupExportCrop)
mainExportSettings.layout().addWidget(groupExportLayers)
mainWidget.addTab(mainExportSettings, i18n("General"))
# CBZ, crop, resize, which metadata to add.
CBZexportSettings = QWidget()
CBZexportSettings.setLayout(QVBoxLayout())
self.CBZactive = QCheckBox(i18n("Export to CBZ"))
CBZexportSettings.layout().addWidget(self.CBZactive)
self.CBZgroupResize = comic_export_resize_widget("CBZ")
CBZexportSettings.layout().addWidget(self.CBZgroupResize)
self.CBZactive.clicked.connect(self.CBZgroupResize.setEnabled)
CBZgroupMeta = QGroupBox(i18n("Metadata to add"))
# CBZexportSettings.layout().addWidget(CBZgroupMeta)
CBZgroupMeta.setLayout(QFormLayout())
mainWidget.addTab(CBZexportSettings, "CBZ")
# ACBF, crop, resize, creator name, version history, panel layer, text layers.
ACBFExportSettings = QWidget()
ACBFform = QFormLayout()
ACBFExportSettings.setLayout(QVBoxLayout())
ACBFdocInfo = QGroupBox()
ACBFdocInfo.setTitle(i18n("ACBF Document Info"))
ACBFdocInfo.setLayout(ACBFform)
self.lnACBFSource = QLineEdit()
self.lnACBFSource.setToolTip(
i18n(
"Whether the acbf file is an adaption of an existing source, and if so, how to find information about that source. So for example, for an adapted webcomic, the official website url should go here."
))
self.lnACBFID = QLabel()
self.lnACBFID.setToolTip(
i18n(
"By default this will be filled with a generated universal unique identifier. The ID by itself is merely so that comic book library management programs can figure out if this particular comic is already in their database and whether it has been rated. Of course, the UUID can be changed into something else by manually changing the json, but this is advanced usage."
))
self.spnACBFVersion = QSpinBox()
self.ACBFhistoryModel = QStandardItemModel()
acbfHistoryList = QListView()
acbfHistoryList.setModel(self.ACBFhistoryModel)
btn_add_history = QPushButton(i18n("Add history entry"))
btn_add_history.clicked.connect(self.slot_add_history_item)
self.chkIncludeTranslatorComments = QCheckBox()
self.chkIncludeTranslatorComments.setText(
i18n("Include Translator's Comments"))
self.chkIncludeTranslatorComments.setToolTip(
i18n(
"A PO file can contain translator's comments. If this is checked, the translations comments will be added as references into the ACBF file."
))
self.lnTranslatorHeader = QLineEdit()
ACBFform.addRow(i18n("Source:"), self.lnACBFSource)
ACBFform.addRow(i18n("ACBF UID:"), self.lnACBFID)
ACBFform.addRow(i18n("Version:"), self.spnACBFVersion)
ACBFform.addRow(i18n("Version History:"), acbfHistoryList)
ACBFform.addRow("", btn_add_history)
ACBFform.addRow("", self.chkIncludeTranslatorComments)
ACBFform.addRow(i18n("Translator Header:"), self.lnTranslatorHeader)
ACBFAuthorInfo = QWidget()
acbfAVbox = QVBoxLayout(ACBFAuthorInfo)
infoLabel = QLabel(
i18n(
"The people responsible for the generation of the CBZ/ACBF files."
))
infoLabel.setWordWrap(True)
ACBFAuthorInfo.layout().addWidget(infoLabel)
self.ACBFauthorModel = QStandardItemModel(0, 6)
labels = [
i18n("Nick Name"),
i18n("Given Name"),
i18n("Middle Name"),
i18n("Family Name"),
i18n("Email"),
i18n("Homepage")
]
self.ACBFauthorModel.setHorizontalHeaderLabels(labels)
self.ACBFauthorTable = QTableView()
acbfAVbox.addWidget(self.ACBFauthorTable)
self.ACBFauthorTable.setModel(self.ACBFauthorModel)
self.ACBFauthorTable.verticalHeader().setDragEnabled(True)
self.ACBFauthorTable.verticalHeader().setDropIndicatorShown(True)
self.ACBFauthorTable.verticalHeader().setSectionsMovable(True)
self.ACBFauthorTable.verticalHeader().sectionMoved.connect(
self.slot_reset_author_row_visual)
AuthorButtons = QHBoxLayout()
btn_add_author = QPushButton(i18n("Add author"))
btn_add_author.clicked.connect(self.slot_add_author)
AuthorButtons.addWidget(btn_add_author)
btn_remove_author = QPushButton(i18n("Remove author"))
btn_remove_author.clicked.connect(self.slot_remove_author)
AuthorButtons.addWidget(btn_remove_author)
acbfAVbox.addLayout(AuthorButtons)
ACBFStyle = QWidget()
ACBFStyle.setLayout(QHBoxLayout())
self.ACBFStylesModel = QStandardItemModel()
self.ACBFStyleClass = QListView()
self.ACBFStyleClass.setModel(self.ACBFStylesModel)
ACBFStyle.layout().addWidget(self.ACBFStyleClass)
ACBFStyleEdit = QWidget()
ACBFStyleEditVB = QVBoxLayout(ACBFStyleEdit)
self.ACBFfontCombo = QFontComboBox()
self.ACBFdefaultFont = QComboBox()
self.ACBFdefaultFont.addItems(
["sans-serif", "serif", "monospace", "cursive", "fantasy"])
self.ACBFBold = QCheckBox(i18n("Bold"))
self.ACBFItal = QCheckBox(i18n("Italic"))
self.ACBFStyleClass.clicked.connect(self.slot_set_style)
self.ACBFStyleClass.selectionModel().selectionChanged.connect(
self.slot_set_style)
self.ACBFStylesModel.itemChanged.connect(self.slot_set_style)
self.ACBFfontCombo.currentFontChanged.connect(
self.slot_font_current_style)
self.ACBFfontCombo.setEditable(False)
self.ACBFBold.toggled.connect(self.slot_font_current_style)
self.ACBFItal.toggled.connect(self.slot_font_current_style)
colorWidget = QGroupBox(self)
colorWidget.setTitle(i18n("Text Colors"))
colorWidget.setLayout(QVBoxLayout())
self.regularColor = QColorDialog()
self.invertedColor = QColorDialog()
self.btn_acbfRegColor = QPushButton(i18n("Regular Text"), self)
self.btn_acbfRegColor.clicked.connect(self.slot_change_regular_color)
self.btn_acbfInvColor = QPushButton(i18n("Inverted Text"), self)
self.btn_acbfInvColor.clicked.connect(self.slot_change_inverted_color)
colorWidget.layout().addWidget(self.btn_acbfRegColor)
colorWidget.layout().addWidget(self.btn_acbfInvColor)
ACBFStyleEditVB.addWidget(colorWidget)
ACBFStyleEditVB.addWidget(self.ACBFfontCombo)
ACBFStyleEditVB.addWidget(self.ACBFdefaultFont)
ACBFStyleEditVB.addWidget(self.ACBFBold)
ACBFStyleEditVB.addWidget(self.ACBFItal)
ACBFStyleEditVB.addStretch()
ACBFStyle.layout().addWidget(ACBFStyleEdit)
ACBFTabwidget = QTabWidget()
ACBFTabwidget.addTab(ACBFdocInfo, i18n("Document Info"))
ACBFTabwidget.addTab(ACBFAuthorInfo, i18n("Author Info"))
ACBFTabwidget.addTab(ACBFStyle, i18n("Style Sheet"))
ACBFExportSettings.layout().addWidget(ACBFTabwidget)
mainWidget.addTab(ACBFExportSettings, i18n("ACBF"))
# Epub export, crop, resize, other questions.
EPUBexportSettings = QWidget()
EPUBexportSettings.setLayout(QVBoxLayout())
self.EPUBactive = QCheckBox(i18n("Export to EPUB"))
EPUBexportSettings.layout().addWidget(self.EPUBactive)
self.EPUBgroupResize = comic_export_resize_widget("EPUB")
EPUBexportSettings.layout().addWidget(self.EPUBgroupResize)
self.EPUBactive.clicked.connect(self.EPUBgroupResize.setEnabled)
mainWidget.addTab(EPUBexportSettings, "EPUB")
# For Print. Crop, no resize.
TIFFExportSettings = QWidget()
TIFFExportSettings.setLayout(QVBoxLayout())
self.TIFFactive = QCheckBox(i18n("Export to TIFF"))
TIFFExportSettings.layout().addWidget(self.TIFFactive)
self.TIFFgroupResize = comic_export_resize_widget("TIFF")
TIFFExportSettings.layout().addWidget(self.TIFFgroupResize)
self.TIFFactive.clicked.connect(self.TIFFgroupResize.setEnabled)
mainWidget.addTab(TIFFExportSettings, "TIFF")
# SVG, crop, resize, embed vs link.
#SVGExportSettings = QWidget()
#mainWidget.addTab(SVGExportSettings, "SVG")
"""
Add a history item to the acbf version history list.
"""
def slot_add_history_item(self):
newItem = QStandardItem()
newItem.setText("v" + str(self.spnACBFVersion.value()) + "-" +
i18n("in this version..."))
self.ACBFhistoryModel.appendRow(newItem)
"""
Get the margins by treating the active selection in a document as the trim area.
This allows people to snap selections to a vector or something, and then get the margins.
"""
def slot_set_margin_from_selection(self):
doc = Application.activeDocument()
if doc is not None:
if doc.selection() is not None:
self.spn_marginLeft.setValue(doc.selection().x())
self.spn_marginTop.setValue(doc.selection().y())
self.spn_marginRight.setValue(doc.width() -
(doc.selection().x() +
doc.selection().width()))
self.spn_marginBottom.setValue(doc.height() -
(doc.selection().y() +
doc.selection().height()))
"""
Add an author with default values initialised.
"""
def slot_add_author(self):
listItems = []
listItems.append(QStandardItem(i18n("Anon"))) # Nick name
listItems.append(QStandardItem(i18n("John"))) # First name
listItems.append(QStandardItem()) # Middle name
listItems.append(QStandardItem(i18n("Doe"))) # Last name
listItems.append(QStandardItem()) # email
listItems.append(QStandardItem()) # homepage
self.ACBFauthorModel.appendRow(listItems)
"""
Remove the selected author from the author list.
"""
def slot_remove_author(self):
self.ACBFauthorModel.removeRow(
self.ACBFauthorTable.currentIndex().row())
"""
Ensure that the drag and drop of authors doesn't mess up the labels.
"""
def slot_reset_author_row_visual(self):
headerLabelList = []
for i in range(self.ACBFauthorTable.verticalHeader().count()):
headerLabelList.append(str(i))
for i in range(self.ACBFauthorTable.verticalHeader().count()):
logicalI = self.ACBFauthorTable.verticalHeader().logicalIndex(i)
headerLabelList[logicalI] = str(i + 1)
self.ACBFauthorModel.setVerticalHeaderLabels(headerLabelList)
def slot_set_style(self):
index = self.ACBFStyleClass.currentIndex()
if index.isValid():
item = self.ACBFStylesModel.item(index.row())
font = QFont()
font.setFamily(str(item.data(role=Qt.UserRole + 1)))
self.ACBFfontCombo.setCurrentFont(font)
self.ACBFdefaultFont.setCurrentText(
str(item.data(role=Qt.UserRole + 2)))
bold = item.data(role=Qt.UserRole + 3)
if bold is not None:
self.ACBFBold.setChecked(bold)
else:
self.ACBFBold.setChecked(False)
italic = item.data(role=Qt.UserRole + 4)
if italic is not None:
self.ACBFItal.setChecked(italic)
else:
self.ACBFItal.setChecked(False)
def slot_font_current_style(self):
index = self.ACBFStyleClass.currentIndex()
if index.isValid():
item = self.ACBFStylesModel.item(index.row())
font = QFont(self.ACBFfontCombo.currentFont())
item.setData(font.family(), role=Qt.UserRole + 1)
item.setData(self.ACBFdefaultFont.currentText(),
role=Qt.UserRole + 2)
item.setData(self.ACBFBold.isChecked(), role=Qt.UserRole + 3)
item.setData(self.ACBFItal.isChecked(), role=Qt.UserRole + 4)
self.ACBFStylesModel.setItem(index.row(), item)
def slot_change_regular_color(self):
if (self.regularColor.exec_() == QDialog.Accepted):
square = QPixmap(32, 32)
square.fill(self.regularColor.currentColor())
self.btn_acbfRegColor.setIcon(QIcon(square))
def slot_change_inverted_color(self):
if (self.invertedColor.exec_() == QDialog.Accepted):
square = QPixmap(32, 32)
square.fill(self.invertedColor.currentColor())
self.btn_acbfInvColor.setIcon(QIcon(square))
"""
Load the UI values from the config dictionary given.
"""
def setConfig(self, config):
if "cropToGuides" in config.keys():
self.chk_toOutmostGuides.setChecked(config["cropToGuides"])
if "cropLeft" in config.keys():
self.spn_marginLeft.setValue(config["cropLeft"])
if "cropTop" in config.keys():
self.spn_marginTop.setValue(config["cropTop"])
if "cropRight" in config.keys():
self.spn_marginRight.setValue(config["cropRight"])
if "cropBottom" in config.keys():
self.spn_marginBottom.setValue(config["cropBottom"])
if "labelsToRemove" in config.keys():
self.cmbLabelsRemove.setLabels(config["labelsToRemove"])
if "textLayerNames" in config.keys():
self.ln_text_layer_name.setText(", ".join(
config["textLayerNames"]))
else:
self.ln_text_layer_name.setText("text")
if "panelLayerNames" in config.keys():
self.ln_panel_layer_name.setText(", ".join(
config["panelLayerNames"]))
else:
self.ln_panel_layer_name.setText("panels")
self.CBZgroupResize.set_config(config)
if "CBZactive" in config.keys():
self.CBZactive.setChecked(config["CBZactive"])
self.EPUBgroupResize.set_config(config)
if "EPUBactive" in config.keys():
self.EPUBactive.setChecked(config["EPUBactive"])
self.TIFFgroupResize.set_config(config)
if "TIFFactive" in config.keys():
self.TIFFactive.setChecked(config["TIFFactive"])
if "acbfAuthor" in config.keys():
if isinstance(config["acbfAuthor"], list):
for author in config["acbfAuthor"]:
listItems = []
listItems.append(QStandardItem(author.get("nickname", "")))
listItems.append(
QStandardItem(author.get("first-name", "")))
listItems.append(QStandardItem(author.get("initials", "")))
listItems.append(QStandardItem(author.get("last-name",
"")))
listItems.append(QStandardItem(author.get("email", "")))
listItems.append(QStandardItem(author.get("homepage", "")))
self.ACBFauthorModel.appendRow(listItems)
pass
else:
listItems = []
listItems.append(QStandardItem(
config["acbfAuthor"])) # Nick name
for i in range(0, 5):
listItems.append(QStandardItem()) # First name
self.ACBFauthorModel.appendRow(listItems)
if "acbfSource" in config.keys():
self.lnACBFSource.setText(config["acbfSource"])
if "acbfID" in config.keys():
self.lnACBFID.setText(config["acbfID"])
else:
self.lnACBFID.setText(QUuid.createUuid().toString())
if "acbfVersion" in config.keys():
self.spnACBFVersion.setValue(config["acbfVersion"])
if "acbfHistory" in config.keys():
for h in config["acbfHistory"]:
item = QStandardItem()
item.setText(h)
self.ACBFhistoryModel.appendRow(item)
if "acbfStyles" in config.keys():
styleDict = config.get("acbfStyles", {})
for key in self.acbfStylesList:
keyDict = styleDict.get(key, {})
style = QStandardItem(key.title())
style.setCheckable(True)
if key in styleDict.keys():
style.setCheckState(Qt.Checked)
else:
style.setCheckState(Qt.Unchecked)
style.setData(keyDict.get("font",
QFont().family()),
role=Qt.UserRole + 1)
style.setData(keyDict.get("genericfont", "sans-serif"),
role=Qt.UserRole + 2)
style.setData(keyDict.get("bold", False), role=Qt.UserRole + 3)
style.setData(keyDict.get("ital", False), role=Qt.UserRole + 4)
self.ACBFStylesModel.appendRow(style)
keyDict = styleDict.get("general", {})
self.regularColor.setCurrentColor(
QColor(keyDict.get("color", "#000000")))
square = QPixmap(32, 32)
square.fill(self.regularColor.currentColor())
self.btn_acbfRegColor.setIcon(QIcon(square))
keyDict = styleDict.get("inverted", {})
self.invertedColor.setCurrentColor(
QColor(keyDict.get("color", "#FFFFFF")))
square.fill(self.invertedColor.currentColor())
self.btn_acbfInvColor.setIcon(QIcon(square))
else:
for key in self.acbfStylesList:
style = QStandardItem(key.title())
style.setCheckable(True)
style.setCheckState(Qt.Unchecked)
style.setData(QFont().family(), role=Qt.UserRole + 1)
style.setData("sans-serif", role=Qt.UserRole + 2)
style.setData(False, role=Qt.UserRole + 3) #Bold
style.setData(False, role=Qt.UserRole + 4) #Italic
self.ACBFStylesModel.appendRow(style)
self.CBZgroupResize.setEnabled(self.CBZactive.isChecked())
self.lnTranslatorHeader.setText(
config.get("translatorHeader", "Translator's Notes"))
self.chkIncludeTranslatorComments.setChecked(
config.get("includeTranslComment", False))
"""
Store the GUI values into the config dictionary given.
@return the config diactionary filled with new values.
"""
def getConfig(self, config):
config["cropToGuides"] = self.chk_toOutmostGuides.isChecked()
config["cropLeft"] = self.spn_marginLeft.value()
config["cropTop"] = self.spn_marginTop.value()
config["cropBottom"] = self.spn_marginRight.value()
config["cropRight"] = self.spn_marginBottom.value()
config["labelsToRemove"] = self.cmbLabelsRemove.getLabels()
config["CBZactive"] = self.CBZactive.isChecked()
config = self.CBZgroupResize.get_config(config)
config["EPUBactive"] = self.EPUBactive.isChecked()
config = self.EPUBgroupResize.get_config(config)
config["TIFFactive"] = self.TIFFactive.isChecked()
config = self.TIFFgroupResize.get_config(config)
authorList = []
for row in range(self.ACBFauthorTable.verticalHeader().count()):
logicalIndex = self.ACBFauthorTable.verticalHeader().logicalIndex(
row)
listEntries = [
"nickname", "first-name", "initials", "last-name", "email",
"homepage"
]
author = {}
for i in range(len(listEntries)):
entry = self.ACBFauthorModel.data(
self.ACBFauthorModel.index(logicalIndex, i))
if entry is None:
entry = " "
if entry.isspace() is False and len(entry) > 0:
author[listEntries[i]] = entry
elif listEntries[i] in author.keys():
author.pop(listEntries[i])
authorList.append(author)
config["acbfAuthor"] = authorList
config["acbfSource"] = self.lnACBFSource.text()
config["acbfID"] = self.lnACBFID.text()
config["acbfVersion"] = self.spnACBFVersion.value()
versionList = []
for r in range(self.ACBFhistoryModel.rowCount()):
index = self.ACBFhistoryModel.index(r, 0)
versionList.append(
self.ACBFhistoryModel.data(index, Qt.DisplayRole))
config["acbfHistory"] = versionList
acbfStylesDict = {}
for row in range(0, self.ACBFStylesModel.rowCount()):
entry = self.ACBFStylesModel.item(row)
if entry.checkState() == Qt.Checked:
key = entry.text().lower()
style = {}
font = entry.data(role=Qt.UserRole + 1)
if font is not None:
style["font"] = font
genericfont = entry.data(role=Qt.UserRole + 2)
if font is not None:
style["genericfont"] = genericfont
bold = entry.data(role=Qt.UserRole + 3)
if bold is not None:
style["bold"] = bold
italic = entry.data(role=Qt.UserRole + 4)
if italic is not None:
style["ital"] = italic
acbfStylesDict[key] = style
acbfStylesDict["general"] = {
"color": self.regularColor.currentColor().name()
}
acbfStylesDict["inverted"] = {
"color": self.invertedColor.currentColor().name()
}
config["acbfStyles"] = acbfStylesDict
config["translatorHeader"] = self.lnTranslatorHeader.text()
config[
"includeTranslComment"] = self.chkIncludeTranslatorComments.isChecked(
)
# Turn this into something that retreives from a line-edit when string freeze is over.
config["textLayerNames"] = self.ln_text_layer_name.text().split(",")
config["panelLayerNames"] = self.ln_panel_layer_name.text().split(",")
return config
class MainWindow(QMainWindow):
InsertTextButton = 10
items = {-2: "source", -3: "channel", -4: "sink"}
def __init__(self):
import _diagramscene_rc
super(MainWindow, self).__init__()
self.config_manipulations = FlumeConfig(self)
properties_generator.dump_props()
self.create_actions()
self.create_menus()
self.create_tool_box()
self.clicked_button_id = 0
self.scene = DiagramScene(self.item_menu)
self.scene.setSceneRect(QRectF(0, 0, 5000, 5000))
self.scene.itemInserted.connect(self.item_inserted)
self.scene.textInserted.connect(self.text_inserted)
self.scene.itemSelected.connect(self.item_selected)
self.create_tool_bars()
# self.scene.enable_grid()
layout = QHBoxLayout()
layout.addWidget(self.tool_box)
self.view = QGraphicsView(self.scene)
self.view.centerOn(0, 0)
layout.addWidget(self.view)
self.widget = QWidget()
self.widget.setLayout(layout)
self.setCentralWidget(self.widget)
self.setWindowTitle("The Flume Illustrator")
# noinspection PyAttributeOutsideInit,PyArgumentList
def create_actions(self):
self.to_front_action = QAction(QIcon(':/images/bringtofront.png'),
"Bring to &Front", self, shortcut="Ctrl+F",
statusTip="Bring item to front", triggered=self.bring_to_front)
self.send_back_action = QAction(QIcon(':/images/sendtoback.png'),
"Send to &Back", self, shortcut="Ctrl+B",
statusTip="Send item to back", triggered=self.send_to_back)
self.bold_action = QAction(QIcon(':/images/bold.png'),
"Bold", self, checkable=True, shortcut="Ctrl+B",
triggered=self.handle_font_change)
self.italic_action = QAction(QIcon(':/images/italic.png'),
"Italic", self, checkable=True, shortcut="Ctrl+I",
triggered=self.handle_font_change)
self.underline_action = QAction(QIcon(':/images/underline.png'),
"Underline", self, checkable=True, shortcut="Ctrl+U",
triggered=self.handle_font_change)
self.delete_action = QAction(QIcon(':/images/delete.png'),
"Delete", self, shortcut="Delete", statusTip='Delete item from diagram',
triggered=self.delete_item)
self.exit_action = QAction("Exit", self, shortcut="Ctrl+X",
statusTip="Quit program", triggered=self.close)
self.about_action = QAction("About", self, shortcut="Ctrl+B",
triggered=self.about)
self.load_config_action = QAction("Load", self, shortcut="Ctrl+O",
statusTip="Load config file", triggered=self.config_manipulations.load_config)
self.enable_grid_action = QAction("Enable grid", self, checkable=True, triggered=self.enable_grid)
# noinspection PyAttributeOutsideInit
def create_menus(self):
self.file_menu = self.menuBar().addMenu("File")
self.file_menu.addAction(self.load_config_action)
self.file_menu.addAction(self.exit_action)
self.item_menu = self.menuBar().addMenu("Item")
self.item_menu.addAction(self.delete_action)
self.item_menu.addSeparator()
self.item_menu.addAction(self.to_front_action)
self.item_menu.addAction(self.send_back_action)
self.about_menu = self.menuBar().addMenu("Help")
self.about_menu.addAction(self.about_action)
# noinspection PyAttributeOutsideInit,PyUnresolvedReferences
def create_tool_box(self):
self.button_group = QButtonGroup()
self.button_group.setExclusive(False)
self.button_group.buttonClicked[int].connect(self.button_group_clicked)
layout = QGridLayout()
layout.addWidget(self.create_cell_widget("Source", "source"), 0, 0)
layout.addWidget(self.create_cell_widget("Channel", "channel"), 0, 1)
layout.addWidget(self.create_cell_widget("Sink", "sink"), 1, 0)
text_button = QToolButton()
text_button.setCheckable(True)
self.button_group.addButton(text_button, self.InsertTextButton)
text_button.setIcon(QIcon(QPixmap(':/images/textpointer.png').scaled(30, 30)))
text_button.setIconSize(QSize(50, 50))
text_layout = QGridLayout()
text_layout.addWidget(text_button, 0, 0, Qt.AlignHCenter)
text_layout.addWidget(QLabel("Text"), 1, 0, Qt.AlignCenter)
text_widget = QWidget()
text_widget.setLayout(text_layout)
layout.addWidget(text_widget, 1, 1)
layout.setRowStretch(3, 10)
layout.setColumnStretch(2, 10)
item_widget = QWidget()
item_widget.setLayout(layout)
self.tool_box = QToolBox()
self.tool_box.setSizePolicy(QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Ignored))
self.tool_box.setMinimumWidth(item_widget.sizeHint().width())
self.tool_box.addItem(item_widget, "Basic Flume Items")
# noinspection PyAttributeOutsideInit,PyUnresolvedReferences
def create_tool_bars(self):
self.edit_tool_bar = self.addToolBar("Edit")
self.edit_tool_bar.addAction(self.delete_action)
self.edit_tool_bar.addAction(self.to_front_action)
self.edit_tool_bar.addAction(self.send_back_action)
self.edit_tool_bar.addAction(self.enable_grid_action)
self.font_combo = QFontComboBox()
self.font_combo.currentFontChanged.connect(self.current_font_changed)
self.font_size_combo = QComboBox()
self.font_size_combo.setEditable(True)
for i in range(8, 30, 2):
self.font_size_combo.addItem(str(i))
validator = QIntValidator(2, 64, self)
self.font_size_combo.setValidator(validator)
self.font_size_combo.currentIndexChanged.connect(self.font_size_changed)
self.font_color_tool_button = QToolButton()
self.font_color_tool_button.setPopupMode(QToolButton.MenuButtonPopup)
self.font_color_tool_button.setMenu(
self.create_color_menu(self.text_color_changed, Qt.black))
self.text_action = self.font_color_tool_button.menu().defaultAction()
self.font_color_tool_button.setIcon(
self.create_color_tool_button_icon(':/images/textpointer.png',
Qt.black))
self.font_color_tool_button.setAutoFillBackground(True)
self.font_color_tool_button.clicked.connect(self.text_button_triggered)
self.fill_color_tool_button = QToolButton()
self.fill_color_tool_button.setPopupMode(QToolButton.MenuButtonPopup)
self.fill_color_tool_button.setMenu(
self.create_color_menu(self.item_color_changed, Qt.white))
self.fillAction = self.fill_color_tool_button.menu().defaultAction()
self.fill_color_tool_button.setIcon(
self.create_color_tool_button_icon(':/images/floodfill.png',
Qt.white))
self.fill_color_tool_button.clicked.connect(self.fill_button_triggered)
self.line_color_tool_button = QToolButton()
self.line_color_tool_button.setPopupMode(QToolButton.MenuButtonPopup)
self.line_color_tool_button.setMenu(
self.create_color_menu(self.line_color_changed, Qt.black))
self.lineAction = self.line_color_tool_button.menu().defaultAction()
self.line_color_tool_button.setIcon(
self.create_color_tool_button_icon(':/images/linecolor.png',
Qt.black))
self.line_color_tool_button.clicked.connect(self.line_button_triggered)
self.text_tool_bar = self.addToolBar("Font")
self.text_tool_bar.addWidget(self.font_combo)
self.text_tool_bar.addWidget(self.font_size_combo)
self.text_tool_bar.addAction(self.bold_action)
self.text_tool_bar.addAction(self.italic_action)
self.text_tool_bar.addAction(self.underline_action)
self.color_tool_bar = self.addToolBar("Color")
self.color_tool_bar.addWidget(self.font_color_tool_button)
self.color_tool_bar.addWidget(self.fill_color_tool_button)
self.color_tool_bar.addWidget(self.line_color_tool_button)
self.loading_tool_bar = self.addToolBar("Load")
self.loading_tool_bar.addAction(self.load_config_action)
pointer_button = QToolButton()
pointer_button.setCheckable(True)
pointer_button.setChecked(True)
pointer_button.setIcon(QIcon(":/images/pointer.png"))
line_pointer_button = QToolButton()
line_pointer_button.setCheckable(True)
line_pointer_button.setIcon(QIcon(":/images/linepointer.png"))
self.pointer_type_group = QButtonGroup()
self.pointer_type_group.addButton(pointer_button, DiagramScene.MoveItem)
self.pointer_type_group.addButton(line_pointer_button, DiagramScene.InsertLine)
self.pointer_type_group.buttonClicked[int].connect(self.pointer_group_clicked)
self.scene_scale_combo = QComboBox()
self.scene_scale_combo.addItems(["50%", "75%", "100%", "125%", "150%"])
self.scene_scale_combo.setCurrentIndex(2)
self.scene_scale_combo.currentIndexChanged[str].connect(self.scene_scale_changed)
self.pointer_tool_bar = self.addToolBar("Pointer type")
self.pointer_tool_bar.addWidget(pointer_button)
self.pointer_tool_bar.addWidget(line_pointer_button)
self.pointer_tool_bar.addWidget(self.scene_scale_combo)
def button_group_clicked(self, button_id):
buttons = self.button_group.buttons()
self.clicked_button_id = button_id
for button in buttons:
if self.button_group.button(button_id) != button:
button.setChecked(False)
if button_id == self.InsertTextButton:
self.scene.set_mode(DiagramScene.InsertText)
else:
self.scene.set_item_type(self.items[button_id])
self.scene.set_mode(DiagramScene.InsertItem)
def delete_item(self):
for item in self.scene.selectedItems():
if isinstance(item, FlumeDiagramItem):
item.remove_arrows()
self.scene.removeItem(item)
# noinspection PyTypeChecker,PyCallByClass
def about(self):
# noinspection PyArgumentList
QMessageBox.about(self, "About Flume Illustrator", "The Flume illustrator shows config-file details")
def pointer_group_clicked(self):
self.scene.set_mode(self.pointer_type_group.checkedId())
def bring_to_front(self):
if not self.scene.selectedItems():
return
selected_item = self.scene.selectedItems()[0]
overlap_items = selected_item.collidingItems()
z_value = 0
for item in overlap_items:
if item.zValue() >= z_value and isinstance(item, FlumeDiagramItem):
z_value = item.zValue() + 0.1
selected_item.setZValue(z_value)
def send_to_back(self):
if not self.scene.selectedItems():
return
selected_item = self.scene.selectedItems()[0]
overlap_items = selected_item.collidingItems()
z_value = 0
for item in overlap_items:
if item.zValue() <= z_value and isinstance(item, FlumeDiagramItem):
z_value = item.zValue() - 0.1
selected_item.setZValue(z_value)
def scene_scale_changed(self, scale):
new_scale = float(scale[:scale.index("%")]) / 100
old_transform = self.view.transform()
self.view.resetTransform()
self.view.translate(old_transform.dx(), old_transform.dy())
self.view.scale(new_scale, new_scale)
def item_inserted(self, diagram_type):
self.pointer_type_group.button(DiagramScene.MoveItem).setChecked(True)
self.scene.set_mode(self.scene.DefaultMode)
self.button_group.button(self.clicked_button_id).setChecked(False)
def text_inserted(self, item):
self.button_group.button(self.InsertTextButton).setChecked(False)
self.scene.set_mode(self.pointer_type_group.checkedId())
def current_font_changed(self, font):
self.handle_font_change()
def font_size_changed(self, font=None):
self.handle_font_change()
def text_color_changed(self):
self.text_action = self.sender()
self.font_color_tool_button.setIcon(
self.create_color_tool_button_icon(':/images/textpointer.png',
QColor(self.text_action.data())))
self.text_button_triggered()
def item_color_changed(self):
self.fillAction = self.sender()
self.fill_color_tool_button.setIcon(
self.create_color_tool_button_icon(':/images/floodfill.png',
QColor(self.fillAction.data())))
self.fill_button_triggered()
def line_color_changed(self):
self.lineAction = self.sender()
self.line_color_tool_button.setIcon(
self.create_color_tool_button_icon(':/images/linecolor.png',
QColor(self.lineAction.data())))
self.line_button_triggered()
def text_button_triggered(self):
self.scene.set_text_color(QColor(self.text_action.data()))
def fill_button_triggered(self):
self.scene.set_item_color(QColor(self.fillAction.data()))
def line_button_triggered(self):
self.scene.set_line_color(QColor(self.lineAction.data()))
def handle_font_change(self):
font = self.font_combo.currentFont()
font.setPointSize(int(self.font_size_combo.currentText()))
if self.bold_action.isChecked():
font.setWeight(QFont.Bold)
else:
font.setWeight(QFont.Normal)
font.setItalic(self.italic_action.isChecked())
font.setUnderline(self.underline_action.isChecked())
self.scene.setFont(font)
def item_selected(self, item):
font = item.font()
self.font_combo.setCurrentFont(font)
self.font_size_combo.setEditText(str(font.pointSize()))
self.bold_action.setChecked(font.weight() == QFont.Bold)
self.italic_action.setChecked(font.italic())
self.underline_action.setChecked(font.underline())
def create_cell_widget(self, text, diagram_type):
item = FlumeObject(diagram_type, "")
icon = QIcon(item.pictogram.image())
button = QToolButton()
button.setIcon(icon)
button.setIconSize(QSize(50, 50))
button.setCheckable(True)
self.button_group.addButton(button) # , diagram_type
layout = QGridLayout()
layout.addWidget(button, 0, 0, Qt.AlignHCenter)
layout.addWidget(QLabel(text), 1, 0, Qt.AlignHCenter)
widget = QWidget()
widget.setLayout(layout)
return widget
# noinspection PyArgumentList
def create_color_menu(self, slot, default_color):
colors = [Qt.black, Qt.white, Qt.red, Qt.blue, Qt.yellow]
names = ["black", "white", "red", "blue", "yellow"]
color_menu = QMenu(self)
for color, name in zip(colors, names):
action = QAction(self.create_color_icon(color), name, self,
triggered=slot)
action.setData(QColor(color))
color_menu.addAction(action)
if color == default_color:
color_menu.setDefaultAction(action)
return color_menu
@staticmethod
def create_color_tool_button_icon(image_file, color):
pixmap = QPixmap(50, 80)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
image = QPixmap(image_file)
target = QRect(0, 0, 50, 60)
source = QRect(0, 0, 42, 42)
painter.fillRect(QRect(0, 60, 50, 80), color)
painter.drawPixmap(target, image, source)
painter.end()
return QIcon(pixmap)
@staticmethod
def create_color_icon(color):
pixmap = QPixmap(20, 20)
painter = QPainter(pixmap)
painter.setPen(Qt.NoPen)
painter.fillRect(QRect(0, 0, 20, 20), color)
painter.end()
return QIcon(pixmap)
def enable_grid(self):
if self.enable_grid_action.isChecked():
color = Qt.black
else:
color = Qt.white
for i in range(50):
for j in range(50):
self.scene.addEllipse(i * 100, j * 100, 2, 2, QPen(color))
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
# View widget stuff
self.view = TextView()
self.centralWidget = QWidget(self)
self.layout = QVBoxLayout(self.centralWidget)
self.view.statusChanged.connect(self.quickViewStatusChanged)
self.view.sceneGraphError.connect(self.sceneGraphError)
self.container = QWidget.createWindowContainer(self.view)
self.container.setMinimumSize(self.view.size())
self.container.setFocusPolicy(Qt.TabFocus)
self.layout.addWidget(self.container)
self.setCentralWidget(self.centralWidget)
self.statusBar().showMessage('Ready')
# Menu stuff
self.toolbar = self.addToolBar('Text Effects')
# Set up the text effects tools
actionGroup = QActionGroup(self)
noneAction = QAction(QIcon("none.png"), "&Clear", self)
noneAction.setStatusTip("Clear Effects")
noneAction.triggered.connect(self.view.noEffect)
actionGroup.addAction(noneAction)
blurAction = QAction(QIcon("blur.png"), "&Blur", self)
blurAction.setStatusTip("Blur Text")
blurAction.triggered.connect(self.view.blur)
actionGroup.addAction(blurAction)
opacityAction = QAction(QIcon("opacity.png"), "&Transparency", self)
opacityAction.setStatusTip("Fade Text")
opacityAction.triggered.connect(self.view.opacity)
actionGroup.addAction(opacityAction)
shadowAction = QAction(QIcon("shadow.png"), "&Drop Shadow", self)
shadowAction.setStatusTip("Drop-shadow Text")
shadowAction.triggered.connect(self.view.shadow)
actionGroup.addAction(shadowAction)
self.toolbar.addActions(actionGroup.actions())
self.toolbar.addSeparator()
# Set up the font selection tools
boldAction = QAction(QIcon("bold.png"), "&Bold", self)
boldAction.setStatusTip("Bold Text")
boldAction.setCheckable(True)
boldAction.setChecked(False)
boldAction.triggered[bool].connect(self.view.bold)
self.toolbar.addAction(boldAction)
italicAction = QAction(QIcon("italic.png"), "&Italic", self)
italicAction.setStatusTip("Italic Text")
italicAction.setCheckable(True)
italicAction.triggered[bool].connect(self.view.italic)
self.toolbar.addAction(italicAction)
self.fontBox = QFontComboBox(self)
self.fontBox.setCurrentFont(self.view.font)
self.fontBox.currentFontChanged.connect(self.view.fontFamily)
self.toolbar.addWidget(self.fontBox)
self.fontSizeBox = QComboBox(self)
self.fontSizeBox.setEditable(True)
strlist = []
intlist = QFontDatabase.standardSizes()
for item in intlist:
strlist.append(str(item))
self.fontSizeBox.addItems(strlist)
self.view.fontSize('24')
self.fontSizeBox.setCurrentText(str(self.view.basicFontSize))
self.fontSizeBox.currentTextChanged.connect(self.view.fontSize)
self.toolbar.addWidget(self.fontSizeBox)
self.setGeometry(300, 300, 600, 500)
self.setWindowTitle('Renderer')
self.show()
def quickViewStatusChanged(status):
if status is QQuickView.Error:
errors = []
for error in self.quickView.errors():
errors.append(str(error))
self.statusBar().showmessage((', ').join(errors))
def sceneGraphError(error, message):
self.statusBar.showMessage(message)
class Preferences(QDialog):
# Signal to warn that the window is closed
settingsClosed = pyqtSignal()
def __init__(self, parent=None):
super(Preferences, self).__init__(parent)
# Main container
# This contains a grid
main_box = QVBoxLayout(self)
main_box.setContentsMargins(200, 50, 200, 100)
# The grid contains two containers
# left container and right container
grid = QGridLayout()
# Left Container
left_container = QVBoxLayout()
left_container.setContentsMargins(0, 0, 0, 0)
# General
group_gral = QGroupBox(self.tr("General"))
box_gral = QVBoxLayout(group_gral)
# Updates
btn_updates = QPushButton(self.tr("Check for updates"))
box_gral.addWidget(btn_updates)
# Language
group_language = QGroupBox(self.tr("Language"))
box = QVBoxLayout(group_language)
# Find .qm files in language path
available_langs = file_manager.get_files_from_folder(
settings.LANGUAGE_PATH)
languages = ["English"] + available_langs
self._combo_lang = QComboBox()
box.addWidget(self._combo_lang)
self._combo_lang.addItems(languages)
self._combo_lang.currentIndexChanged[int].connect(
self._change_lang)
if PSetting.LANGUAGE:
self._combo_lang.setCurrentText(PSetting.LANGUAGE)
box.addWidget(QLabel(self.tr("(Requires restart)")))
# Add widgets
left_container.addWidget(group_gral)
left_container.addWidget(group_language)
left_container.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding,
QSizePolicy.Expanding))
# Right Container
right_container = QVBoxLayout()
right_container.setContentsMargins(0, 0, 0, 0)
# Editor
editor_group = QGroupBox(self.tr("Editor Configurations"))
box_editor = QHBoxLayout(editor_group)
# Current line
self._highlight_current_line = QCheckBox(
self.tr("Highlight Current Line"))
self._highlight_current_line.setChecked(
PSetting.HIGHLIGHT_CURRENT_LINE)
self._highlight_current_line.stateChanged[int].connect(
self.__current_line_value_changed)
box_editor.addWidget(self._highlight_current_line)
# Matching paren
self._matching_paren = QCheckBox(self.tr("Matching Parenthesis"))
self._matching_paren.setChecked(
PSetting.MATCHING_PARENTHESIS)
self._matching_paren.stateChanged[int].connect(
self.__set_enabled_matching_parenthesis)
box_editor.addWidget(self._matching_paren)
# Font group
font_group = QGroupBox(self.tr("Font"))
font_grid = QGridLayout(font_group)
font_grid.addWidget(QLabel(self.tr("Family")), 0, 0)
self._combo_font = QFontComboBox()
self._combo_font.setCurrentFont(PSetting.FONT)
font_grid.addWidget(self._combo_font, 0, 1)
font_grid.addWidget(QLabel(self.tr("Point Size")), 1, 0)
self._combo_font_size = QComboBox()
fdb = QFontDatabase()
combo_sizes = fdb.pointSizes(PSetting.FONT.family())
current_size_index = combo_sizes.index(
PSetting.FONT.pointSize())
self._combo_font_size.addItems([str(f) for f in combo_sizes])
self._combo_font_size.setCurrentIndex(current_size_index)
font_grid.addWidget(self._combo_font_size, 1, 1)
right_container.addWidget(editor_group)
right_container.addWidget(font_group)
right_container.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding,
QSizePolicy.Expanding))
# Add widgets
grid.addLayout(left_container, 0, 0)
grid.addLayout(right_container, 0, 1)
main_box.addLayout(grid)
# Button close and reset
hbox = QHBoxLayout()
hbox.setSpacing(20)
hbox.addItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
btn_cancel = QPushButton(self.tr("Back"))
hbox.addWidget(btn_cancel)
btn_reset = QPushButton(self.tr("Reset Configurations"))
hbox.addWidget(btn_reset)
main_box.addLayout(hbox)
# Overlay
self.overlay = overlay_widget.OverlayWidget(self)
self.overlay.hide()
# Effect and animations
self.effect = QGraphicsOpacityEffect()
self.setGraphicsEffect(self.effect)
duration, x = 180, 150 # Animation duration
# Animation start
# Opacity animation
self.opacity_animation_s = QPropertyAnimation(self.effect, b"opacity")
self.opacity_animation_s.setDuration(duration)
self.opacity_animation_s.setStartValue(0.0)
self.opacity_animation_s.setEndValue(1.0)
# X animation
self.x_animation_s = QPropertyAnimation(self, b"geometry")
self.x_animation_s.setDuration(duration)
self.x_animation_s.setStartValue(QRect(x, 0, parent.width(),
parent.height()))
self.x_animation_s.setEndValue(QRect(0, 0, parent.width(),
parent.height()))
# Animation end
# Opacity animation
self.opacity_animation_e = QPropertyAnimation(self.effect, b"opacity")
self.opacity_animation_e.setDuration(duration)
self.opacity_animation_e.setStartValue(1.0)
self.opacity_animation_e.setEndValue(0.0)
# X animation
self.x_animation_e = QPropertyAnimation(self, b"geometry")
self.x_animation_e.setDuration(duration)
self.x_animation_e.setStartValue(QRect(0, 0, parent.width(),
parent.height()))
self.x_animation_e.setEndValue(QRect(-x, 0, parent.width(),
parent.height()))
# Group animation start
self.group_animation_s = QParallelAnimationGroup()
self.group_animation_s.addAnimation(self.opacity_animation_s)
self.group_animation_s.addAnimation(self.x_animation_s)
# Group animation end
self.group_animation_e = QParallelAnimationGroup()
self.group_animation_e.addAnimation(self.opacity_animation_e)
self.group_animation_e.addAnimation(self.x_animation_e)
# Connections
self.group_animation_e.finished.connect(
self._on_group_animation_finished)
btn_cancel.clicked.connect(self.close)
btn_reset.clicked.connect(self._reset_settings)
btn_updates.clicked.connect(self._check_for_updates)
# self.thread.finished.connect(self._on_thread_finished)
self._combo_font.currentFontChanged.connect(
self._change_font)
self._combo_font_size.currentTextChanged.connect(
self._change_font_size)
def __current_line_value_changed(self, value):
qs = QSettings(settings.SETTINGS_PATH, QSettings.IniFormat)
qs.setValue('highlight_current_line', value)
PSetting.HIGHLIGHT_CURRENT_LINE = value
def __set_enabled_matching_parenthesis(self, value):
qs = QSettings(settings.SETTINGS_PATH, QSettings.IniFormat)
qs.setValue("matching_parenthesis", value)
PSetting.MATCHING_PARENTHESIS = value
def _change_font(self, font):
# FIXME: un quilombo esto
central = Pireal.get_service("central")
mcontainer = central.get_active_db()
if mcontainer is not None:
query_widget = mcontainer.query_container.currentWidget()
if query_widget is not None:
weditor = query_widget.get_editor()
if weditor is not None:
qs = QSettings(settings.SETTINGS_PATH, QSettings.IniFormat)
weditor.set_font(font)
qs.setValue("font", font)
def _change_font_size(self, size):
# FIXME: un quilombo esto
font = self._combo_font.currentFont()
font.setPointSize(int(size))
central = Pireal.get_service("central")
mcontainer = central.get_active_db()
if mcontainer is not None:
query_widget = mcontainer.query_container.currentWidget()
if query_widget is not None:
weditor = query_widget.get_editor()
if weditor is not None:
qs = QSettings(settings.SETTINGS_PATH, QSettings.IniFormat)
weditor.set_font(font)
qs.setValue("font", font)
def showEvent(self, event):
super(Preferences, self).showEvent(event)
self.group_animation_s.start()
def resizeEvent(self, event):
self.overlay.resize(self.size())
event.accept()
def done(self, result):
self.res = result
self.group_animation_e.start()
def _on_group_animation_finished(self):
super(Preferences, self).done(self.res)
self.settingsClosed.emit()
def _check_for_updates(self):
# Thread
self._thread = QThread()
self._updater = updater.Updater()
self._updater.moveToThread(self._thread)
self._thread.started.connect(self._updater.check_updates)
self._updater.finished.connect(self.__on_thread_update_finished)
# Show overlay widget
self.overlay.show()
# Start thread
self._thread.start()
def __on_thread_update_finished(self):
# Hide overlay widget
self.overlay.hide()
self._thread.quit()
msg = QMessageBox(self)
if not self._updater.error:
if self._updater.version:
version = self._updater.version
msg.setWindowTitle(self.tr("New version available!"))
msg.setText(self.tr("Check the web site to "
"download <b>Pireal {}</b>".format(
version)))
download_btn = msg.addButton(self.tr("Download!"),
QMessageBox.YesRole)
msg.addButton(self.tr("Cancel"),
QMessageBox.RejectRole)
msg.exec_()
r = msg.clickedButton()
if r == download_btn:
webbrowser.open_new(
"http://centaurialpha.github.io/pireal")
else:
msg.setWindowTitle(self.tr("Information"))
msg.setText(self.tr("Last version installed"))
msg.addButton(self.tr("Ok"),
QMessageBox.AcceptRole)
msg.exec_()
else:
msg.critical(self, self.tr("Error"),
self.tr("Connection error"))
self._thread.deleteLater()
self._updater.deleteLater()
def _reset_settings(self):
""" Remove all settings """
msg = QMessageBox(self)
msg.setWindowTitle(self.tr("Reset Settings"))
msg.setText(self.tr("Are you sure you want to clear all settings?"))
msg.setIcon(QMessageBox.Question)
msg.addButton(self.tr("No"), QMessageBox.NoRole)
yes_btn = msg.addButton(self.tr("Yes"),
QMessageBox.YesRole)
msg.exec_()
r = msg.clickedButton()
if r == yes_btn:
QSettings(settings.SETTINGS_PATH, QSettings.IniFormat).clear()
self.close()
def _change_lang(self, index):
lang = self._combo_lang.itemText(index)
qs = QSettings(settings.SETTINGS_PATH, QSettings.IniFormat)
qs.setValue('language', lang)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
# self.path holds the path of the currently open file
# If none, we haven't got a file open yet (or creating new)
self.path = None
self.origin_text_length = 0
self.modified_text_length = 0
self.setup()
self.menu_and_toolbar()
self.slot()
# Initialize
self.update_format()
self.update_title()
self.show()
def setup(self):
layout = QVBoxLayout()
# Editor 설정
self.editor = TextEdit()
self.editor.setAutoFormatting(QTextEdit.AutoAll)
font = QFont("Times", 12)
self.editor.setFont(font)
self.editor.setFontPointSize(12)
self.convert_button = QPushButton("Convert")
layout.addWidget(self.editor)
layout.addWidget(self.convert_button)
container = QWidget()
container.setLayout(layout)
self.setCentralWidget(container)
self.status = QStatusBar()
self.setStatusBar(self.status)
self.menuBar().setNativeMenuBar(False)
def slot(self):
self.editor.selectionChanged.connect(self.update_format)
self.bold_action.toggled.connect(
lambda x: self.editor.setFontWeight(QFont.Bold if x else QFont.Normal)
)
self.italic_action.toggled.connect(self.editor.setFontItalic)
self.underline_action.toggled.connect(self.editor.setFontUnderline)
self.new_file_action.triggered.connect(self.new_file)
self.open_file_action.triggered.connect(self.file_open)
self.save_file_action.triggered.connect(self.file_save)
self.saveas_file_action.triggered.connect(self.file_saveas)
self.undo_action.triggered.connect(self.editor.undo)
self.redo_action.triggered.connect(self.editor.redo)
self.cut_action.triggered.connect(self.editor.cut)
self.copy_action.triggered.connect(self.editor.copy)
self.paste_action.triggered.connect(self.editor.paste)
self.select_action.triggered.connect(self.editor.selectAll)
self.wrap_action.triggered.connect(self.edit_toggle_wrap)
self.fonts.currentIndexChanged.connect(self.editor.setCurrentFont)
self.fontsize.currentIndexChanged[str].connect(
lambda s: self.editor.setFontPointSize(float(s))
)
self.text_color_action.triggered.connect(self.change_text_color)
self.text_background_color_action.triggered.connect(
self.change_text_background_color
)
self.alignl_action.triggered.connect(
lambda: self.editor.setAlignment(Qt.AlignLeft)
)
self.alignc_action.triggered.connect(
lambda: self.editor.setAlignment(Qt.AlignCenter)
)
self.alignr_action.triggered.connect(
lambda: self.editor.setAlignment(Qt.AlignRight)
)
self.alignj_action.triggered.connect(
lambda: self.editor.setAlignment(Qt.AlignJustify)
)
self.convert_button.clicked.connect(self.convert_to_html)
def menu_and_toolbar(self):
file_toolbar = QToolBar("File")
file_toolbar.setIconSize(QSize(14, 14))
self.addToolBar(file_toolbar)
file_menu = self.menuBar().addMenu("&File")
self.new_file_action = QAction(
QIcon(os.path.join("images", "document-plus.png")), "New file", self
)
self.new_file_action.setStatusTip("Create new file")
file_menu.addAction(self.new_file_action)
file_toolbar.addAction(self.new_file_action)
self.open_file_action = QAction(
QIcon(os.path.join("images", "blue-folder-open-document.png")),
"Open file...",
self,
)
self.open_file_action.setStatusTip("Open file")
file_menu.addAction(self.open_file_action)
file_toolbar.addAction(self.open_file_action)
self.save_file_action = QAction(
QIcon(os.path.join("images", "disk.png")), "Save", self
)
self.save_file_action.setStatusTip("Save current page")
file_menu.addAction(self.save_file_action)
file_toolbar.addAction(self.save_file_action)
self.saveas_file_action = QAction(
QIcon(os.path.join("images", "disk--pencil.png")), "Save As...", self
)
self.saveas_file_action.setStatusTip("Save current page to specified file")
file_menu.addAction(self.saveas_file_action)
file_toolbar.addAction(self.saveas_file_action)
edit_toolbar = QToolBar("Edit")
edit_toolbar.setIconSize(QSize(16, 16))
self.addToolBar(edit_toolbar)
edit_menu = self.menuBar().addMenu("&Edit")
self.undo_action = QAction(
QIcon(os.path.join("images", "arrow-curve-180-left.png")), "Undo", self
)
self.undo_action.setStatusTip("Undo last change")
edit_menu.addAction(self.undo_action)
edit_toolbar.addAction(self.undo_action)
self.redo_action = QAction(
QIcon(os.path.join("images", "arrow-curve.png")), "Redo", self
)
self.redo_action.setStatusTip("Redo last change")
edit_menu.addAction(self.redo_action)
edit_toolbar.addAction(self.redo_action)
edit_menu.addSeparator()
self.cut_action = QAction(
QIcon(os.path.join("images", "scissors.png")), "Cut", self
)
self.cut_action.setStatusTip("Cut selected text")
self.cut_action.setShortcut(QKeySequence.Cut)
edit_toolbar.addAction(self.cut_action)
edit_menu.addAction(self.cut_action)
self.copy_action = QAction(
QIcon(os.path.join("images", "document-copy.png")), "Copy", self
)
self.copy_action.setStatusTip("Copy selected text")
self.copy_action.setShortcut(QKeySequence.Copy)
edit_toolbar.addAction(self.copy_action)
edit_menu.addAction(self.copy_action)
self.paste_action = QAction(
QIcon(os.path.join("images", "clipboard-paste-document-text.png")),
"Paste",
self,
)
self.paste_action.setStatusTip("Paste from clipboard")
self.paste_action.setShortcut(QKeySequence.Paste)
edit_toolbar.addAction(self.paste_action)
edit_menu.addAction(self.paste_action)
self.select_action = QAction(
QIcon(os.path.join("images", "selection-input.png")), "Select all", self
)
self.select_action.setStatusTip("Select all text")
self.select_action.setShortcut(QKeySequence.SelectAll)
edit_menu.addAction(self.select_action)
edit_toolbar.addAction(self.select_action)
edit_menu.addSeparator()
self.wrap_action = QAction(
QIcon(os.path.join("images", "arrow-continue.png")),
"Wrap text to window",
self,
)
self.wrap_action.setStatusTip("Toggle wrap text to window")
self.wrap_action.setCheckable(True)
self.wrap_action.setChecked(True)
edit_menu.addAction(self.wrap_action)
edit_toolbar.addAction(self.wrap_action)
format_toolbar = QToolBar("Format")
format_toolbar.setIconSize(QSize(16, 16))
self.addToolBar(format_toolbar)
format_menu = self.menuBar().addMenu("&Foramt")
self.fonts = QFontComboBox()
format_toolbar.addWidget(self.fonts)
self.fontsize = QComboBox()
self.fontsize.addItems([str(s) for s in FONT_SIZES])
format_toolbar.addWidget(self.fontsize)
self.bold_action = QAction(
QIcon(os.path.join("images", "edit-bold.png")), "Bold", self
)
self.bold_action.setStatusTip("Bold")
self.bold_action.setShortcut(QKeySequence.Bold)
self.bold_action.setCheckable(True)
format_toolbar.addAction(self.bold_action)
format_menu.addAction(self.bold_action)
self.italic_action = QAction(
QIcon(os.path.join("images", "edit-italic.png")), "Italic", self
)
self.italic_action.setStatusTip("Italic")
self.italic_action.setShortcut(QKeySequence.Italic)
self.italic_action.setCheckable(True)
format_toolbar.addAction(self.italic_action)
format_menu.addAction(self.italic_action)
self.underline_action = QAction(
QIcon(os.path.join("images", "edit-underline.png")), "Underline", self
)
self.underline_action.setStatusTip("Underline")
self.underline_action.setShortcut(QKeySequence.Underline)
self.underline_action.setCheckable(True)
format_toolbar.addAction(self.underline_action)
format_menu.addAction(self.underline_action)
self.text_color_action = QAction(
QIcon(os.path.join("images", "color-pencil.png")), "Text Color", self
)
self.text_color_action.setStatusTip("Change text color")
format_toolbar.addAction(self.text_color_action)
format_menu.addAction(self.text_color_action)
self.text_background_color_action = QAction(
QIcon(os.path.join("images", "color.png")), "Background Color", self
)
self.text_background_color_action.setStatusTip("Change text background color")
format_toolbar.addAction(self.text_background_color_action)
format_menu.addAction(self.text_background_color_action)
format_menu.addSeparator()
format_toolbar.addSeparator()
self.alignl_action = QAction(
QIcon(os.path.join("images", "edit-alignment.png")), "Align left", self
)
self.alignl_action.setStatusTip("Align text left")
self.alignl_action.setCheckable(True)
format_toolbar.addAction(self.alignl_action)
format_menu.addAction(self.alignl_action)
self.alignc_action = QAction(
QIcon(os.path.join("images", "edit-alignment-center.png")),
"Align center",
self,
)
self.alignc_action.setStatusTip("Align text center")
self.alignc_action.setCheckable(True)
format_toolbar.addAction(self.alignc_action)
format_menu.addAction(self.alignc_action)
self.alignr_action = QAction(
QIcon(os.path.join("images", "edit-alignment-right.png")),
"Align right",
self,
)
self.alignr_action.setStatusTip("Align text right")
self.alignr_action.setCheckable(True)
format_toolbar.addAction(self.alignr_action)
format_menu.addAction(self.alignr_action)
self.alignj_action = QAction(
QIcon(os.path.join("images", "edit-alignment-justify.png")), "Justify", self
)
self.alignj_action.setStatusTip("Justify text")
self.alignj_action.setCheckable(True)
format_toolbar.addAction(self.alignj_action)
format_menu.addAction(self.alignj_action)
format_group = QActionGroup(self)
format_group.setExclusive(True)
format_group.addAction(self.alignl_action)
format_group.addAction(self.alignc_action)
format_group.addAction(self.alignr_action)
format_group.addAction(self.alignj_action)
format_menu.addSeparator()
def new_file(self):
if self.path:
if self.origin_text_length != self.modified_text_length:
button_reply = QMessageBox.question(
self,
"PyQt5 Message",
"Do you want to save?",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes,
)
if button_reply == QMessageBox.Yes:
self.file_save()
self.path = None
else:
text = self.editor.toPlainText()
if len(text) > 0:
button_reply = QMessageBox.question(
self,
"PyQt5 message",
"Do you want to save?",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes,
)
if button_reply == QMessageBox.Yes:
self.file_save()
self.editor.selectAll()
self.editor.clear()
self.update_title()
def block_signals(self, objects, b):
for o in objects:
o.blockSignals(b)
def update_format(self):
"""
Update the font format toolbar/action when a new text selection is made.
This is neccessary to keep toolbars/etc.
in sync with the current edit state
:return:
"""
# A list of all format-related widgets/actions, so we can disable/enable signals when updating.
self._format_action = [
self.fonts,
self.fontsize,
self.bold_action,
self.italic_action,
self.underline_action,
]
# Disable signals for all format widgets, so changing values here does not trigger further formatting
self.block_signals(self._format_action, True)
self.fonts.setCurrentFont(self.editor.currentFont())
self.fontsize.setCurrentText(str(int(self.editor.fontPointSize())))
self.italic_action.setChecked(self.editor.fontItalic())
self.underline_action.setChecked(self.editor.fontUnderline())
self.bold_action.setChecked(self.editor.fontWeight() == QFont.Bold)
self.alignl_action.setChecked(self.editor.alignment() == Qt.AlignLeft)
self.alignc_action.setChecked(self.editor.alignment() == Qt.AlignCenter)
self.alignr_action.setChecked(self.editor.alignment() == Qt.AlignRight)
self.alignj_action.setChecked(self.editor.alignment() == Qt.AlignJustify)
self.block_signals(self._format_action, False)
def file_open(self):
path, _ = QFileDialog.getOpenFileName(
self,
"Open file",
"",
"HTML documents (*.html);Text Documents (*.txt);All files (*.*)",
)
try:
with open(path, "r") as f:
text = f.read()
except Exception as e:
self.dialog_critical(str(e))
else:
self.path = path
# Qt will automatically try and guess the format as txt/html
self.editor.setText(text)
self.update_title()
def file_save(self):
if self.path is None:
# If we do not have a path, we need to use Save As.
return self.file_saveas()
text = (
self.editor.toHtml()
if splitext(self.path) in HTML_EXTENSIONS
else self.editor.toPlainText()
)
try:
with open(self.path, "w") as f:
f.write(text)
except Exception as e:
self.dialog_critical(str(e))
def file_saveas(self):
path, _ = QFileDialog.getSaveFileName(
self,
"Save file",
"",
"HTML documents (*.html);Text documents (*.txt);All files (*.*)",
)
if not path:
# If dialog is cancelled, will return ''
return
text = (
self.editor.toHtml()
if splitext(path) in HTML_EXTENSIONS
else self.editor.toPlainText()
)
try:
with open(path, "w") as f:
f.write(text)
except Exception as e:
self.dialog_critical(str(e))
else:
self.path = path
self.update_title()
def convert_to_html(self):
dialog = QDialog()
tool_bar = QToolBar("Edit")
tool_bar.setIconSize(QSize(14, 14))
self.copy_html_button = QPushButton("Copy")
self.html_dialog_editor = QTextEdit()
self.html_dialog_editor.setReadOnly(True)
html = self.editor.toHtml()
body = re.search("<body.*/body>", html, re.I | re.S)
self.html_dialog_editor.setPlainText(body.group()[89:-7])
layout = QVBoxLayout()
layout.addWidget(self.copy_html_button)
layout.addWidget(self.html_dialog_editor)
dialog.setLayout(layout)
self.copy_html_button.clicked.connect(self.copy_html)
dialog.exec()
def copy_html(self):
self.html_dialog_editor.selectAll()
self.html_dialog_editor.copy()
def update_title(self):
self.setWindowTitle(os.path.basename(self.path) if self.path else "Untitled")
def edit_toggle_wrap(self):
self.editor.setLineWrapMode(1 if self.editor.lineWrapMode() == 0 else 0)
def _get_color(self):
color = QColorDialog()
selected_color = color.getColor()
if selected_color.isValid():
return selected_color
def change_text_color(self):
color = self._get_color()
if color is not None:
self.editor.setTextColor(color)
def change_text_background_color(self):
color = self._get_color()
if color is not None:
self.editor.setTextBackgroundColor(color)
def dialog_critical(self, s):
dlg = QMessageBox(self)
dlg.setText(s)
dlg.setIcon(QMessageBox.Critical)
dlg.show()
class SettingsEditDialog(QDialog):
def __init__(self, parent=None):
super().__init__(parent)
self.setModal(True)
self.setWindowTitle('Settings')
self.setMinimumWidth(400)
self.accepted.connect(self.save)
# Editor group
self.font_family_input = QFontComboBox()
self.font_size_input = QSpinBox()
self.font_size_input.setRange(8, 24)
self.font_size_input.setSuffix(' pt')
self.tab_size_input = QSpinBox()
self.tab_size_input.setRange(1, 16)
self.tab_size_input.setSuffix(' spaces')
self.enable_text_wrapping_input = QCheckBox('Enable text wrapping')
editor_layout = QFormLayout()
editor_layout.addRow('Font family:', self.font_family_input)
editor_layout.addRow('Font size:', self.font_size_input)
editor_layout.addRow('Tab size:', self.tab_size_input)
editor_layout.addRow('', self.enable_text_wrapping_input)
editor_group = QGroupBox('Editor')
editor_group.setLayout(editor_layout)
# Buttons
edit_project_button = QPushButton('Edit default project...')
edit_project_button.clicked.connect(
lambda: projects.show_edit_dialog('default'))
save_button = QPushButton('OK')
save_button.setDefault(True)
save_button.clicked.connect(self.accept)
cancel_button = QPushButton('Cancel')
cancel_button.clicked.connect(self.reject)
button_layout = QHBoxLayout()
button_layout.addWidget(edit_project_button, 1, Qt.AlignLeft)
button_layout.addWidget(save_button, 0, Qt.AlignRight)
button_layout.addWidget(cancel_button)
# Main layout
main_layout = QVBoxLayout()
main_layout.addWidget(editor_group)
main_layout.addLayout(button_layout)
self.setLayout(main_layout)
def show(self):
font = QFont(value('editor/font_family'))
self.font_family_input.setCurrentFont(font)
self.font_family_input.setCurrentText(QFontInfo(font).family())
self.font_family_input.setFocus(Qt.OtherFocusReason)
self.font_size_input.setValue(value('editor/font_size'))
self.tab_size_input.setValue(value('editor/tab_size'))
self.enable_text_wrapping_input.setChecked(
value('editor/enable_text_wrapping'))
super().show()
def save(self):
set_value('editor/font_family',
QFontInfo(self.font_family_input.currentFont()).family())
set_value('editor/font_size', self.font_size_input.value())
set_value('editor/tab_size', self.tab_size_input.value())
set_value('editor/enable_text_wrapping',
self.enable_text_wrapping_input.isChecked())
edit_dialog_saved().emit()
class GlobalFontDialog(widgets.dialog.Dialog):
def __init__(self, parent=None):
super(GlobalFontDialog, self).__init__(parent)
self._messageLabel.setWordWrap(True)
layout = QGridLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.mainWidget().setLayout(layout)
self.romanLabel = QLabel()
self.romanCombo = QFontComboBox()
self.sansLabel = QLabel()
self.sansCombo = QFontComboBox()
self.typewriterLabel = QLabel()
self.typewriterCombo = QFontComboBox(fontFilters=QFontComboBox.MonospacedFonts)
layout.addWidget(self.romanLabel, 0, 0)
layout.addWidget(self.romanCombo, 0, 1, 1, 2)
layout.addWidget(self.sansLabel, 1, 0)
layout.addWidget(self.sansCombo, 1, 1, 1, 2)
layout.addWidget(self.typewriterLabel, 2, 0)
layout.addWidget(self.typewriterCombo, 2, 1, 1, 2)
self.loadSettings()
self.finished.connect(self.saveSettings)
app.translateUI(self)
def translateUI(self):
self.setWindowTitle(app.caption(_("Global Fonts")))
self.setMessage(_(
"Please select the three global fonts to use for "
r"<code>\roman</code>, <code>\sans</code>, and <code>\typewriter</code> "
"respectively."))
self.romanLabel.setText(_("Roman Font:"))
self.sansLabel.setText(_("Sans Font:"))
self.typewriterLabel.setText(_("Typewriter Font:"))
def romanFont(self):
return self.romanCombo.currentFont().family()
def setromanFont(self, family):
self.romanCombo.setCurrentFont(QFont(family))
def sansFont(self):
return self.sansCombo.currentFont().family()
def setSansFont(self, family):
self.sansCombo.setCurrentFont(QFont(family))
def typewriterFont(self):
return self.typewriterCombo.currentFont().family()
def settypewriterFont(self, family):
self.typewriterCombo.setCurrentFont(QFont(family))
def loadSettings(self):
s = QSettings()
s.beginGroup("global_font_dialog")
roman = s.value("roman", "Century Schoolbook L", str)
self.romanCombo.setCurrentFont(QFont(roman))
sans = s.value("sans", "sans-serif", str)
self.sansCombo.setCurrentFont(QFont(sans))
typewriter = s.value("typewriter", "monospace", str)
self.typewriterCombo.setCurrentFont(QFont(typewriter))
def saveSettings(self):
s = QSettings()
s.beginGroup("global_font_dialog")
s.setValue("roman", self.romanCombo.currentFont().family())
s.setValue("sans", self.sansCombo.currentFont().family())
s.setValue("typewriter", self.typewriterCombo.currentFont().family())
class LogTool(preferences.Group):
def __init__(self, page):
super(LogTool, self).__init__(page)
layout = QVBoxLayout()
self.setLayout(layout)
self.fontLabel = QLabel()
self.fontChooser = QFontComboBox(currentFontChanged=self.changed)
self.fontSize = QDoubleSpinBox(valueChanged=self.changed)
self.fontSize.setRange(6.0, 32.0)
self.fontSize.setSingleStep(0.5)
self.fontSize.setDecimals(1)
box = QHBoxLayout()
box.addWidget(self.fontLabel)
box.addWidget(self.fontChooser, 1)
box.addWidget(self.fontSize)
layout.addLayout(box)
self.showlog = QCheckBox(toggled=self.changed)
layout.addWidget(self.showlog)
self.rawview = QCheckBox(toggled=self.changed)
layout.addWidget(self.rawview)
self.hideauto = QCheckBox(toggled=self.changed)
layout.addWidget(self.hideauto)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("LilyPond Log"))
self.fontLabel.setText(_("Font:"))
self.showlog.setText(_("Show log when a job is started"))
self.rawview.setText(_("Display plain log output"))
self.rawview.setToolTip(_(
"If checked, Frescobaldi will not shorten filenames in the log output."""))
self.hideauto.setText(_("Hide automatic engraving jobs"))
self.hideauto.setToolTip(_(
"If checked, Frescobaldi will not show the log for automatically\n"
"started engraving jobs (LilyPond->Auto-engrave)."))
def loadSettings(self):
s = QSettings()
s.beginGroup("log")
font = QFont(s.value("fontfamily", "monospace", str))
font.setPointSizeF(s.value("fontsize", 9.0, float))
with qutil.signalsBlocked(self.fontChooser, self.fontSize):
self.fontChooser.setCurrentFont(font)
self.fontSize.setValue(font.pointSizeF())
self.showlog.setChecked(s.value("show_on_start", True, bool))
self.rawview.setChecked(s.value("rawview", True, bool))
self.hideauto.setChecked(s.value("hide_auto_engrave", False, bool))
def saveSettings(self):
s = QSettings()
s.beginGroup("log")
s.setValue("fontfamily", self.fontChooser.currentFont().family())
s.setValue("fontsize", self.fontSize.value())
s.setValue("show_on_start", self.showlog.isChecked())
s.setValue("rawview", self.rawview.isChecked())
s.setValue("hide_auto_engrave", self.hideauto.isChecked())
class SettingsDialog(QDialog):
def __init__(self, settings: Settings):
super(SettingsDialog, self).__init__()
self.settings = settings
self.setWindowTitle("Sticky Note - Settings")
self.layout = QFormLayout()
self.fontSizeBox = QComboBox(self)
for i in settings.getAllFontSizes():
self.fontSizeBox.addItem(str(i))
self.fontSizeBox.setCurrentText(str(settings.getFontSize()))
self.layout.addRow("Font size", self.fontSizeBox)
self.fontSizeBox.currentIndexChanged.connect(self.fontSizeChanged)
self.fontFamilyBox = QFontComboBox(self)
self.layout.addRow("Font Family", self.fontFamilyBox)
self.fontFamilyBox.setCurrentFont(QFont(settings.getFontFamily()))
self.fontFamilyBox.currentIndexChanged.connect(self.fontFamilyChanged)
self.colorButton = QPushButton('', self)
color = QColor(settings.getFontColor())
self.fontColorChanged(color)
self.colorButton.clicked.connect(self.showColors)
self.layout.addRow("Font Color", self.colorButton)
isAutoStartCheckBox = QCheckBox("Enable start on startup", self)
#self.layout.addRow("", isAutoStartCheckBox)
isAutoStartCheckBox.stateChanged.connect(self.actionEnableAutoStart)
isAutoStartCheckBox.setChecked(settings.getStartOnStartup())
QBtn = QDialogButtonBox.Ok | QDialogButtonBox.Cancel
self.buttonBox = QDialogButtonBox(QBtn)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.layout.addRow(self.buttonBox)
self.setLayout(self.layout)
self.setWindowFlags(Qt.Window)
self.setFixedSize(350, 150)
def fontColorChanged(self, color):
if (color.isValid()):
self.colorButton.setStyleSheet(
"background-color: {0};border-color: {0}".format(color.name()))
self.settings.setFontColor(color.name())
def showColors(self):
colorDialog = QColorDialog()
color = colorDialog.getColor()
if color:
self.fontColorChanged(color)
def fontSizeChanged(self):
fontSize = str(self.fontSizeBox.currentText())
self.settings.setFontSize(fontSize)
def fontFamilyChanged(self):
fontFamily = str(self.fontFamilyBox.currentText())
self.settings.setFontFamily(fontFamily)
def accept(self):
ConfigParser.config_instance.saveSettings(self.settings)
self.done(0)
StickyNoteManager.sticky_note_manager_instance.updateSettings()
def reject(self):
self.done(0)
def actionEnableAutoStart(self, res):
self.settings.setStartOnStartup(bool(res))
class SettinInterface(QWidget):
def __init__(self, screen_scale_rate):
super(SettinInterface, self).__init__()
if 1.01 <= screen_scale_rate <= 1.49:
self.rate = 1.25
self.px = 80
self.image_sign = 2
else:
self.rate = 1
self.px = 75
self.image_sign = 1
self.get_settin()
self.setupUi()
def setupUi(self):
# 窗口尺寸及不可拉伸
self.setWindowFlags(Qt.WindowStaysOnTopHint)
self.resize(404 * self.rate, 576 * self.rate)
self.setMinimumSize(QSize(404 * self.rate, 576 * self.rate))
self.setMaximumSize(QSize(404 * self.rate, 576 * self.rate))
self.setWindowFlags(Qt.WindowMinimizeButtonHint)
# 窗口标题
self.setWindowTitle("设置")
# 窗口样式
# self.setStyleSheet("QWidget {""font: 9pt \"华康方圆体W7\";"
# "background-image: url(./config/Background%d.jpg);"
# "background-repeat: no-repeat;"
# "background-size:cover;""}" % self.image_sign)
self.setStyleSheet("QWidget {" "font: 9pt \"微软雅黑\"};") # 华康方圆体W7
# 窗口图标
self.icon = QIcon()
self.icon.addPixmap(QPixmap(folder_path + "/config/logo.ico"),
QIcon.Normal, QIcon.On)
self.setWindowIcon(self.icon)
# 顶部工具栏
self.tabWidget = QTabWidget(self)
self.tabWidget.setGeometry(
QRect(-2, 0, 410 * self.rate, 580 * self.rate))
self.tabWidget.setCurrentIndex(0)
# 工具栏样式
self.tabWidget.setStyleSheet("QTabBar::tab {"
"min-width:%dpx;"
"background: rgba(255, 255, 255, 1);"
"}"
"QTabBar::tab:selected {"
"border-bottom: 2px solid #4796f0;"
"}"
"QLabel{"
"background: transparent;"
"}"
"QCheckBox{"
"background: transparent;"
"}" % (self.px))
# 工具栏2
self.tab_2 = QWidget()
self.tabWidget.addTab(self.tab_2, "")
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_2), "设置")
# 原语言标签
self.translateSource_label_6 = QLabel(self.tab_2)
self.translateSource_label_6.setGeometry(
QRect(30 * self.rate, 20 * self.rate, 151 * self.rate,
16 * self.rate))
self.translateSource_label_6.setText("待识别的语言类型：")
# 原语言comboBox
self.language_comboBox = QComboBox(self.tab_2)
self.language_comboBox.setGeometry(
QRect(190 * self.rate, 20 * self.rate, 150 * self.rate,
22 * self.rate))
for idx, language_name in enumerate(config.language_name):
self.language_comboBox.addItem("")
self.language_comboBox.setItemText(idx, language_name[1])
self.language_comboBox.setStyleSheet(
"background: rgba(255, 255, 255, 0.4);")
self.language_comboBox.setCurrentIndex(self.language)
# 是否显示识别结果checkBox
self.vis_result_checkBox = QCheckBox(self.tab_2)
self.vis_result_checkBox.setGeometry(
QRect(30 * self.rate, 52 * self.rate, 300 * self.rate,
16 * self.rate))
self.vis_result_checkBox.setChecked(self.vis_result)
self.vis_result_checkBox.setText("可视化识别结果(对识别结果进行修改及导出)")
# 自动复制到剪贴板checkBox
self.Clipboard_checkBox = QCheckBox(self.tab_2)
self.Clipboard_checkBox.setGeometry(
QRect(30 * self.rate, 80 * self.rate, 231 * self.rate,
16 * self.rate))
self.Clipboard_checkBox.setChecked(self.showClipboard)
self.Clipboard_checkBox.setText("识别结果自动复制到剪贴板")
# 字体大小设定标签
self.fontSize_label = QLabel(self.tab_2)
self.fontSize_label.setGeometry(
QRect(30 * self.rate, 120 * self.rate, 145 * self.rate,
16 * self.rate))
self.fontSize_label.setText("显示文字大小：")
# 字体大小设定
self.fontSize_spinBox = QSpinBox(self.tab_2)
self.fontSize_spinBox.setGeometry(
QRect(190 * self.rate, 120 * self.rate, 50 * self.rate,
25 * self.rate))
self.fontSize_spinBox.setMinimum(10)
self.fontSize_spinBox.setMaximum(30)
self.fontSize_spinBox.setStyleSheet(
"background: rgba(255, 255, 255, 0)")
self.fontSize_spinBox.setValue(self.fontSize)
# 字体样式设定标签
self.translate_label = QLabel(self.tab_2)
self.translate_label.setGeometry(
QRect(30 * self.rate, 145 * self.rate, 145 * self.rate,
20 * self.rate))
self.translate_label.setText("显示字体类型：")
# 字体样式设定
self.fontComboBox = QFontComboBox(self.tab_2)
self.fontComboBox.setGeometry(
QRect(190 * self.rate, 145 * self.rate, 151 * self.rate,
25 * self.rate))
self.fontComboBox.setStyleSheet("background: rgba(255, 255, 255, 0.4)")
self.fontComboBox.activated[str].connect(self.get_fontType)
self.ComboBoxFont = QFont(self.fontType)
self.fontComboBox.setCurrentFont(self.ComboBoxFont)
# 字体颜色设定标签
self.colour_label = QLabel(self.tab_2)
self.colour_label.setGeometry(
QRect(30 * self.rate, 172 * self.rate, 340 * self.rate,
25 * self.rate))
self.colour_label.setText("显示文字颜色：")
# 字体颜色按钮
self.originalColour_toolButton = QToolButton(self.tab_2)
self.originalColour_toolButton.setGeometry(
QRect(190 * self.rate, 175 * self.rate, 71 * self.rate,
25 * self.rate))
self.originalColour_toolButton.setStyleSheet(
"background: rgba(255, 255, 255, 0.4); color: {};".format(
self.originalColor))
self.originalColour_toolButton.clicked.connect(
lambda: self.get_font_color())
self.originalColour_toolButton.setText("选择颜色")
# 显示颜色样式checkBox
self.showColorType_checkBox = QCheckBox(self.tab_2)
self.showColorType_checkBox.setGeometry(
QRect(30 * self.rate, 200 * self.rate, 340 * self.rate,
20 * self.rate))
self.showColorType_checkBox.setChecked(self.showColorType)
self.showColorType_checkBox.setText("是否使用实心字体样式（不勾选则显示描边字体样式）")
# 截屏键快捷键checkBox
self.shortcutKey2_checkBox = QCheckBox(self.tab_2)
self.shortcutKey2_checkBox.setGeometry(
QRect(30 * self.rate, 250 * self.rate, 160 * self.rate,
16 * self.rate))
self.shortcutKey2_checkBox.setStyleSheet("background: transparent;")
self.shortcutKey2_checkBox.setChecked(self.showHotKey2)
self.shortcutKey2_checkBox.setText("是否使用截屏快捷键：")
# 截屏键的快捷键
self.HotKey2_ComboBox = QComboBox(self.tab_2)
self.HotKey2_ComboBox.setGeometry(
QRect(200 * self.rate, 250 * self.rate, 120 * self.rate,
21 * self.rate))
self.HotKey2_ComboBox.setStyleSheet(
"background: rgba(255, 255, 255, 0.4);")
for index, HotKey in enumerate(self.HotKeys):
self.HotKey2_ComboBox.addItem("")
self.HotKey2_ComboBox.setItemText(index, HotKey)
self.HotKey2_ComboBox.setCurrentIndex(self.showHotKey1Value2)
# 翻译键快捷键checkBox
self.shortcutKey1_checkBox = QCheckBox(self.tab_2)
self.shortcutKey1_checkBox.setGeometry(
QRect(30 * self.rate, 280 * self.rate, 160 * self.rate,
16 * self.rate))
self.shortcutKey1_checkBox.setStyleSheet("background: transparent;")
self.shortcutKey1_checkBox.setChecked(self.showHotKey1)
self.shortcutKey1_checkBox.setText("是否使用识别快捷键：")
# 翻译键的快捷键
self.HotKey1_ComboBox = QComboBox(self.tab_2)
self.HotKey1_ComboBox.setGeometry(
QRect(200 * self.rate, 280 * self.rate, 120 * self.rate,
21 * self.rate))
self.HotKey1_ComboBox.setStyleSheet(
"background: rgba(255, 255, 255, 0.4);")
for index, HotKey in enumerate(self.HotKeys):
self.HotKey1_ComboBox.addItem("")
self.HotKey1_ComboBox.setItemText(index, HotKey)
self.HotKey1_ComboBox.setCurrentIndex(self.showHotKey1Value1)
# 是否翻译
self.translate_checkBox = QCheckBox(self.tab_2)
self.translate_checkBox.setGeometry(
QRect(30 * self.rate, 315 * self.rate, 300 * self.rate,
16 * self.rate))
self.translate_checkBox.setChecked(self.need_translate)
self.translate_checkBox.setText("是否翻译为汉语")
# 是否翻译
self.show_org_checkBox = QCheckBox(self.tab_2)
self.show_org_checkBox.setGeometry(
QRect(30 * self.rate, 340 * self.rate, 300 * self.rate,
16 * self.rate))
self.show_org_checkBox.setChecked(self.showOriginal)
self.show_org_checkBox.setText("翻译后是否显示原文")
# 翻译框透明度设定标签1
self.tab4_label_1 = QLabel(self.tab_2)
self.tab4_label_1.setGeometry(
QRect(30 * self.rate, 380 * self.rate, 211 * self.rate,
16 * self.rate))
self.tab4_label_1.setText("调节显示界面的透明度")
# 翻译框透明度设定
self.horizontalSlider = QSlider(self.tab_2)
self.horizontalSlider.setGeometry(
QRect(30 * self.rate, 400 * self.rate, 347 * self.rate,
22 * self.rate))
self.horizontalSlider.setStyleSheet("background: transparent;")
self.horizontalSlider.setMaximum(100)
self.horizontalSlider.setOrientation(Qt.Horizontal)
self.horizontalSlider.setValue(self.horizontal)
self.horizontalSlider.valueChanged.connect(self.get_horizontal)
# 翻译框透明度设定标签2
self.tab2_label_2 = QLabel(self.tab_2)
self.tab2_label_2.setGeometry(
QRect(30 * self.rate, 420 * self.rate, 61 * self.rate,
20 * self.rate))
self.tab2_label_2.setText("完全透明")
# 翻译框透明度设定标签3
self.tab2_label_3 = QLabel(self.tab_2)
self.tab2_label_3.setGeometry(
QRect(310 * self.rate, 420 * self.rate, 71 * self.rate,
20 * self.rate))
self.tab2_label_3.setText("完全不透明")
# 工具栏3
self.tab_3 = QWidget()
self.tabWidget.addTab(self.tab_3, "")
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_3), "关于")
self.tab3_label = QLabel(self.tab_3)
self.tab3_label.setGeometry(
QRect(30 * self.rate, 75 * self.rate, 100 * self.rate,
40 * self.rate))
self.tab3_label.setText("说明：")
self.tab3_label2 = QLabel(self.tab_3)
self.tab3_label2.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.tab3_label2.setWordWrap(True)
self.tab3_label2.setGeometry(
QRect(50 * self.rate, 100 * self.rate, 400 * self.rate,
80 * self.rate))
self.tab3_label2.setText(
"Dango-OCR是一款开源的OCR文字识别软件。\n如果在使用过程中有什么问题或者建议，欢迎微信交流(itlane)\n"
"或者在github(https://github.com/zhangming8/Dango-ocr)\n上留言")
self.tab3_label3 = QLabel(self.tab_3)
self.tab3_label3.setWordWrap(True)
self.tab3_label3.setGeometry(
QRect(30 * self.rate, 350 * self.rate, 400 * self.rate,
80 * self.rate))
self.tab3_label3.setText(
"参考:\n https://github.com/zhangming8/ocr_algo_server\n "
"https://github.com/PaddlePaddle/PaddleOCR\n "
"https://github.com/PantsuDango/Dango-Translator")
# 设置保存按钮
self.SaveButton = QPushButton(self)
self.SaveButton.setGeometry(
QRect(85 * self.rate, 515 * self.rate, 90 * self.rate,
30 * self.rate))
self.SaveButton.setStyleSheet(
"background: rgba(255, 255, 255, 0.4);font: 12pt;")
self.SaveButton.setText("保存设置")
# 设置返回按钮
self.CancelButton = QPushButton(self)
self.CancelButton.setGeometry(
QRect(232 * self.rate, 515 * self.rate, 90 * self.rate,
30 * self.rate))
self.CancelButton.setStyleSheet(
"background: rgba(255, 255, 255, 0.4);font: 12pt")
self.CancelButton.setText("退 出")
def get_settin(self): # 获取所有预设值
with open(folder_path + '/config/settin.json') as file:
self.data = load(file)
# 获取各翻译源颜色预设值
self.originalColor = self.data["fontColor"]["original"]
# 获取翻译字体大小预设值
self.fontSize = self.data["fontSize"]
# 获取翻译字体样式预设值
self.fontType = self.data["fontType"]
# 获取颜色样式预设值
self.showColorType = self.data["showColorType"]
if self.showColorType == "True":
self.showColorType = True
else:
self.showColorType = False
# 获取是否显示原文预设值
self.showOriginal = self.data["showOriginal"]
if self.showOriginal == "True":
self.showOriginal = True
else:
self.showOriginal = False
# 获取是否将原文复制到剪贴板预设值
self.showClipboard = self.data["showClipboard"]
if self.showClipboard == "True":
self.showClipboard = True
else:
self.showClipboard = False
self.vis_result = self.data.get("vis_result", False)
if self.vis_result == "True":
self.vis_result = True
else:
self.vis_result = False
self.need_translate = self.data.get("need_translate", False)
if self.need_translate == "True":
self.need_translate = True
else:
self.need_translate = False
# 所有可设置的快捷键
self.HotKeys = [
'F1', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8', 'F9', 'F10', 'F11',
'F12', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'Back',
'Tab', 'Space', 'Left', 'Up', 'Right', 'Down', 'Delete', 'Numpad0',
'Numpad1', 'Numpad2', 'Numpad3', 'Numpad4', 'Numpad5', 'Numpad6',
'Numpad7', 'Numpad8', 'Numpad9'
]
self.QtHotKeys = [
Qt.Key_F1, Qt.Key_F2, Qt.Key_F3, Qt.Key_F4, Qt.Key_F5, Qt.Key_F6,
Qt.Key_F7, Qt.Key_F8, Qt.Key_F9, Qt.Key_F10, Qt.Key_F11,
Qt.Key_F12, Qt.Key_A, Qt.Key_B, Qt.Key_C, Qt.Key_D, Qt.Key_E,
Qt.Key_F, Qt.Key_G, Qt.Key_H, Qt.Key_I, Qt.Key_J, Qt.Key_K,
Qt.Key_L, Qt.Key_M, Qt.Key_N, Qt.Key_O, Qt.Key_P, Qt.Key_Q,
Qt.Key_R, Qt.Key_S, Qt.Key_T, Qt.Key_U, Qt.Key_V, Qt.Key_W,
Qt.Key_X, Qt.Key_Y, Qt.Key_Z, Qt.Key_0, Qt.Key_1, Qt.Key_2,
Qt.Key_3, Qt.Key_4, Qt.Key_5, Qt.Key_6, Qt.Key_7, Qt.Key_8,
Qt.Key_9, Qt.Key_Back, Qt.Key_Tab, Qt.Key_Space, Qt.Key_Left,
Qt.Key_Up, Qt.Key_Right, Qt.Key_Down, Qt.Key_Delete, Qt.Key_0,
Qt.Key_1, Qt.Key_2, Qt.Key_3, Qt.Key_4, Qt.Key_5, Qt.Key_6,
Qt.Key_7, Qt.Key_8, Qt.Key_9
]
self.QtHotKeysMaps = {}
for idx in range(len(self.HotKeys)):
self.QtHotKeysMaps[self.HotKeys[idx]] = self.QtHotKeys[idx]
# 获取翻译键快捷键的热键预设值
self.showHotKey1Value1 = self.data["showHotKeyValue1"]
self.showHotKey1Value1 = self.HotKeys.index(self.showHotKey1Value1)
# 获取范围键快捷键的热键预设值
self.showHotKey1Value2 = self.data["showHotKeyValue2"]
self.showHotKey1Value2 = self.HotKeys.index(self.showHotKey1Value2)
# 获取是否启用翻译键快捷键预设值
self.showHotKey1 = self.data["showHotKey1"]
if self.showHotKey1 == "True":
self.showHotKey1 = True
else:
self.showHotKey1 = False
# 获取是否启用范围键快捷键预设值
self.showHotKey2 = self.data["showHotKey2"]
if self.showHotKey2 == "True":
self.showHotKey2 = True
else:
self.showHotKey2 = False
# 获取文本框透明度预设值
self.horizontal = self.data["horizontal"]
# 获取翻译语言预设值
self.language = config.language_map_reverse[self.data["language"]]
def get_font_color(self): # 各翻译源字体颜色
color = QColorDialog.getColor()
self.originalColor = color.name()
self.originalColour_toolButton.setStyleSheet(
"background: rgba(255, 255, 255, 0.4);color: {};".format(
color.name()))
self.data["fontColor"]["original"] = self.originalColor
def get_fontType(self, text): # 字体样式
self.fontType = text
self.data["fontType"] = self.fontType
def showColorType_state(self): # 颜色样式
if self.showColorType_checkBox.isChecked():
self.showColorType = "True"
else:
self.showColorType = "False"
self.data["showColorType"] = self.showColorType
def showClipboard_state(self): # 是否将原文自动复制到剪贴板
if self.Clipboard_checkBox.isChecked():
self.showClipboard = "True"
else:
self.showClipboard = "False"
self.data["showClipboard"] = self.showClipboard
def VisResult_state(self):
if self.vis_result_checkBox.isChecked():
self.vis_result = "True"
else:
self.vis_result = "False"
self.data["vis_result"] = self.vis_result
def NeedTranslate_state(self):
if self.translate_checkBox.isChecked():
self.need_translate = "True"
else:
self.need_translate = "False"
self.data["need_translate"] = self.need_translate
def ShowOrigion_state(self):
if self.show_org_checkBox.isChecked():
self.showOriginal = "True"
else:
self.showOriginal = "False"
self.data["showOriginal"] = self.showOriginal
def showHotKey1_state(self): # 是否启用翻译键快捷键
if self.shortcutKey1_checkBox.isChecked():
self.showHotKey1 = "True"
else:
self.showHotKey1 = "False"
self.data["showHotKey1"] = self.showHotKey1
def showHotKey2_state(self): # 是否启用范围键快捷键
if self.shortcutKey2_checkBox.isChecked():
self.showHotKey2 = "True"
else:
self.showHotKey2 = "False"
self.data["showHotKey2"] = self.showHotKey2
def get_horizontal(self): # 文本框透明度
self.horizontal = self.horizontalSlider.value()
self.data["horizontal"] = self.horizontal
def save_fontSize(self): # 翻译源字体大小
self.data["fontSize"] = self.fontSize_spinBox.value()
def range(self):
with open(folder_path + '/config/settin.json') as file:
data1 = load(file)
self.data["range"]["X1"] = data1["range"]["X1"]
self.data["range"]["Y1"] = data1["range"]["Y1"]
self.data["range"]["X2"] = data1["range"]["X2"]
self.data["range"]["Y2"] = data1["range"]["Y2"]
def save_language(self): # 保存翻译语种
self.data["language"] = config.language_map[
self.language_comboBox.currentIndex()][0]
def save_showHotKeyValue1(self): # 保存翻译键快捷键
HotKey_index = self.HotKey1_ComboBox.currentIndex()
self.data["showHotKeyValue1"] = self.HotKeys[HotKey_index]
def save_showHotKeyValue2(self): # 保存范围键快捷键
HotKey_index = self.HotKey2_ComboBox.currentIndex()
self.data["showHotKeyValue2"] = self.HotKeys[HotKey_index]
def save_settin(self):
self.range()
self.get_horizontal()
self.save_fontSize()
self.showColorType_state()
self.showClipboard_state()
self.VisResult_state()
self.NeedTranslate_state()
self.ShowOrigion_state()
self.save_language()
self.showHotKey1_state()
self.showHotKey2_state()
self.save_showHotKeyValue1()
self.save_showHotKeyValue2()
with open(folder_path + '/config/settin.json', 'w') as file:
dump(self.data, file, indent=2)
MessageBox('保存设置', '保存成功啦 ヾ(๑╹◡╹)ﾉ"')
def __init__(self, data: TextData, parent, printable):
super().__init__(data, parent, printable)
font = data.getQFont()
self.setMinimumWidth(256)
self.edit_text = QLineEdit(self.data.text, self)
self.edit_text.textChanged.connect(self.text_changed)
self.layout.addWidget(QLabel('Text:'))
self.layout.addWidget(self.edit_text)
self.button_font = QPushButton(self.get_font_name())
self.button_font.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
self.button_font.clicked.connect(self.button_font_clicked)
button_default = QPushButton('Set as default', self)
button_default.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
button_default.clicked.connect(self.default_clicked)
font_layout = QVBoxLayout()
font_family = QFontComboBox(self)
font_family.setCurrentFont(font)
font_family.currentFontChanged.connect(self.font_changed)
self.font_family = font_family
font_layout.addWidget(font_family)
font_group = QGroupBox('Font:', self)
font_group.setLayout(font_layout)
self.layout.addWidget(font_group)
buttons = QHBoxLayout()
buttons.setSpacing(0)
font_size = QSpinBox(self)
font_size.setValue(font.pixelSize())
font_size.valueChanged.connect(self.size_changed)
self.font_size = font_size
buttons.addWidget(QLabel('Size:'))
buttons.addWidget(font_size)
buttons.addWidget(QLabel('px'))
buttons.addStretch()
# buttons.addWidget(self.button_font)
adjusted_size = QLabel(self)
self.adjusted_size_label = adjusted_size
self.auto_size = QCheckBox('Automatically scale font', self)
self.auto_size.stateChanged.connect(self.auto_size_changed)
buttons.addWidget(self.auto_size)
buttons2 = QHBoxLayout()
buttons2.addWidget(adjusted_size)
buttons2.addWidget(button_default)
font_layout.addLayout(buttons)
font_layout.addLayout(buttons2)
# font_preview = QLabel(self.data.text)
# font_preview.setFont(font)
# self.layout.addWidget(font_preview)
self.layout.addStretch()
class NoteView(QWidget):
def __init__(self, parent: QWidget, noteViewManager: NoteViewManager, note: Note):
super(QWidget, self).__init__(parent)
self.noteViewManager = noteViewManager
self.note = note
self.notebook = self.noteViewManager.notebook
self.setLayout(QVBoxLayout(self))
self.lay = self.layout()
self.noteContentEdit = NoteContentEdit(self, self.notebook, note)
self.noteContentEdit.anchorClicked.connect(self.onAnchorClicked)
self.attachmentsView = NoteAttachmentsView(self, self.notebook, note)
self.attachmentsBox = CollapsibleBox(title="Attachments")
tmpLay = QVBoxLayout()
tmpLay.addWidget(self.attachmentsView)
self.attachmentsBox.setContentLayout(tmpLay)
self.attachmentsBox.setContentsMargins(0, 0, 0, 0)
self.initFormatbar()
self.fontBox.setCurrentFont(self.notebook.settings.font())
self.fontSize.setValue(self.notebook.settings.font().pointSize())
self.noteContentEdit.currentCharFormatChanged.connect(self.onCurrentCharFormatChanged)
self.lay.addWidget(self.noteContentEdit)
self.lay.addWidget(self.attachmentsBox)
def initFormatbar(self):
self.fontBox = QFontComboBox()
self.fontBox.setCurrentFont(self.noteContentEdit.font())
self.fontBox.currentFontChanged.connect(lambda font: self.noteContentEdit.setCurrentFont(font))
# self.families = list(self.fontBox.itemText(i) for i in range(self.fontBox.count()))
#
# with open("fonts.txt", "w") as f:
# for name in self.families:
# f.write(name + "\r\n")
self.fontSize = QSpinBox()
self.fontSize.setValue(self.noteContentEdit.fontPointSize())
self.fontSize.adjustSize()
self.fontSize.setSuffix(" pt")
self.fontSize.valueChanged.connect(lambda size: self.noteContentEdit.setFontPointSize(size))
fontColor = QAction(QIcon("icons/font-color.png"), "Change font color", self)
fontColor.triggered.connect(self.fontColorChanged)
boldAction = QAction(QIcon("icons/bold.png"), "Bold", self)
boldAction.triggered.connect(self.bold)
italicAction = QAction(QIcon("icons/italic.png"), "Italic", self)
italicAction.triggered.connect(self.italic)
underlAction = QAction(QIcon("icons/underline.png"), "Underline", self)
underlAction.triggered.connect(self.underline)
strikeAction = QAction(QIcon("icons/strike.png"), "Strike-out", self)
strikeAction.triggered.connect(self.strike)
superAction = QAction(QIcon("icons/superscript.png"), "Superscript", self)
superAction.triggered.connect(self.superScript)
subAction = QAction(QIcon("icons/subscript.png"), "Subscript", self)
subAction.triggered.connect(self.subScript)
alignLeft = QAction(QIcon("icons/align-left.png"), "Align left", self)
alignLeft.triggered.connect(self.alignLeft)
alignCenter = QAction(QIcon("icons/align-center.png"), "Align center", self)
alignCenter.triggered.connect(self.alignCenter)
alignRight = QAction(QIcon("icons/align-right.png"), "Align right", self)
alignRight.triggered.connect(self.alignRight)
alignJustify = QAction(QIcon("icons/align-justify.png"), "Align justify", self)
alignJustify.triggered.connect(self.alignJustify)
indentAction = QAction(QIcon("icons/indent.png"), "Indent Area", self)
indentAction.setShortcut("Ctrl+Tab")
indentAction.triggered.connect(self.indent)
dedentAction = QAction(QIcon("icons/dedent.png"), "Dedent Area", self)
dedentAction.setShortcut("Shift+Tab")
dedentAction.triggered.connect(self.dedent)
backColor = QAction(QIcon("icons/highlight.png"), "Change background color", self)
backColor.triggered.connect(self.highlight)
bulletAction = QAction(QIcon("icons/bullet.png"), "Insert bullet List", self)
bulletAction.setStatusTip("Insert bullet list")
bulletAction.setShortcut("Ctrl+Shift+B")
bulletAction.triggered.connect(self.bulletList)
numberedAction = QAction(QIcon("icons/number.png"), "Insert numbered List", self)
numberedAction.setStatusTip("Insert numbered list")
numberedAction.setShortcut("Ctrl+Shift+L")
numberedAction.triggered.connect(self.numberList)
dateTimeAction = QAction(QIcon("icons/calender.png"), "Insert current date/time", self)
dateTimeAction.setStatusTip("Insert current date/time")
dateTimeAction.setShortcut("Ctrl+D")
dateTimeAction.triggered.connect(self.insertDateTime)
wordCountAction = QAction(QIcon("icons/count.png"), "See word/symbol count", self)
wordCountAction.setStatusTip("See word/symbol count")
wordCountAction.setShortcut("Ctrl+W")
wordCountAction.triggered.connect(self.wordCount)
tableAction = QAction(QIcon("icons/table.png"), "Insert table", self)
tableAction.setStatusTip("Insert table")
tableAction.setShortcut("Ctrl+T")
tableAction.triggered.connect(self.insertTable)
imageAction = QAction(QIcon("icons/image.png"), "Insert image", self)
imageAction.setStatusTip("Insert image")
imageAction.setShortcut("Ctrl+Shift+I")
imageAction.triggered.connect(self.insertImage)
linkAction = QAction(QIcon("icons/insert_link.png"), "Insert link", self)
linkAction.setStatusTip("Insert link")
# linkAction.setShortcut("Ctrl+Shift+L")
linkAction.triggered.connect(self.insertLink)
linkNoteAction = QAction(QIcon("icons/insert_note_link.png"), "Insert note link", self)
linkNoteAction.setStatusTip("Insert note link")
# linkAction.setShortcut("Ctrl+Shift+L")
linkNoteAction.triggered.connect(self.insertNoteLink)
attachAction = QAction(QIcon("icons/attach.png"), "Insert attachment", self)
attachAction.setStatusTip("Insert attachment")
attachAction.triggered.connect(self.insertAttachment)
printAction = QAction(QIcon("icons/print.png"), "Print document", self)
printAction.setStatusTip("Print document")
printAction.setShortcut("Ctrl+P")
printAction.triggered.connect(self.printHandler)
previewAction = QAction(QIcon("icons/preview.png"), "Page view", self)
previewAction.setStatusTip("Preview page before printing")
previewAction.setShortcut("Ctrl+Shift+P")
previewAction.triggered.connect(self.preview)
viewHistoryAction = QAction(QIcon("icons/history.png"), "Show history", self)
viewHistoryAction.setStatusTip("View note content history")
viewHistoryAction.setShortcut("Ctrl+H")
viewHistoryAction.triggered.connect(self.showHistory)
self.formatbar = QToolBar("Format")
self.formatbar.setIconSize(QSize(16, 16))
self.lay.addWidget(self.formatbar)
self.formatbar.addWidget(self.fontBox)
self.formatbar.addWidget(self.fontSize)
self.formatbar.addSeparator()
self.formatbar.addAction(fontColor)
self.formatbar.addAction(backColor)
self.formatbar.addSeparator()
self.formatbar.addAction(boldAction)
self.formatbar.addAction(italicAction)
self.formatbar.addAction(underlAction)
self.formatbar.addAction(strikeAction)
self.formatbar.addAction(superAction)
self.formatbar.addAction(subAction)
self.formatbar.addSeparator()
self.formatbar.addAction(alignLeft)
self.formatbar.addAction(alignCenter)
self.formatbar.addAction(alignRight)
self.formatbar.addAction(alignJustify)
self.formatbar.addSeparator()
self.formatbar.addAction(indentAction)
self.formatbar.addAction(dedentAction)
self.formatbar.addSeparator()
self.formatbar.addAction(bulletAction)
self.formatbar.addAction(numberedAction)
self.formatbar.addSeparator()
self.formatbar.addAction(wordCountAction)
self.formatbar.addAction(tableAction)
self.formatbar.addAction(dateTimeAction)
self.formatbar.addAction(imageAction)
self.formatbar.addSeparator()
self.formatbar.addAction(linkAction)
self.formatbar.addAction(linkNoteAction)
self.formatbar.addAction(attachAction)
self.formatbar.addSeparator()
self.formatbar.addAction(viewHistoryAction)
self.formatbar.addAction(previewAction)
self.formatbar.addAction(printAction)
def saveChanges(self):
self.noteContentEdit.saveChanges()
def fontColorChanged(self):
# Get a color from the text dialog
color = QColorDialog.getColor()
# Set it as the new text color
self.noteContentEdit.setTextColor(color)
def highlight(self):
color = QColorDialog.getColor()
self.noteContentEdit.setTextBackgroundColor(color)
def bold(self):
if self.noteContentEdit.fontWeight() == QFont.Bold:
self.noteContentEdit.setFontWeight(QFont.Normal)
else:
self.noteContentEdit.setFontWeight(QFont.Bold)
def italic(self):
state = self.noteContentEdit.fontItalic()
self.noteContentEdit.setFontItalic(not state)
def underline(self):
state = self.noteContentEdit.fontUnderline()
self.noteContentEdit.setFontUnderline(not state)
def strike(self):
# Grab the text's format
fmt = self.noteContentEdit.currentCharFormat()
# Set the fontStrikeOut property to its opposite
fmt.setFontStrikeOut(not fmt.fontStrikeOut())
# And set the next char format
self.noteContentEdit.setCurrentCharFormat(fmt)
def superScript(self):
# Grab the current format
fmt = self.noteContentEdit.currentCharFormat()
# And get the vertical alignment property
align = fmt.verticalAlignment()
# Toggle the state
if align == QTextCharFormat.AlignNormal:
fmt.setVerticalAlignment(QTextCharFormat.AlignSuperScript)
else:
fmt.setVerticalAlignment(QTextCharFormat.AlignNormal)
# Set the new format
self.noteContentEdit.setCurrentCharFormat(fmt)
def subScript(self):
# Grab the current format
fmt = self.noteContentEdit.currentCharFormat()
# And get the vertical alignment property
align = fmt.verticalAlignment()
# Toggle the state
if align == QTextCharFormat.AlignNormal:
fmt.setVerticalAlignment(QTextCharFormat.AlignSubScript)
else:
fmt.setVerticalAlignment(QTextCharFormat.AlignNormal)
# Set the new format
self.noteContentEdit.setCurrentCharFormat(fmt)
def alignLeft(self):
self.noteContentEdit.setAlignment(Qt.AlignLeft)
def alignRight(self):
self.noteContentEdit.setAlignment(Qt.AlignRight)
def alignCenter(self):
self.noteContentEdit.setAlignment(Qt.AlignCenter)
def alignJustify(self):
self.noteContentEdit.setAlignment(Qt.AlignJustify)
def indent(self):
# Grab the cursor
cursor = self.noteContentEdit.textCursor()
if cursor.hasSelection():
# Store the current line/block number
temp = cursor.blockNumber()
# Move to the selection's end
cursor.setPosition(cursor.anchor())
# Calculate range of selection
diff = cursor.blockNumber() - temp
direction = QTextCursor.Up if diff > 0 else QTextCursor.Down
# Iterate over lines (diff absolute value)
for n in range(abs(diff) + 1):
# Move to start of each line
cursor.movePosition(QTextCursor.StartOfLine)
# Insert tabbing
cursor.insertText("\t")
# And move back up
cursor.movePosition(direction)
# If there is no selection, just insert a tab
else:
cursor.insertText("\t")
def handleDedent(self, cursor):
cursor.movePosition(QTextCursor.StartOfLine)
# Grab the current line
line = cursor.block().text()
# If the line starts with a tab character, delete it
if line.startswith("\t"):
# Delete next character
cursor.deleteChar()
# Otherwise, delete all spaces until a non-space character is met
else:
for char in line[:8]:
if char != " ":
break
cursor.deleteChar()
def dedent(self):
cursor = self.noteContentEdit.textCursor()
if cursor.hasSelection():
# Store the current line/block number
temp = cursor.blockNumber()
# Move to the selection's last line
cursor.setPosition(cursor.anchor())
# Calculate range of selection
diff = cursor.blockNumber() - temp
direction = QTextCursor.Up if diff > 0 else QTextCursor.Down
# Iterate over lines
for n in range(abs(diff) + 1):
self.handleDedent(cursor)
# Move up
cursor.movePosition(direction)
else:
self.handleDedent(cursor)
def bulletList(self):
cursor = self.noteContentEdit.textCursor()
# Insert bulleted list
cursor.insertList(QTextListFormat.ListDisc)
def numberList(self):
cursor = self.noteContentEdit.textCursor()
# Insert list with numbers
cursor.insertList(QTextListFormat.ListDecimal)
def insertTable(self):
Table(parent=self, text=self.noteContentEdit).show()
def insertDateTime(self):
# Grab cursor
cursor = self.noteContentEdit.textCursor()
datetime = strftime(self.noteViewManager.notebook.settings.date_time_insert_format())
# Insert the comboBox's current text
cursor.insertText(datetime)
def wordCount(self):
wc = WordCount(self, self.noteContentEdit)
wc.text = self.noteContentEdit
wc.getText()
wc.show()
def insertHyperLynk(self, url: str):
cursor = QTextCursor(self.noteContentEdit.document())
format = QTextCharFormat()
format.setAnchor(True)
format.setAnchorHref(url)
cursor.mergeBlockCharFormat(format)
def insertLink(self):
dialog = LinkAddDialog(self.noteContentEdit)
result = dialog.exec_()
if result == QDialog.Accepted:
cursor = self.noteContentEdit.textCursor()
linkAdress = dialog.linkAdress
linkCaption = dialog.linkCaption
url = QUrl.fromUserInput(linkAdress)
linkAdress = url.toString()
cursor.insertHtml(f"<a href=\"{linkAdress}\" >{linkCaption}</a>")
def insertNoteLink(self):
cursor = self.noteContentEdit.textCursor()
filename = QFileDialog.getOpenFileName(self.noteContentEdit, 'Open File', ".", "(*.nbf)")[0]
if filename:
notebook = Notebook.from_file(filename)
dialog = NoteSelectDialog(parent=self, notebook=notebook)
result = dialog.exec_()
if result == QDialog.Accepted:
url: QUrl = QUrl.fromLocalFile(filename)
url.setScheme("notesmanager")
query = QUrlQuery()
query.addQueryItem("uuid", str(dialog.selectedNote.uuid))
url.setQuery(query)
cursor.insertHtml(f"<a href=\"{url.toString()}\" >{dialog.caption}</a>")
# self.text.setReadOnly(True)
# self.insertHyperLynk("www.google.com")
def preview(self):
# Open preview dialog
preview = QPrintPreviewDialog()
# If a print is requested, open print dialog
preview.paintRequested.connect(lambda p: self.noteContentEdit.print_(p))
preview.exec_()
def printHandler(self):
# Open printing dialog
dialog = QPrintDialog()
if dialog.exec_() == QDialog.Accepted:
self.noteContentEdit.document().print_(dialog.printer())
def showHistory(self):
self.noteViewManager.saveChanges()
dialog = NoteHistoryView(self, self.note)
if dialog.exec_() == QDialog.Accepted:
self.note.restore(dialog.restoreIndex)
self.noteContentEdit.setHtml(self.note.content)
def insertImage(self):
# Get image file name
# PYQT5 Returns a tuple in PyQt5
filename = \
QFileDialog.getOpenFileName(self.noteContentEdit, 'Insert image', ".",
"Images (*.png *.xpm *.jpg *.bmp *.gif)")[
0]
if filename:
# Create image object
image = QImage(filename)
# Error if unloadable
if image.isNull():
popup = QMessageBox(QMessageBox.Critical,
"Image load error",
"Could not load image file!",
QMessageBox.Ok,
self.noteContentEdit)
popup.show()
else:
# from PIL import Image, ImageDraw
import base64
import os
content_type = "image/" + os.path.splitext(filename)[1][1:]
raw_data = base64.b64encode(open(filename, "rb").read())
uri = ("data:" +
content_type + ";" +
"base64," + raw_data.decode())
html_code = '<img src="' + uri + '"/>'
print(html_code)
cursor = self.noteContentEdit.textCursor()
cursor.insertHtml(html_code)
# random_filename = self.get_random_file_name(os.path.splitext(filename)[1][1:])
# from shutil import copy
# copy(filename, dst=random_filename)
# cursor.insertImage(image, random_filename)
# cursor.insertHtml(html)
def onCurrentCharFormatChanged(self, format: QTextCharFormat) -> None:
if format.isAnchor():
new_format = QTextCharFormat()
new_format.setFont(self.fontBox.currentFont())
new_format.setFontPointSize(self.fontSize.value())
self.noteContentEdit.setCurrentCharFormat(new_format)
def onAnchorClicked(self, url: QUrl):
from notes.ui.MainWindow import MainWindow
import webbrowser
host = url.host()
print(url.scheme())
scheme = url.scheme()
if scheme == "http" or scheme == "https":
webbrowser.open(url.toString())
elif scheme == "notesmanager":
url.setScheme("file")
local_path = url.toLocalFile()
query = QUrlQuery(url)
uuid = query.queryItemValue("uuid")
if local_path == self.notebook.attachment_base.filename:
self.noteViewManager.openNote(self.noteViewManager.notebook.get_note_by_uuid(uuid))
else:
spawn = MainWindow(None, local_path, uuid)
spawn.show()
def insertAttachment(self):
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.ExistingFiles)
filenames = dialog.getOpenFileNames(self, 'Insert attachments', ".")[0]
self.attachmentsView.addAttachments(filenames)
class FontsColors(preferences.Page):
def __init__(self, dialog):
super(FontsColors, self).__init__(dialog)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.scheme = SchemeSelector(self)
layout.addWidget(self.scheme)
self.printScheme = QCheckBox()
layout.addWidget(self.printScheme)
hbox = QHBoxLayout()
self.tree = QTreeWidget(self)
self.tree.setHeaderHidden(True)
self.tree.setAnimated(True)
self.stack = QStackedWidget(self)
hbox.addWidget(self.tree)
hbox.addWidget(self.stack)
layout.addLayout(hbox)
hbox = QHBoxLayout()
self.fontLabel = QLabel()
self.fontChooser = QFontComboBox()
self.fontSize = QDoubleSpinBox()
self.fontSize.setRange(6.0, 32.0)
self.fontSize.setSingleStep(0.5)
self.fontSize.setDecimals(1)
hbox.addWidget(self.fontLabel)
hbox.addWidget(self.fontChooser, 1)
hbox.addWidget(self.fontSize)
layout.addLayout(hbox)
# add the items to our list
self.baseColorsItem = i = QTreeWidgetItem()
self.tree.addTopLevelItem(i)
self.defaultStylesItem = i = QTreeWidgetItem()
self.tree.addTopLevelItem(i)
self.defaultStyles = {}
for name in textformats.defaultStyles:
self.defaultStyles[name] = i = QTreeWidgetItem()
self.defaultStylesItem.addChild(i)
i.name = name
self.defaultStylesItem.setExpanded(True)
self.allStyles = {}
for group, styles in ly.colorize.default_mapping():
i = QTreeWidgetItem()
children = {}
self.allStyles[group] = (i, children)
self.tree.addTopLevelItem(i)
i.group = group
for name, base, clss in styles:
j = QTreeWidgetItem()
j.name = name
j.base = base
i.addChild(j)
children[name] = j
self.baseColorsWidget = BaseColors(self)
self.customAttributesWidget = CustomAttributes(self)
self.emptyWidget = QWidget(self)
self.stack.addWidget(self.baseColorsWidget)
self.stack.addWidget(self.customAttributesWidget)
self.stack.addWidget(self.emptyWidget)
self.tree.currentItemChanged.connect(self.currentItemChanged)
self.tree.setCurrentItem(self.baseColorsItem)
self.scheme.currentChanged.connect(self.currentSchemeChanged)
self.scheme.changed.connect(self.changed)
self.baseColorsWidget.changed.connect(self.baseColorsChanged)
self.customAttributesWidget.changed.connect(
self.customAttributesChanged)
self.fontChooser.currentFontChanged.connect(self.fontChanged)
self.fontSize.valueChanged.connect(self.fontChanged)
self.printScheme.clicked.connect(self.printSchemeChanged)
app.translateUI(self)
def translateUI(self):
self.printScheme.setText(_("Use this scheme for printing"))
self.fontLabel.setText(_("Font:"))
self.baseColorsItem.setText(0, _("Base Colors"))
self.defaultStylesItem.setText(0, _("Default Styles"))
self.defaultStyleNames = defaultStyleNames()
self.allStyleNames = allStyleNames()
for name in textformats.defaultStyles:
self.defaultStyles[name].setText(0, self.defaultStyleNames[name])
for group, styles in ly.colorize.default_mapping():
self.allStyles[group][0].setText(0, self.allStyleNames[group][0])
for name, base, clss in styles:
self.allStyles[group][1][name].setText(
0, self.allStyleNames[group][1][name])
def currentItemChanged(self, item, previous):
if item is self.baseColorsItem:
self.stack.setCurrentWidget(self.baseColorsWidget)
elif not item.parent():
self.stack.setCurrentWidget(self.emptyWidget)
else:
data = self.data[self.scheme.currentScheme()]
w = self.customAttributesWidget
self.stack.setCurrentWidget(w)
toptext = None
if item.parent() is self.defaultStylesItem:
# default style
w.setTitle(item.text(0))
w.setTristate(False)
w.setTextFormat(data.defaultStyles[item.name])
else:
# specific style of specific group
group, name = item.parent().group, item.name
w.setTitle("{0}: {1}".format(item.parent().text(0),
item.text(0)))
inherit = item.base
if inherit:
toptext = _("(Inherits: {name})").format(
name=self.defaultStyleNames[inherit])
w.setTristate(bool(inherit))
w.setTextFormat(data.allStyles[group][name])
w.setTopText(toptext)
def currentSchemeChanged(self):
scheme = self.scheme.currentScheme()
if scheme not in self.data:
self.data[scheme] = textformats.TextFormatData(scheme)
self.updateDisplay()
if self.tree.currentItem():
self.currentItemChanged(self.tree.currentItem(), None)
with qutil.signalsBlocked(self.printScheme):
self.printScheme.setChecked(scheme == self._printScheme)
def fontChanged(self):
data = self.data[self.scheme.currentScheme()]
data.font = self.fontChooser.currentFont()
data.font.setPointSizeF(self.fontSize.value())
self.updateDisplay()
self.changed.emit()
def printSchemeChanged(self):
if self.printScheme.isChecked():
self._printScheme = self.scheme.currentScheme()
else:
self._printScheme = None
self.changed.emit()
def addSchemeData(self, scheme, tfd):
self.data[scheme] = tfd
def currentSchemeData(self):
return self.data[self.scheme.currentScheme()]
def updateDisplay(self):
data = self.data[self.scheme.currentScheme()]
with qutil.signalsBlocked(self.fontChooser, self.fontSize):
self.fontChooser.setCurrentFont(data.font)
self.fontSize.setValue(data.font.pointSizeF())
with qutil.signalsBlocked(self):
# update base colors
for name in textformats.baseColors:
self.baseColorsWidget.color[name].setColor(
data.baseColors[name])
# update base colors for whole treewidget
p = QApplication.palette()
p.setColor(QPalette.Base, data.baseColors['background'])
p.setColor(QPalette.Text, data.baseColors['text'])
p.setColor(QPalette.Highlight, data.baseColors['selectionbackground'])
p.setColor(QPalette.HighlightedText, data.baseColors['selectiontext'])
self.tree.setPalette(p)
def setItemTextFormat(item, f):
font = QFont(data.font)
if f.hasProperty(QTextFormat.ForegroundBrush):
item.setForeground(0, f.foreground().color())
else:
item.setForeground(0, data.baseColors['text'])
if f.hasProperty(QTextFormat.BackgroundBrush):
item.setBackground(0, f.background().color())
else:
item.setBackground(0, QBrush())
font.setWeight(f.fontWeight())
font.setItalic(f.fontItalic())
font.setUnderline(f.fontUnderline())
item.setFont(0, font)
# update looks of default styles
for name in textformats.defaultStyles:
setItemTextFormat(self.defaultStyles[name],
data.defaultStyles[name])
# update looks of all the specific styles
for group, styles in ly.colorize.default_mapping():
children = self.allStyles[group][1]
for name, inherit, clss in styles:
f = QTextCharFormat(data.defaultStyles[inherit]
) if inherit else QTextCharFormat()
f.merge(data.allStyles[group][name])
setItemTextFormat(children[name], f)
def baseColorsChanged(self, name):
# keep data up to date with base colors
data = self.data[self.scheme.currentScheme()]
data.baseColors[name] = self.baseColorsWidget.color[name].color()
self.updateDisplay()
self.changed.emit()
def customAttributesChanged(self):
item = self.tree.currentItem()
if not item or not item.parent():
return
data = self.data[self.scheme.currentScheme()]
if item.parent() is self.defaultStylesItem:
# a default style has been changed
data.defaultStyles[
item.name] = self.customAttributesWidget.textFormat()
else:
# a specific style has been changed
group, name = item.parent().group, item.name
data.allStyles[group][
name] = self.customAttributesWidget.textFormat()
self.updateDisplay()
self.changed.emit()
def import_(self, filename):
from . import import_export
import_export.importTheme(filename, self, self.scheme)
def export(self, name, filename):
from . import import_export
try:
import_export.exportTheme(self, name, filename)
except (IOError, OSError) as e:
QMessageBox.critical(
self, _("Error"),
_("Can't write to destination:\n\n{url}\n\n{error}").format(
url=filename, error=e.strerror))
def loadSettings(self):
self.data = {} # holds all data with scheme as key
self._printScheme = QSettings().value("printer_scheme", "default", str)
self.scheme.loadSettings("editor_scheme", "editor_schemes")
def saveSettings(self):
self.scheme.saveSettings("editor_scheme", "editor_schemes",
"fontscolors")
for scheme in self.scheme.schemes():
if scheme in self.data:
self.data[scheme].save(scheme)
if self._printScheme:
QSettings().setValue("printer_scheme", self._printScheme)
else:
QSettings().remove("printer_scheme")
class AugerToolbar(QWidget):
sig_font_changed = pyqtSignal(str)
sig_size_changed = pyqtSignal(int)
sig_ao_toggle = pyqtSignal(bool)
def __init__(self, parent, flags=Qt.WindowFlags(Qt.Widget)):
super().__init__(parent, flags)
font_size_tooltip = 'Font Size (in pt.)'
ao_tooltip = 'Append / Overwrite (Default: Overwrite)'
# Font Selector
self._fontbox = QFontComboBox(self)
self._fontbox.currentFontChanged.connect(self.slot_font_changed)
# Font Size Label Hint
self._label_size = QLabel(self)
self._label_size_pixmap = QPixmap()
self._label_size_pixmap.load(
Resources().resource(Resource.ResourceToolIcon,
which=ToolIcon.ToolIconFontSize), None)
self._label_size.setFixedSize(25, 25)
self._label_size.setPixmap(self._label_size_pixmap)
self._label_size.setToolTip(font_size_tooltip)
# Font Size Input
self._fontsize = QLineEdit('8', self)
self._fontsize.setMaxLength(3)
self._fontsize.setInputMask('00D')
self._fontsize.setFixedSize(36, self._fontbox.height())
self._fontsize.setToolTip(font_size_tooltip)
self._fontsize.textChanged.connect(self.slot_size_changed)
# The Append / Overwrite Toggler
self._appendtoggler = AugerAppendToggler(self)
self._appendtoggler.setFixedSize(25, 25)
self._appendtoggler.setToolTip(ao_tooltip)
self._appendtoggler.clicked.connect(self.slot_append_toggle)
# The Undo Button
self._undobutton = QPushButton(self)
self._undobutton.setFixedSize(25, 25)
self._undobutton.setToolTip('Undo')
self._undobutton.setAccessibleName('toolbutton')
self._undobutton.setIcon(
QIcon(Resources().resource(Resource.ResourceToolIcon,
which=ToolIcon.ToolIconUndo)))
self._undobutton.setFlat(True)
self._undobutton.setEnabled(False)
self._undobutton.clicked.connect(self.slot_undo_clicked)
# The Redo Button
self._redobutton = QPushButton(self)
self._redobutton.setFixedSize(25, 25)
self._redobutton.setToolTip('Redo')
self._redobutton.setAccessibleName('toolbutton')
self._redobutton.setIcon(
QIcon(Resources().resource(Resource.ResourceToolIcon,
which=ToolIcon.ToolIconRedo)))
self._redobutton.setFlat(True)
self._redobutton.setEnabled(False)
self._redobutton.clicked.connect(self.slot_redo_clicked)
# The Layout holding all toolbar contents
self._layout = QHBoxLayout(self)
self._layout.addWidget(self._fontbox)
self._layout.addWidget(self._label_size)
self._layout.addWidget(self._fontsize)
self._layout.addWidget(self._appendtoggler)
self._layout.addWidget(self._undobutton)
self._layout.addWidget(self._redobutton)
self.setLayout(self._layout)
# connect slots to the command manager for undo / redo
get_app_instance().cmd_mgr.sig_undo_stack_changed.connect(
self.slot_undo_available)
get_app_instance().cmd_mgr.sig_redo_stack_changed.connect(
self.slot_redo_available)
# Override method
def paintEvent(self, paint_event): # pylint: disable=invalid-name
def border_coords():
coords = paint_event.rect()
return coords.x(), coords.y(), coords.width(), coords.height()
#
# # # # # # # # # # #
# make coordinates for border
draw_rect = tuple(
map(lambda x, y: x + y, border_coords(), (1, 1, -2, -2)))
# Prevent the painting of a border around children within the widget
if not self.childrenRect().contains(paint_event.rect()):
painter = QPainter(self)
painter.setPen(QPen(QColor(130, 135, 144, 255)))
painter.drawRect(*draw_rect)
return super().paintEvent(paint_event)
def set_font_properties(self, family, size):
self._fontbox.setCurrentFont(QFont(family))
self._fontsize.setText(str(size))
########### SLOTS ############## SLOTS ############# SLOTS ##############
def slot_font_changed(self, font):
self.sig_font_changed.emit(font.family())
def slot_size_changed(self, str_size):
try:
font_size = int(str_size)
except ValueError:
font_size = 0
if font_size > 0:
self.sig_size_changed.emit(font_size)
def slot_append_toggle(self, state):
self.sig_ao_toggle.emit(state)
def slot_undo_available(self, num_undos):
if num_undos > 0:
self._undobutton.setEnabled(True)
else:
self._undobutton.setEnabled(False)
def slot_redo_available(self, num_redos):
if num_redos > 0:
self._redobutton.setEnabled(True)
else:
self._redobutton.setEnabled(False)
def slot_undo_clicked(self): # pylint: disable=no-self-use
get_app_instance().cmd_mgr.undo_last_command()
def slot_redo_clicked(self): # pylint: disable=no-self-use
get_app_instance().cmd_mgr.redo_last_command()
