class FontLayout(QHBoxLayout):
"""Font selection"""
def __init__(self, value, parent=None):
QHBoxLayout.__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)
# Font size
self.size = QComboBox(parent)
self.size.setEditable(True)
sizelist = list(itertools.chain(range(6, 12), 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)
def get_font(self):
font = self.family.currentFont()
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)
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."""))
def loadSettings(self):
s = QSettings()
s.beginGroup("log")
font = QFont(s.value("fontfamily", "monospace"))
font.setPointSizeF(float(s.value("fontsize", 9.0)))
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) not in (False, "false"))
self.rawview.setChecked(s.value("rawview", True) not in (False, "false"))
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())
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.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.addWidget(self.size, 1, 0)
# Italic or not
self.italic = QCheckBox(self.tr("Italic"), parent)
self.addWidget(self.italic, 1, 1)
# Bold or not
self.bold = QCheckBox(self.tr("Bold"), parent)
self.addWidget(self.bold, 1, 2)
self.set_font(font)
def set_font(self, font):
self.family.setCurrentFont(font)
size = font.pointSize()
i = self.size.findText(str(size))
if i >= 0:
self.size.setCurrentIndex(i)
self.italic.setChecked(font.italic())
self.bold.setChecked(font.bold())
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 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.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.addWidget(self.size, 1, 0)
# Italic or not
self.italic = QCheckBox(self.tr("Italic"), parent)
self.addWidget(self.italic, 1, 1)
# Bold or not
self.bold = QCheckBox(self.tr("Bold"), parent)
self.addWidget(self.bold, 1, 2)
self.set_font(font)
def set_font(self, font):
self.family.setCurrentFont(font)
size = font.pointSize()
i = self.size.findText(str(size))
if i >= 0:
self.size.setCurrentIndex(i)
self.italic.setChecked(font.italic())
self.bold.setChecked(font.bold())
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 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", "")
if family:
font.setFamily(family)
font.setPointSizeF(float(s.value("fontsize", font.pointSizeF())))
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 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", "", type(""))
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 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", type("")))
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 QgsTextAnnotationDialog(QDialog):
def __init__(self, item):
QDialog.__init__(self)
self.gridLayout = QGridLayout(self)
self.gridLayout.setObjectName(("gridLayout"))
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout.setObjectName(("horizontalLayout"))
self.mFontComboBox = QFontComboBox(self)
self.mFontComboBox.setObjectName(("mFontComboBox"))
self.horizontalLayout.addWidget(self.mFontComboBox)
spacerItem = QSpacerItem(38, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem)
self.mFontSizeSpinBox = QSpinBox(self)
self.mFontSizeSpinBox.setObjectName(("mFontSizeSpinBox"))
self.horizontalLayout.addWidget(self.mFontSizeSpinBox)
self.mBoldPushButton = QPushButton(self)
self.mBoldPushButton.setMinimumSize(QSize(50, 0))
self.mBoldPushButton.setCheckable(True)
self.mBoldPushButton.setObjectName(("mBoldPushButton"))
self.horizontalLayout.addWidget(self.mBoldPushButton)
self.mItalicsPushButton = QPushButton(self)
self.mItalicsPushButton.setMinimumSize(QSize(50, 0))
self.mItalicsPushButton.setCheckable(True)
self.mItalicsPushButton.setObjectName(("mItalicsPushButton"))
self.horizontalLayout.addWidget(self.mItalicsPushButton)
self.mFontColorButton = QgsColorButton(self)
self.mFontColorButton.setText((""))
self.mFontColorButton.setAutoDefault(False)
self.mFontColorButton.setObjectName(("mFontColorButton"))
self.horizontalLayout.addWidget(self.mFontColorButton)
self.gridLayout.addLayout(self.horizontalLayout, 0, 0, 1, 1)
self.mButtonBox = QDialogButtonBox(self)
self.mButtonBox.setOrientation(Qt.Horizontal)
self.mButtonBox.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
self.mButtonBox.setObjectName(("mButtonBox"))
self.gridLayout.addWidget(self.mButtonBox, 3, 0, 1, 1)
self.mTextEdit = QTextEdit(self)
self.mTextEdit.setObjectName(("mTextEdit"))
self.gridLayout.addWidget(self.mTextEdit, 1, 0, 1, 1)
self.mStackedWidget = QStackedWidget(self)
self.mStackedWidget.setObjectName(("mStackedWidget"))
self.page = QWidget()
self.page.setObjectName(("page"))
self.mStackedWidget.addWidget(self.page)
self.page_2 = QWidget()
self.page_2.setObjectName(("page_2"))
self.mStackedWidget.addWidget(self.page_2)
self.gridLayout.addWidget(self.mStackedWidget, 2, 0, 1, 1)
self.setLayout(self.gridLayout)
self.mStackedWidget.setCurrentIndex(0)
QObject.connect(self.mButtonBox, SIGNAL(("accepted()")), self.accept)
QObject.connect(self.mButtonBox, SIGNAL(("rejected()")), self.reject)
self.setTabOrder(self.mFontComboBox, self.mFontSizeSpinBox)
self.setTabOrder(self.mFontSizeSpinBox, self.mBoldPushButton)
self.setTabOrder(self.mBoldPushButton, self.mItalicsPushButton)
self.setTabOrder(self.mItalicsPushButton, self.mFontColorButton)
self.setTabOrder(self.mFontColorButton, self.mTextEdit)
self.setTabOrder(self.mTextEdit, self.mButtonBox)
self.setWindowTitle("Annotation text")
self.mBoldPushButton.setText("B")
self.mItalicsPushButton.setText("I")
self.mTextDocument = None
self.mItem = item
self.mEmbeddedWidget = QgsAnnotationWidget(self, self.mItem )
self.mEmbeddedWidget.show()
self.mStackedWidget.addWidget( self.mEmbeddedWidget )
self.mStackedWidget.setCurrentWidget( self.mEmbeddedWidget )
if ( self.mItem != None ):
self.mTextDocument = self.mItem.document()
self.mTextEdit.setDocument( self.mTextDocument )
self.mFontColorButton.setColorDialogTitle( "Select font color" )
self.mFontColorButton.setColorDialogOptions( QColorDialog.ShowAlphaChannel )
self.setCurrentFontPropertiesToGui()
QObject.connect( self.mButtonBox, SIGNAL("accepted()"), self.applyTextToItem)
# QObject.connect( self.mFontComboBox, SIGNAL( "currentFontChanged(QFont())"), self.changeCurrentFormat)
self.mFontComboBox.currentFontChanged.connect(self.changeCurrentFormat)
QObject.connect( self.mFontSizeSpinBox, SIGNAL( "valueChanged( int )" ), self.changeCurrentFormat )
QObject.connect( self.mBoldPushButton, SIGNAL( "toggled( bool )" ), self.changeCurrentFormat)
QObject.connect( self.mItalicsPushButton, SIGNAL( "toggled( bool )" ), self.changeCurrentFormat)
QObject.connect( self.mTextEdit, SIGNAL( "cursorPositionChanged()" ), self.setCurrentFontPropertiesToGui )
# QObject.connect( self.mButtonBox, SIGNAL( "accepted()" ), self.applySettingsToItem)
deleteButton = QPushButton( "Delete" )
QObject.connect( deleteButton, SIGNAL( "clicked()" ), self.deleteItem )
self.mButtonBox.addButton( deleteButton, QDialogButtonBox.RejectRole )
def applyTextToItem(self):
if ( self.mItem != None and self.mTextDocument !=None ):
if ( self.mEmbeddedWidget != None):
self.mEmbeddedWidget.apply()
self.mItem.setDocument( self.mTextDocument )
self.mItem.update()
def changeCurrentFormat(self):
newFont = QFont()
newFont.setFamily( self.mFontComboBox.currentFont().family() )
#bold
if ( self.mBoldPushButton.isChecked() ):
newFont.setBold( True )
else:
newFont.setBold( False )
#italic
if ( self.mItalicsPushButton.isChecked() ):
newFont.setItalic( True )
else:
newFont.setItalic( False )
#size
newFont.setPointSize( self.mFontSizeSpinBox.value() )
self.mTextEdit.setCurrentFont( newFont )
#color
self.mTextEdit.setTextColor( self.mFontColorButton.color() )
def on_mFontColorButton_colorChanged(self, color ):
self.changeCurrentFormat()
def setCurrentFontPropertiesToGui(self):
self.blockAllSignals( True )
currentFont = self.mTextEdit.currentFont()
self.mFontComboBox.setCurrentFont( currentFont )
self.mFontSizeSpinBox.setValue( currentFont.pointSize() )
self.mBoldPushButton.setChecked( currentFont.bold() )
self.mItalicsPushButton.setChecked( currentFont.italic() )
self.mFontColorButton.setColor( self.mTextEdit.textColor() )
self.blockAllSignals( False )
def blockAllSignals(self, block ):
self.mFontComboBox.blockSignals( block )
self.mFontSizeSpinBox.blockSignals( block )
self.mBoldPushButton.blockSignals( block )
self.mItalicsPushButton.blockSignals( block )
self.mFontColorButton.blockSignals( block )
def deleteItem(self):
scene = self.mItem.scene()
if ( scene != None ):
scene.removeItem( self.mItem )
self.mItem = None
class GeneralSection(QWidget):
""" Clase Configuracion Editor """
def __init__(self):
super(GeneralSection, self).__init__()
main_container = QVBoxLayout(self)
# Tabs and indentation
group_indentation = QGroupBox(self.tr("Indentación y Tabs:"))
box = QGridLayout(group_indentation)
box.setContentsMargins(20, 5, 20, 5)
box.addWidget(QLabel(self.tr("Política:")), 0, 0)
self.combo_tabs = QComboBox()
self.combo_tabs.setFixedWidth(350)
self.combo_tabs.addItems([
self.tr("Solo Espacios"),
self.tr("Solo Tabulaciones"),
])
box.addWidget(self.combo_tabs, 0, 1)
self.combo_tabs.setCurrentIndex(
int(settings.get_setting('editor/usetabs')))
# Auto indent
self.check_autoindent = QCheckBox(self.tr("Indentación Automática"))
box.addWidget(self.check_autoindent, 1, 0)
box.setAlignment(Qt.AlignLeft)
self.check_autoindent.setChecked(settings.get_setting('editor/indent'))
# Minimap
group_minimap = QGroupBox(self.tr("Minimapa:"))
box = QGridLayout(group_minimap)
box.setContentsMargins(20, 5, 20, 5)
self.check_minimap = QCheckBox(
self.tr("Activar Minimapa (requiere reiniciar el Editor)"))
self.check_minimap.setChecked(settings.get_setting('editor/minimap'))
box.addWidget(self.check_minimap, 0, 0)
#self.check_minimap_animation = QCheckBox(self.tr("Enable animation"))
#self.check_minimap_animation.setChecked(
#settings.get_setting('editor/minimap-animation'))
#box.addWidget(self.check_minimap_animation, 1, 0)
#box.addWidget(QLabel(self.tr("Size Area:")), 2, 0)
#self.spin_area_minimap = QSpinBox()
#self.spin_area_minimap.setFixedWidth(350)
#box.addWidget(self.spin_area_minimap, 2, 1)
box.setAlignment(Qt.AlignLeft)
# Cursor
group_caret = QGroupBox(self.tr("Cursor:"))
box = QGridLayout(group_caret)
box.setContentsMargins(20, 5, 20, 5)
box.setAlignment(Qt.AlignLeft)
# Type
box.addWidget(QLabel(self.tr("Tipo:")), 0, 0)
self.combo_caret = QComboBox()
self.combo_caret.setFixedWidth(300)
caret_types = [
self.tr('Invisible'),
self.tr('Línea'),
self.tr('Bloque')
]
self.combo_caret.addItems(caret_types)
index = settings.get_setting('editor/cursor')
self.combo_caret.setCurrentIndex(index)
box.addWidget(self.combo_caret, 0, 1)
# Width
box.addWidget(QLabel(self.tr("Ancho:")), 1, 0)
self.spin_caret_width = QSpinBox()
self.spin_caret_width.setFixedWidth(300)
if index != 1:
self.spin_caret_width.setEnabled(False)
self.spin_caret_width.setRange(1, 3)
self.spin_caret_width.setValue(
settings.get_setting('editor/caret-width'))
box.addWidget(self.spin_caret_width, 1, 1, Qt.AlignLeft)
# Period
box.addWidget(QLabel(self.tr("Período (ms):")), 2, 0)
self.slider_caret_period = QSlider(Qt.Horizontal)
self.slider_caret_period.setMaximum(500)
self.slider_caret_period.setFixedWidth(300)
box.addWidget(self.slider_caret_period, 2, 1, Qt.AlignLeft)
lcd_caret = QLCDNumber()
lcd_caret.setSegmentStyle(QLCDNumber.Flat)
box.addWidget(lcd_caret, 2, 3)
# Font
group_typo = QGroupBox(self.tr("Fuente:"))
box = QGridLayout(group_typo)
box.setContentsMargins(20, 5, 20, 5)
box.addWidget(QLabel(self.tr("Familia:")), 0, 0)
self.combo_font = QFontComboBox()
self.combo_font.setFixedWidth(350)
box.addWidget(self.combo_font, 0, 1)
self._load_font()
box.addWidget(QLabel(self.tr("Tamaño:")), 1, 0)
self.spin_size_font = QSpinBox()
self.spin_size_font.setValue(settings.get_setting('editor/size-font'))
self.spin_size_font.setFixedWidth(350)
box.addWidget(self.spin_size_font, 1, 1)
box.setAlignment(Qt.AlignLeft)
# Scheme
group_scheme = QGroupBox(self.tr("Tema:"))
box = QVBoxLayout(group_scheme)
box.setContentsMargins(20, 5, 20, 5)
self.combo_scheme = QComboBox()
self.combo_scheme.setFixedWidth(350)
self.combo_scheme.addItems(['Dark Edis', 'White Edis'])
scheme = settings.get_setting('editor/scheme')
index = 0
if scheme != 'dark':
index = 1
self.combo_scheme.setCurrentIndex(index)
box.addWidget(self.combo_scheme)
box.addWidget(QLabel(self.tr("Requiere reiniciar Edis")))
## Agrupación
main_container.addWidget(group_indentation)
main_container.addWidget(group_minimap)
main_container.addWidget(group_caret)
main_container.addWidget(group_typo)
main_container.addWidget(group_scheme)
main_container.addItem(
QSpacerItem(0, 10, QSizePolicy.Expanding, QSizePolicy.Expanding))
EditorConfiguration.install_widget(self.tr("General"), self)
# Conexiones
self.combo_scheme.currentIndexChanged['const QString&'].connect(
self._change_scheme)
self.combo_caret.currentIndexChanged[int].connect(
self._caret_type_changed)
self.slider_caret_period.valueChanged[int].connect(lcd_caret.display)
self.slider_caret_period.setValue(
settings.get_setting('editor/cursor-period'))
def _change_scheme(self, theme):
theme = theme.split()[0].lower()
editor_container = Edis.get_component("principal")
editor = editor_container.get_active_editor()
if editor is not None:
# Restyle
pass
def _caret_type_changed(self, index):
self.spin_caret_width.setEnabled(bool(index))
def _load_font(self):
font = settings.get_setting('editor/font')
self.combo_font.setCurrentFont(QFont(font))
def save(self):
""" Guarda las configuraciones del Editor. """
use_tabs = bool(self.combo_tabs.currentIndex())
settings.set_setting('editor/usetabs', use_tabs)
auto_indent = self.check_autoindent.isChecked()
settings.set_setting('editor/indent', auto_indent)
settings.set_setting('editor/minimap', self.check_minimap.isChecked())
#settings.set_setting('editor/minimap-animation',
#self.check_minimap_animation.isChecked())
font = self.combo_font.currentFont().family()
settings.set_setting('editor/font', font)
font_size = self.spin_size_font.value()
settings.set_setting('editor/size-font', font_size)
scheme = self.combo_scheme.currentText().split()[0].lower()
settings.set_setting('editor/scheme', scheme)
settings.set_setting('editor/cursor', self.combo_caret.currentIndex())
settings.set_setting('editor/caret-width',
self.spin_caret_width.value())
settings.set_setting('editor/cursor-period',
self.slider_caret_period.value())
editor_container = Edis.get_component("principal")
editor = editor_container.get_active_editor()
if editor is not None:
editor.setIndentationsUseTabs(use_tabs)
editor.load_font(font, font_size)
class NotesMainWindow(QMainWindow):
"""The view class"""
def __init__(self, parent=None):
super().__init__(parent)
# Load saved application settings
self.recentNotes = []
self.numberOfTabs = 0 # keep track of the total number of tabs in the window
self.currentPage = None
self.__mediator = MITM.Mediator.Mediator(
) # the mediator object. intermediary btwn view and model
# create a timer
timer = QTimer(self)
# dialogs: saved to avoid eating memory by constant cre- and re- creation
self.findDialog = None
self.renameDialog = None
self.helpAboutDialog = HelpAboutDialog(self)
self.helpHelpDialog = HelpHelpDialog(self)
self.recentFilesListWidget = QListWidget
# create menus first
self.fileMenu = self.menuBar().addMenu("File")
self.recentNotesMenu = self.fileMenu.addMenu("Open Recent")
self.editMenu = self.menuBar().addMenu("Edit")
self.syncMenu = self.menuBar().addMenu("Sync")
self.helpMenu = self.menuBar().addMenu("Help")
# region Actions
# create the menu actions
# first the file menu actions
fileNewAct = self.createAction(self,
"&New",
shortcut=QKeySequence.New,
tooltip="Create a new note",
enabled=True,
slot=self.onNewClick)
fileOpenRecentNotesAct = self.createAction(self,
"&Open Recent Note",
tooltip="open recent notes",
enabled=True,
slot=self.onOpenRecentNotes)
fileQuitAct = self.createAction(self,
"&Exit",
shortcut=QKeySequence.Quit,
tooltip="Exit the application",
enabled=True,
slot=self.close)
# recent files menu actions
self.recentFilesMenuAct = self.createAction(self.recentNotesMenu,
"File 1")
# edit menu actions
editInsertAct = self.createAction(self,
"Ins&ert...",
shortcut="Ctrl+I",
tooltip="Insert a media file",
enabled=True)
editPreferencesAct = self.createAction(
self,
"&Preferences",
shortcut="Ctrl+Shift+P",
tooltip="Set application preferences",
enabled=True)
editFindAct = self.createAction(self,
"&Find",
shortcut=QKeySequence.Find,
tooltip="Find a text string",
slot=self.onFind)
editUndoAct = self.createAction(
self,
"&Undo",
shortcut=QKeySequence.Undo,
tooltip="Roll back changes to document",
slot=self.onUndo)
editRedoAct = self.createAction(self,
"&Redo",
shortcut=QKeySequence.Redo,
tooltip="Repeat the last action",
slot=self.onRedo)
editRenameAct = self.createAction(self,
"&Rename...",
shortcut="Ctrl+Shift+R",
tooltip="Rename current note",
slot=self.onRenameNote)
# sync menu actions
synCloudAcctAct = self.createAction(self,
"Cloud &Account",
shortcut="Alt+A",
tooltip="Sync with cloud accounts",
enabled=True)
# help menu actions
helpHelpAct = self.createAction(self,
"Help",
shortcut=QKeySequence.HelpContents,
tooltip="Display help",
enabled=True,
slot=self.onHelpHelp)
helpAboutAct = self.createAction(self,
"A&bout",
shortcut="Ctrl+Shift+B",
tooltip="About application",
enabled=True,
slot=self.onHelpAbout)
boldTextAction = self.createAction(self,
"B",
shortcut="Ctrl+B",
tooltip="Bold text")
italicsTextAction = self.createAction(self,
"<i>I</i>",
shortcut="Ctrl+I",
tooltip="Italics text")
# endregion
# add actions to corresponding menu
self.addActions_(
self.fileMenu,
(fileNewAct, fileOpenRecentNotesAct, fileQuitAct)) # to file menu
self.addActions_(self.editMenu,
(editRenameAct, editUndoAct, editRedoAct, editFindAct,
editInsertAct, editPreferencesAct)) # to edit menu
self.addActions_(self.helpMenu,
(helpHelpAct, helpAboutAct)) # to help menu
self.addActions_(self.recentNotesMenu, (self.recentFilesMenuAct, ))
# create tool bar and add relevant actions
allToolBar = self.addToolBar(
"All Tools"
) # tool bar that contains all tool;not separated into file/edit/*
self.addActions_(allToolBar,
(fileNewAct, synCloudAcctAct, editInsertAct,
editFindAct, editUndoAct, editRedoAct))
fontDetailsToolBar = self.addToolBar("Font Details")
self.fontTypeComboBox = QFontComboBox(
fontDetailsToolBar) # get font list present on the user system
self.fontSizeSpinBox = QSpinBox(fontDetailsToolBar) # size of the font
self.fontSizeSpinBox.setMinimum(7)
self.fontSizeSpinBox.setValue(12)
self.textBoldButton = QPushButton("B")
self.addNewNoteButton = QPushButton("+")
self.textItalicsButton = QPushButton("I")
maskLabel = QLabel(
fontDetailsToolBar) # TODO: experimental, to be removed
pixmap = QPixmap("Asset/guit.png") # TODO: experimental, remove
maskLabel.setPixmap(pixmap.mask()) # TODO: experimental, remove
self.addWidgetToToolBar(fontDetailsToolBar,
(self.fontTypeComboBox, self.fontSizeSpinBox,
self.textBoldButton, self.textItalicsButton))
# self.addActions_(fontDetailsToolBar, (boldTextAction, italicsTextAction))
# create a QTabWidget
self.tabWidget = QTabWidget(self)
self.tabWidget.setMovable(True)
self.tabWidget.setTabsClosable(True)
self.tabWidget.setTabPosition(QTabWidget.South)
# self.setTabPosition(Qt.BottomDockWidgetArea, QTabWidget.South) # TODO: not working yet. Handled
self.tabWidgetTabBar = self.tabWidget.tabBar()
self.tabWidget.setCornerWidget(self.addNewNoteButton,
Qt.TopRightCorner)
# create pages # TODO: let an event handler handle this job: HANDLED
self.onWindowStartOpenNote()
# self.page1 = View.TabbedPage.TabbedPage(self, Note("First", "/path"))
# # add the pages to the tab Widget
# self.tabWidget.addTab(self.page1, "Note 1 ")
# self.currentPage = self.tabWidget.currentWidget()
self.setCurrentPage()
# print("count() returned: ", self.tabWidget.count())
# create "+" bar: TODO: find a better way to create a plus tab: DONE
# self.plusTabIndex = self.tabWidgetTabBar.insertTab(self.tabWidget.count() + 1,
# "+") # this tab bears the "+" sign that indicates 'create new tab'
# self.plusTabWidget = self.tabWidget.widget(self.plusTabIndex) # get a reference to the plus tab widget
# create Dock widget that holds find dialog
# self.dockWidget = QDockWidget(self)
# self.dockWidget.setAllowedAreas(Qt.TopDockWidgetArea)
# self.dockWidget.setFeatures(QDockWidget.DockWidgetClosable|QDockWidget.DockWidgetMovable)
# self.dockWidget.setWidget(FindDialog.FindDialog(self.currentPage, self))
# self.dockWidget.hide()
# do window namings and other stuffs
self.statusbar = QStatusBar(self)
self.statusbar.setSizeGripEnabled(False)
self.setStatusBar(self.statusbar)
self.setCentralWidget(self.tabWidget)
self.setWindowTitle("Notes")
# region Signal And Slot Bindings
self.tabWidget.currentChanged.connect(self.setCurrentPage)
# self.currentPage.firstTime.connect(self.openPageOnFirstNavigation)
self.tabWidget.currentChanged.connect(
self.notifyMediatorOfCurrentPageChange)
# fileNewAct.triggered.connect(self.onNewClick)
# fileQuitAct.triggered.connect(self.close)
self.tabWidget.tabCloseRequested.connect(
self.confirmTabCloseAndCloseTab)
# self.tabWidget.tabCloseRequested.connect(self.holla)
self.fontTypeComboBox.currentFontChanged.connect(self.changeFont)
self.fontSizeSpinBox.valueChanged.connect(self.changeFontSize)
self.textBoldButton.clicked.connect(self.toggleTextBold)
self.textItalicsButton.clicked.connect(self.toggleTextItalics)
timer.timeout.connect(self.onSaveClick)
timer.timeout.connect(self.timed)
self.addNewNoteButton.clicked.connect(self.onNewClick)
self.currentPage.cursorPositionChanged.connect(
self.reportCurrentCursor)
self.recentNotesMenu.aboutToShow.connect(self.updateRecentNotesMenu)
# editUndoAct.triggered.connect(self.currentPage.undo)
# editRedoAct.triggered.connect(self.currentPage.redo)
# endregion
self.readSettings()
# QTimer.singleShot(5000, self.onSaveClick)
# Start the timer
timer.start(1500000)
# Application settings
# region Methods
def updateRecentNotesMenu(self):
"""Repopulate the recent files menu"""
self.recentNotesMenu.clear()
for note in self.recentNotes:
if os.path.exists(self.mediator.returnNotePath(note)):
noteName, ext = os.path.basename(note).split(".")
act = self.createAction(
self.recentNotesMenu, noteName, slot=self.loadNotes
) #TODO: incomplete update loadNotes() to receive the noteName
self.addActions_(self.recentNotesMenu, (act, ))
def onOpenRecentNotes(self):
""""""
def reportCurrentCursor(self):
print("###### cursor position has changed now #####") # TODO: remove
print("current font is: ", self.currentPage.currentFont().family())
self.fontTypeComboBox.setCurrentFont(self.currentPage.currentFont())
self.fontSizeSpinBox.setValue(
self.currentPage.currentFont().pointSize())
def onRecentNotes(self):
self.recentFilesListWidget.show()
def toggleTextItalics(self):
self.currentPage.setFontItalic(not self.currentPage.fontItalic())
self.currentPage.setFocus()
# if not self.textItalicsButton.isChecked():
# self.textItalicsButton.setChecked(True)
# self.currentPage.setFontItalic(True)
# self.currentPage.setFocus()
# return
# self.textItalicsButton.setChecked(False)
# self.currentPage.setFontItalic(False)
# self.currentPage.setFontItalic(checked)
# self.currentPage.setFontItalic(not self.currentPage.fontItalic)
def keyPressEvent(self, event: QKeyEvent):
if event.modifiers() and Qt.ControlModifier:
handled = False
if event.key() == Qt.Key_B:
self.toggleTextBold() # bolden text
handled = True
elif event.key() == Qt.Key_I:
self.toggleTextItalics() # italicise text
handled = True
print("Ctrl+I")
if handled:
event.accept()
return
else:
QTextEdit.keyPressEvent(self.currentPage, event)
def toggleTextBold(self):
self.currentPage.setFontWeight(
QFont.Normal
if self.currentPage.fontWeight() > QFont.Normal else QFont.Bold)
# if not self.textBoldButton.isChecked():
# # self.textBoldButton.setChecked(True)
# self.currentPage.setFontWeight(QFont.Bold)
# self.currentPage.setFocus()
# return
# # self.textBoldButton.setChecked(False)
# self.currentPage.setFontWeight(QFont.Normal)
self.currentPage.setFocus()
# self.currentPage.setFontWeight(QFont.Bold) if checked else \
# self.currentPage.setFontWeight(QFont.Normal)
# self.currentPage.setFocus()
def changeFontSize(self, value: float):
self.currentPage.setFontPointSize(value)
self.currentPage.setFocus()
def changeFont(self, font: QFont):
self.currentPage.setCurrentFont(font)
self.currentPage.setFocus()
def addWidgetToToolBar(self, toolBar: QToolBar, widgets: tuple):
for widget in widgets:
toolBar.addWidget(widget)
def holla(self, index):
"""Debugging Method. To be removed in release code"""
print("<<<<**** Hey! holla! Removing: .... ", index)
def timed(self):
"""Debugging Method. To be removed in release code"""
print("\n$$$$> Called by timer")
# region Methods
def onWindowStartOpenNote(self):
for note_file in self.findNotesInCurrentDirectory(
applicationDirectory): # find all the notes in the app dir
self.createNoteObjectFromNoteFile(
note_file) # create note objs from the files
self.createAndLoadNotes()
def createNoteObjectFromNoteFile(self, note_file: str):
self.mediator.createNote(notePath=note_file)
def createAndLoadNotes(
self): # Trent Harmon: When a man loves a woman....song request
if len(self.mediator.notesCollection) > 0:
self.loadNotes()
else: # couldn't find a note obj
self.createOnlyOneNote()
def loadNotes(self):
"""Creates a TabbedPage for each note found in notes collection
Without reading the contents of the associated note file found
In note path"""
note = self.sender().getData() if self.sender() is QAction else None
if note:
pageIndex = self.createNotePage(note)
self.tabWidget.setCurrentIndex(pageIndex)
for note in self.mediator.NotesCollection:
self.createNotePage(note)
# self.mediator.setCurrentlyDisplayedNote(note)
def createNotePage(self, note):
page = View.TabbedPage.TabbedPage(self, note)
pageIndex = self.tabWidget.addTab(page, note.NoteName)
page.page_number = pageIndex
return pageIndex
def createOnlyOneNote(self):
page1 = View.TabbedPage.TabbedPage(self, Note("First", "/path"))
# add the pages to the tab Widget
self.tabWidget.addTab(page1, "Note 1 ")
def openPageOnFirstNavigation(self):
"""Reads the content of the file on first nav.
Implements something like lazy loading
Implementation is whack.
Implementation Path:
onWindowStart -> createNoteObjectFromNoteFile -> createAndLoadNotes ->
loadNotes -> openPageOnFirstNavigation
TODO: make a better lazy loading implementatiion"""
# TODO: make a better lazy loading implementatiion
print("\n<<<<<I also work\n")
self.mediator.setCurrentlyDisplayedNote(self.currentPage.getNote())
try:
contents = self.mediator.openCurrentNote()
self.currentPage.setHtml(contents)
self.currentPage.moveCursor(
QTextCursor.End, QTextCursor.MoveAnchor
) # move the cursor to the end of the document
self.currentPageIsNowDirty(False)
except IOError as e:
logging.error("Note is not on filesystem yet: {}".format(e))
def currentPageIsNowDirty(self, bool_: bool = False):
self.currentPage.dirty = False
@property
def mediator(self):
return self.__mediator
@mediator.setter
def mediator(self, newMediator):
if isinstance(newMediator, MITM.Mediator.Mediator):
self.__mediator = newMediator
else:
raise TypeError("newMediator must be of type Mediator")
def writeSettings(self) -> None:
settings = QSettings()
settings.setValue("mainWindow/pos", self.pos())
settings.setValue("mainWindow/size", self.size())
settings.setValue("mainWindow/state", self.windowState())
openedNotes = [note.NotePath for note in self.mediator.NotesCollection]
settings.setValue("list of opened notes", openedNotes)
fontAttrList = self.fontTypeComboBox.currentFont().toString()
print("/////////>>>> ", fontAttrList)
settings.setValue("mainWindow/font", fontAttrList)
settings.setValue("mainWindow/fontSize", self.fontSizeSpinBox.value())
def readSettings(self):
settings = QSettings()
self.resize(settings.value("mainWindow/size", QSize(800, 600)))
pos = settings.value("mainWindow/pos", QPoint(0, 0))
listOfOpenedNotes = settings.value("list of opened notes")
print("Opened notes:", listOfOpenedNotes)
fontDetails = settings.value("mainWindow/font",
"Architext, -1, -1, False")
fontSize = settings.value("mainWindow/fontSize", 12)
family, _, _, fontWeight, italics, *_ = fontDetails.split(",")
font = QFont(family, int(fontSize), int(fontWeight), bool(italics))
self.fontTypeComboBox.setCurrentFont(font)
self.fontSizeSpinBox.setValue(int(fontSize))
self.textItalicsButton.click() if font.italic(
) else self.textItalicsButton.clearFocus(
) #TODO: code smell, review later
self.textBoldButton.click() if font.bold(
) else self.textBoldButton.clearFocus(
) #TODO: code smell, review later
self.move(pos)
self.restoreState(settings.value("mainWindow/state"))
def setCurrentPage(self):
"""Updates the self.currentPage variable"""
self.currentPage = self.tabWidget.currentWidget()
self.currentPage.I_becameCurrentPage()
print("::::::::: New current page set: ",
self.currentPage.getNote().NoteName) # TODO: remove
def notifyMediatorOfCurrentPageChange(self):
self.mediator.setCurrentlyDisplayedNote(self.currentPage.getNote())
def onNewClick(self):
"""Create a new area to write new note"""
tabCount = self.tabWidget.count() + 1
noteObject = self.mediator.createNote(tabCount)
page = View.TabbedPage.TabbedPage(self, note=noteObject)
newPageIndex = self.tabWidget.addTab(
page,
"Note {}".format(tabCount)) # add the page to the parent tabWidget
page.page_number = newPageIndex # assign a number to the page
self.numberOfTabs = self.tabWidget.count()
# self.tabWidgetTabBar.moveTab(self.plusTabIndex,
# self.numberOfTabs) # move the "+" tab to the end TODO: update the index of the plus tab widget
self.moveToTab(newPageIndex)
self.currentPage.setFocus()
def moveToTab(self, newPageIndex: int):
self.tabWidgetTabBar.setCurrentIndex(
newPageIndex) # switch to the just created page
def onSaveClick(self, pages: list = []):
"""This method gets the text from the current page;
Passes the text along with the attached Note object to the mediator to save
"""
if len(pages) == 0: # pages is a list of note pages to be saved
pages.append(self.currentPage)
for page in pages:
if page.dirty:
rich_text = page.toHtml(
) # get the text from the current document
# note = self.currentPage.getNote() # get the Note object attached to this page
try:
self.mediator.saveNote(rich_text, page.getNote(
)) # give the text document to the mediator
self.currentPageIsNowDirty(False)
except IOError as error:
QMessageBox(self, "File Save Error",
"Could not save the file", "Ok")
assert isinstance(
error, IOError
) # pycharm suggested this, I don't think it's needed here
print("Error", "IOError occurred", error)
logging.log(1, "IOError occurred", error)
except NoNoteException as error:
# QMessageBox.critical(self, "File Save Error", "Could not save the file: {}".format(error),
# "Ok") # TODO:Not sure this will work yet. Handled
print("Error", "IOError occurred: No Note", error)
logging.log(1, error)
else:
print("\n-----> No changes made to code")
def onRenameNote(self):
"""Rename a Note"""
# TODO : create a rename dialog window later
renameDialog = RenameDialog(self)
if renameDialog.exec_():
newName = renameDialog.getNewName()
try:
self.mediator.renameNote(newName)
self.tabWidget.setTabText(self.currentPage.page_number,
newName)
except Exception as e: # TODO: what error exactly
print("Error renaming this file: ",
e) # TODO: do better, inform the user of the problem
raise e
def onUndo(self):
"""Connect to QTextEdit undo slot. A work around for inability to connect a QAction to
QTextEdit undo slot.
"""
self.currentPage.undo()
def onRedo(self):
"""Connect to QTextEdit undo slot. A work around for inability to connect a QAction to
QTextEdit undo slot.
"""
self.currentPage.redo()
# cus = CustomSignal()
# cus.redoTriggered.connect(QTextEdit.redo)
def onFind(self): # TODO: song request Paul I.K. Dairo: Mo wa dupe
textSelected = self.currentPage.getDocumentCursor().selectedText()
print("Text Selected is: ", textSelected)
self.findDialog = FindDialog.FindDialog(self.currentPage, self,
textSelected)
self.findDialog.show()
# self.dockWidget.show()
def onHelpAbout(self):
self.helpAboutDialog.show()
def onHelpHelp(self):
self.helpHelpDialog.show()
def closeEvent(self, event: QEvent):
# TODO: raise a dialog that prompts the user to accept the closing of the application
"""
:type event: QEvent
"""
numberOfPages = self.tabWidget.count()
widgetList = [
self.tabWidget.widget(widget) for widget in range(numberOfPages)
]
# self.onSaveClick(widgetList) # save notes first
self.writeSettings()
event.accept()
def confirmTabCloseAndCloseTab(self, index):
pageToRemove = self.tabWidget.widget(index)
if pageToRemove.dirty and isinstance(pageToRemove,
View.TabbedPage.TabbedPage):
print("Tab Close requested")
dialog = QMessageBox.warning(self, "Confirm",
"Do you want to close the tab?", "Ok",
"Cancel", "", 1)
if dialog != 0:
return
self.tabWidget.removeTab(pageToRemove.page_number)
self.recentNotes.append(pageToRemove.getNote())
@staticmethod
def addActions_(parent, actions: tuple) -> None:
for action in actions:
parent.addAction(action)
@staticmethod
def createAction(parent: QObject,
text: str,
icon: object = None,
shortcut: str = None,
tooltip: str = None,
enabled: bool = False,
signal: str = "triggered",
slot: object = None) -> object:
action = QAction(parent)
action.setText(text)
if icon:
action.setIcon(
QIcon(icon)) # icon is expected as a string argument
if shortcut:
action.setShortcut(shortcut)
if tooltip:
action.setToolTip(tooltip)
if enabled:
action.setEnabled(enabled)
if slot and signal == "triggered":
action.pyqtConfigure(triggered=slot)
return action
@staticmethod
def findNotesInCurrentDirectory(directory: str):
if os.path.exists(directory):
for path, dirs, files in os.walk(directory):
for file in files:
if file.endswith(".dn"):
fullPath = os.path.join(directory, path, file)
yield os.path.normpath(os.path.abspath(fullPath))
def __str__(self):
print("I am a note window with id {}".format(self.winId()))
def __repr__(self):
print(r"I am a note")
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", type(""))
self.romanCombo.setCurrentFont(QFont(roman))
sans = s.value("sans", "sans-serif", type(""))
self.sansCombo.setCurrentFont(QFont(sans))
typewriter = s.value("typewriter", "monospace", type(""))
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 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", type(""))
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", "", type(""))
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 GeneralSection(QWidget):
""" Clase Configuracion Editor """
def __init__(self):
super(GeneralSection, self).__init__()
main_container = QVBoxLayout(self)
# Tabs and indentation
group_indentation = QGroupBox(self.tr("Indentación y Tabs:"))
box = QGridLayout(group_indentation)
box.setContentsMargins(20, 5, 20, 5)
box.addWidget(QLabel(self.tr("Política:")), 0, 0)
self.combo_tabs = QComboBox()
self.combo_tabs.setFixedWidth(350)
self.combo_tabs.addItems([
self.tr("Solo Espacios"),
self.tr("Solo Tabulaciones"),
])
box.addWidget(self.combo_tabs, 0, 1)
self.combo_tabs.setCurrentIndex(
int(settings.get_setting('editor/usetabs')))
# Auto indent
self.check_autoindent = QCheckBox(self.tr("Indentación Automática"))
box.addWidget(self.check_autoindent, 1, 0)
box.setAlignment(Qt.AlignLeft)
self.check_autoindent.setChecked(settings.get_setting('editor/indent'))
# Minimap
group_minimap = QGroupBox(self.tr("Minimapa:"))
box = QGridLayout(group_minimap)
box.setContentsMargins(20, 5, 20, 5)
self.check_minimap = QCheckBox(
self.tr("Activar Minimapa (requiere reiniciar el Editor)"))
self.check_minimap.setChecked(settings.get_setting('editor/minimap'))
box.addWidget(self.check_minimap, 0, 0)
#self.check_minimap_animation = QCheckBox(self.tr("Enable animation"))
#self.check_minimap_animation.setChecked(
#settings.get_setting('editor/minimap-animation'))
#box.addWidget(self.check_minimap_animation, 1, 0)
#box.addWidget(QLabel(self.tr("Size Area:")), 2, 0)
#self.spin_area_minimap = QSpinBox()
#self.spin_area_minimap.setFixedWidth(350)
#box.addWidget(self.spin_area_minimap, 2, 1)
box.setAlignment(Qt.AlignLeft)
# Cursor
group_caret = QGroupBox(self.tr("Cursor:"))
box = QGridLayout(group_caret)
box.setContentsMargins(20, 5, 20, 5)
box.setAlignment(Qt.AlignLeft)
# Type
box.addWidget(QLabel(self.tr("Tipo:")), 0, 0)
self.combo_caret = QComboBox()
self.combo_caret.setFixedWidth(300)
caret_types = [
self.tr('Invisible'),
self.tr('Línea'),
self.tr('Bloque')
]
self.combo_caret.addItems(caret_types)
index = settings.get_setting('editor/cursor')
self.combo_caret.setCurrentIndex(index)
box.addWidget(self.combo_caret, 0, 1)
# Width
box.addWidget(QLabel(self.tr("Ancho:")), 1, 0)
self.spin_caret_width = QSpinBox()
self.spin_caret_width.setFixedWidth(300)
if index != 1:
self.spin_caret_width.setEnabled(False)
self.spin_caret_width.setRange(1, 3)
self.spin_caret_width.setValue(
settings.get_setting('editor/caret-width'))
box.addWidget(self.spin_caret_width, 1, 1, Qt.AlignLeft)
# Period
box.addWidget(QLabel(self.tr("Período (ms):")), 2, 0)
self.slider_caret_period = QSlider(Qt.Horizontal)
self.slider_caret_period.setMaximum(500)
self.slider_caret_period.setFixedWidth(300)
box.addWidget(self.slider_caret_period, 2, 1, Qt.AlignLeft)
lcd_caret = QLCDNumber()
lcd_caret.setSegmentStyle(QLCDNumber.Flat)
box.addWidget(lcd_caret, 2, 3)
# Font
group_typo = QGroupBox(self.tr("Fuente:"))
box = QGridLayout(group_typo)
box.setContentsMargins(20, 5, 20, 5)
box.addWidget(QLabel(self.tr("Familia:")), 0, 0)
self.combo_font = QFontComboBox()
self.combo_font.setFixedWidth(350)
box.addWidget(self.combo_font, 0, 1)
self._load_font()
box.addWidget(QLabel(self.tr("Tamaño:")), 1, 0)
self.spin_size_font = QSpinBox()
self.spin_size_font.setValue(settings.get_setting('editor/size-font'))
self.spin_size_font.setFixedWidth(350)
box.addWidget(self.spin_size_font, 1, 1)
box.setAlignment(Qt.AlignLeft)
# Scheme
group_scheme = QGroupBox(self.tr("Tema:"))
box = QVBoxLayout(group_scheme)
box.setContentsMargins(20, 5, 20, 5)
self.combo_scheme = QComboBox()
self.combo_scheme.setFixedWidth(350)
self.combo_scheme.addItems(['Dark Edis', 'White Edis'])
scheme = settings.get_setting('editor/scheme')
index = 0
if scheme != 'dark':
index = 1
self.combo_scheme.setCurrentIndex(index)
box.addWidget(self.combo_scheme)
box.addWidget(QLabel(self.tr("Requiere reiniciar Edis")))
## Agrupación
main_container.addWidget(group_indentation)
main_container.addWidget(group_minimap)
main_container.addWidget(group_caret)
main_container.addWidget(group_typo)
main_container.addWidget(group_scheme)
main_container.addItem(QSpacerItem(0, 10, QSizePolicy.Expanding,
QSizePolicy.Expanding))
EditorConfiguration.install_widget(self.tr("General"), self)
# Conexiones
self.combo_scheme.currentIndexChanged['const QString&'].connect(
self._change_scheme)
self.combo_caret.currentIndexChanged[int].connect(
self._caret_type_changed)
self.slider_caret_period.valueChanged[int].connect(
lcd_caret.display)
self.slider_caret_period.setValue(
settings.get_setting('editor/cursor-period'))
def _change_scheme(self, theme):
theme = theme.split()[0].lower()
editor_container = Edis.get_component("principal")
editor = editor_container.get_active_editor()
if editor is not None:
# Restyle
pass
def _caret_type_changed(self, index):
self.spin_caret_width.setEnabled(bool(index))
def _load_font(self):
font = settings.get_setting('editor/font')
self.combo_font.setCurrentFont(QFont(font))
def save(self):
""" Guarda las configuraciones del Editor. """
use_tabs = bool(self.combo_tabs.currentIndex())
settings.set_setting('editor/usetabs', use_tabs)
auto_indent = self.check_autoindent.isChecked()
settings.set_setting('editor/indent', auto_indent)
settings.set_setting('editor/minimap', self.check_minimap.isChecked())
#settings.set_setting('editor/minimap-animation',
#self.check_minimap_animation.isChecked())
font = self.combo_font.currentFont().family()
settings.set_setting('editor/font', font)
font_size = self.spin_size_font.value()
settings.set_setting('editor/size-font', font_size)
scheme = self.combo_scheme.currentText().split()[0].lower()
settings.set_setting('editor/scheme', scheme)
settings.set_setting('editor/cursor',
self.combo_caret.currentIndex())
settings.set_setting('editor/caret-width',
self.spin_caret_width.value())
settings.set_setting('editor/cursor-period',
self.slider_caret_period.value())
editor_container = Edis.get_component("principal")
editor = editor_container.get_active_editor()
if editor is not None:
editor.setIndentationsUseTabs(use_tabs)
editor.load_font(font, font_size)
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", type(""))
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 Tool(QToolBar):
def __init__(self,parent):
QToolBar.__init__(self,parent)
self.parent = parent
self.action_NewProject = QAction(Icons.newprj, 'Project', self)
self.action_NewProject.triggered.connect(self.parent.treeWidget.newProject)
self.action_NewProject.setToolTip("Create a New Project")
self.action_Open = QAction(Icons.open, 'Open', self)
self.action_Open.triggered.connect(self.parent.fileOpen)
self.action_Open.setToolTip("Open File")
self.action_Save = QAction(Icons.save, 'Save', self)
self.action_Save.setShortcut('Ctrl+S')
self.action_Save.triggered.connect(self.parent.fileSave)
self.action_Save.setToolTip("Save Current File")
self.action_SaveAll = QAction(Icons.saveall, 'SaveAll', self)
self.action_SaveAll.setShortcut('Ctrl+A')
self.action_SaveAll.triggered.connect(self.parent.fileSaveAll)
self.action_SaveAll.setToolTip("Save All Files")
self.action_Build = QAction(Icons.thread_view, 'Build', self)
self.action_Build.setShortcut('Ctrl+B')
self.action_Build.triggered.connect(self.parent.build_project)
self.action_Debug = QAction(Icons.debug_exec, 'Debug', self)
self.action_Refresh = QAction(Icons.refresh_tab, 'Refresh', self)
self.action_Refresh.triggered.connect(self.parent.treeWidget.refreshCurrentProject)
self.action_Run = QAction(Icons.run, 'Run', self)
self.action_Run.setShortcut('Ctrl+R')
self.action_Run.triggered.connect(self.parent.adb.run)
self.action_RunFile = QAction(Icons.go, 'Cmd', self)
self.action_RunFile.triggered.connect(self.parent.openCommand)
self.parent.runButton.clicked.connect(self.parent.command.setCmdLine)
self.action_Stop = QAction(Icons.stop, 'Stop', self)
self.action_Stop.setShortcut('Ctrl+Q')
self.action_Stop.triggered.connect(self.parent.adb.stop)
self.action_Design = QAction(Icons.color_palette, 'Design', self)
self.action_Design.triggered.connect(self.parent.design)
self.action_Level = QAction(Icons.cmpC_pal, 'Level', self)
self.action_Level.triggered.connect(self.parent.level)
self.action_Todo = QAction(Icons.task_set, 'Todo', self)
self.action_Todo.triggered.connect(self.parent.todo)
self.action_Help = QAction(Icons.toc_open, 'Help', self)
self.action_Help.triggered.connect(self.parent.help)
men = QMenu()
#Threshold Slider
self.threshSlider = QSlider()
self.threshSlider.setTickPosition(QSlider.TicksLeft)
self.threshSlider.setOrientation(Qt.Horizontal)
self.threshSlider.setValue(config.thresh())
self.threshSlider.setMinimum(0)
self.threshSlider.setMaximum(5)
self.threshSlider.valueChanged.connect(self.parent.setThreshold)
self.threshSliderAction = QWidgetAction(men)
self.threshSliderAction.setDefaultWidget(self.threshSlider)
#TabsWidth Slider
self.tabsSlider = QSlider()
self.tabsSlider.setTickPosition(QSlider.TicksLeft)
self.tabsSlider.setOrientation(Qt.Horizontal)
self.tabsSlider.setValue(config.tabwidth())
self.tabsSlider.setMinimum(0)
self.tabsSlider.setMaximum(8)
self.tabsSlider.valueChanged.connect(self.parent.setTabWidth)
self.tabsSliderAction = QWidgetAction(men)
self.tabsSliderAction.setDefaultWidget(self.tabsSlider)
#iconSize Slider
self.iconSlider = QSlider()
self.iconSlider.setTickPosition(QSlider.TicksLeft)
self.iconSlider.setOrientation(Qt.Horizontal)
self.iconSlider.setValue(config.iconSize())
self.iconSlider.setMinimum(16)
self.iconSlider.setMaximum(32)
self.iconSlider.setSingleStep(2)
self.iconSlider.valueChanged.connect(self.setIcon)
self.iconSliderAction = QWidgetAction(men)
self.iconSliderAction.setDefaultWidget(self.iconSlider)
'''Font Button'''
self.fontCombo = QFontComboBox()
self.fontCombo.currentFontChanged.connect(self.parent.setFont)
self.fontCombo.setCurrentFont(QFont(config.fontName()))
self.fontComboMenu = QWidgetAction(men)
self.fontComboMenu.setDefaultWidget(self.fontCombo)
'''Font Size'''
self.fontSizeCombo = QComboBox()
for size in range(1,40):
self.fontSizeCombo.addItem(str(size))
self.fontSizeCombo.setCurrentIndex(config.fontSize())
self.fontSizeCombo.currentIndexChanged.connect(self.parent.setFontSize)
self.fontSizeComboMenu = QWidgetAction(men)
self.fontSizeComboMenu.setDefaultWidget(self.fontSizeCombo)
action_explorer = QAction("Show Explorer",self)
action_explorer.triggered.connect(self.parent.exp)
action_console = QAction("Show Console",self)
action_console.triggered.connect(self.parent.cmd)
action_designer = QAction("Show Designer",self)
action_designer.triggered.connect(self.parent.design)
action_Indentation = QAction("Indentation Guides",self)
action_Indentation.triggered.connect(self.parent.setIndent)
action_WhiteSpace = QAction("Show WhiteSpace",self)
action_WhiteSpace.triggered.connect(self.parent.setWhiteSpace)
action_EndLine = QAction("Show End of Lines",self)
action_EndLine.triggered.connect(self.parent.setEndLine)
action_Margin = QAction("Line Numbers",self)
action_Margin.triggered.connect(self.parent.setMargin)
action_ToolLabel = QAction("Tool Labels",self)
action_ToolLabel.triggered.connect(self.setToolLabel)
action_Android = QAction(Icons.android,'Android', self)
action_Android.triggered.connect(self.parent.android)
action_Ant = QAction(Icons.ant_view,'Ant', self)
action_Ant.triggered.connect(self.parent.antt)
action_Squirrel = QAction(Icons.nut,'Squirrel', self)
action_Squirrel.triggered.connect(self.parent.squirrel)
action_Ios1 = QAction(Icons.ios,'iOS', self)
action_Update = QAction("Update",self)
action_Update.triggered.connect(self.parent.update)
'''Encoding'''
encodingGroup = QActionGroup(self)
encodingGroup.setExclusive(True)
action_Ascii = QAction("Ascii",encodingGroup)
action_Ascii.setCheckable(True)
action_Unicode = QAction("Unicode",encodingGroup)
action_Unicode.setCheckable(True)
encodingGroup.addAction(action_Ascii)
encodingGroup.addAction(action_Unicode)
encodingGroup.selected.connect(self.parent.setEncoding)
if(config.encoding() == Encoding.ASCII):
action_Ascii.setChecked(True)
else:
action_Unicode.setChecked(True)
men.addAction(action_Android)
men.addAction(action_Ant)
men.addAction(action_Squirrel)
men.addAction(action_Ios1)
men.addAction(action_Update)
men.addSeparator()
men.addAction(action_explorer)
men.addAction(action_console)
men.addAction(action_designer)
men.addAction(action_Indentation)
men.addAction(action_WhiteSpace)
men.addAction(action_EndLine)
men.addAction(action_Margin)
men.addAction(action_ToolLabel)
men.addSeparator()
men.addActions(encodingGroup.actions())
men.addSeparator()
head_font = QLabel("Font---------------------")
fnt = head_font.font()
fnt.setBold(True)
head_font.setFont(fnt)
head_fontWidgetAction = QWidgetAction(men)
head_fontWidgetAction.setDefaultWidget(head_font)
men.addAction(head_fontWidgetAction)
men.addAction(self.fontComboMenu)
men.addAction(self.fontSizeComboMenu)
men.addSeparator()
men.addAction(QAction("TabWidth",self))
men.addAction(self.tabsSliderAction)
men.addSeparator()
men.addAction(QAction("Threshold",self))
men.addAction(self.threshSliderAction)
#men.addAction(QAction("Icon Size",self))
#men.addAction(self.iconSliderAction)
self.action_Options = QAction(Icons.emblem_system, 'Options', self)
self.action_Options.setMenu(men)
self.action_Full = QAction(Icons.fullscreen, 'Full', self)
self.action_Full.setShortcut('Shift+Enter')
self.action_Full.triggered.connect(self.parent.full)
self.modeGroup = QActionGroup(self)
self.modeGroup.setExclusive(True)
self.modeGroup.selected.connect(self.parent.setMode)
self.action_Squirrel = QAction(Icons.nut, 'Squ', self.modeGroup)
self.action_Squirrel.setCheckable(True)
self.action_Emo = QAction(Icons.emo, 'Emo', self.modeGroup)
self.action_Emo.setCheckable(True)
self.action_And = QAction(Icons.android, 'Android', self.modeGroup)
self.action_And.setCheckable(True)
self.action_Ios = QAction(Icons.ios, 'ios', self.modeGroup)
self.action_Ios.setCheckable(True)
self.modeGroup.addAction(self.action_Squirrel)
self.modeGroup.addAction(self.action_Emo)
self.modeGroup.addAction(self.action_And)
self.modeGroup.addAction(self.action_Ios)
self.action_Style = QAction(Icons.style, 'Style', self)
men1 = QMenu()
self.styleslist = []
self.style1 = QAction("All Hallow's Eve",self)
self.style1.triggered.connect(lambda:self.parent.style_clicked(1))
self.style1.setCheckable(True)
self.style2 = QAction("Amy",self)
self.style2.triggered.connect(lambda:self.parent.style_clicked(2))
self.style2.setCheckable(True)
self.style3 = QAction("Aptana Studio",self)
self.style3.triggered.connect(lambda:self.parent.style_clicked(3))
self.style3.setCheckable(True)
self.style4 = QAction("Bespin",self)
self.style4.triggered.connect(lambda:self.parent.style_clicked(4))
self.style4.setCheckable(True)
self.style5 = QAction("Blackboard",self)
self.style5.triggered.connect(lambda:self.parent.style_clicked(5))
self.style5.setCheckable(True)
self.style6 = QAction("Choco",self)
self.style6.triggered.connect(lambda:self.parent.style_clicked(6))
self.style6.setCheckable(True)
self.style7 = QAction("Cobalt",self)
self.style7.triggered.connect(lambda:self.parent.style_clicked(7))
self.style7.setCheckable(True)
self.style8 = QAction("Dawn",self)
self.style8.triggered.connect(lambda:self.parent.style_clicked(8))
self.style8.setCheckable(True)
self.style9 = QAction("Eclipse",self)
self.style9.triggered.connect(lambda:self.parent.style_clicked(9))
self.style9.setCheckable(True)
self.styleslist.append(self.style1)
self.styleslist.append(self.style2)
self.styleslist.append(self.style3)
self.styleslist.append(self.style4)
self.styleslist.append(self.style5)
self.styleslist.append(self.style6)
self.styleslist.append(self.style7)
self.styleslist.append(self.style8)
self.styleslist.append(self.style9)
men1.addActions(self.styleslist)
self.action_Style.setMenu(men1)
self.styleslist[self.parent.styleIndex].setChecked(True)
self.action_Stop.setDisabled(True)
self.setToolLabel()
self.setAllowedAreas(Qt.AllToolBarAreas)
#self.setFixedHeight(40)
#self.setIconSize(QSize(config.iconSize(),config.iconSize()))
self.addAction(self.action_NewProject)
self.addAction(self.action_Open)
self.addAction(self.action_Save)
self.addAction(self.action_SaveAll)
#self.addAction(self.action_Refresh)
self.addSeparator()
self.addAction(self.action_Build)
self.addAction(self.action_Run)
self.addAction(self.action_RunFile)
self.addAction(self.action_Stop)
self.addAction(self.action_Debug)
self.addSeparator()
self.addAction(self.action_Design)
self.addAction(self.action_Level)
self.addAction(self.action_Todo)
self.addAction(self.action_Options)
self.addAction(self.action_Style)
self.addSeparator()
self.addAction(self.action_Help)
self.addAction(self.action_Full)
self.addSeparator()
self.addActions(self.modeGroup.actions())
if(config.mode() == 0):
self.action_Squirrel.setChecked(True)
elif(config.mode() == 1):
self.action_Emo.setChecked(True)
elif(config.mode() == 2):
self.action_And.setChecked(True)
elif(config.mode() == 3):
self.action_Ios.setChecked(True)
def setIcon(self,val):
config.setIconSize(val)
self.setIconSize(QSize(val,val))
def setToolLabel(self):
if (config.toolLabel()):
self.setToolButtonStyle(Qt.ToolButtonIconOnly)
self.setIconSize(QSize(24,24))
else:
self.setIconSize(QSize(16,16))
self.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
'''Important for multiple callbacks in for loop'''
def make_callback(self, param):
return lambda:self.parent.setFontName(param)
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", type(""))
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", "", type(""))
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 Tool(QToolBar):
def __init__(self,parent):
QToolBar.__init__(self,parent)
self.parent = parent
self.action_NewProject = QAction(Icons.newprj, 'Project', self)
self.action_NewProject.triggered.connect(self.parent.treeWidget.newProject)
self.action_NewProject.setToolTip("Create a New Project")
self.action_Open = QAction(Icons.open, 'Open', self)
self.action_Open.triggered.connect(self.parent.fileOpen)
self.action_Open.setToolTip("Open File")
self.action_Save = QAction(Icons.save, 'Save', self)
self.action_Save.setShortcut('Ctrl+S')
self.action_Save.triggered.connect(self.parent.fileSave)
self.action_Save.setToolTip("Save Current File")
self.action_SaveAll = QAction(Icons.saveall, 'SaveAll', self)
self.action_SaveAll.setShortcut('Ctrl+A')
self.action_SaveAll.triggered.connect(self.parent.fileSaveAll)
self.action_SaveAll.setToolTip("Save All Files")
self.action_Build = QAction(Icons.thread_view, 'Build', self)
self.action_Build.setShortcut('Ctrl+B')
self.action_Build.triggered.connect(self.parent.build_project)
self.action_Debug = QAction(Icons.debug_exec, 'Debug', self)
self.action_Refresh = QAction(Icons.refresh_tab, 'Refresh', self)
self.action_Refresh.triggered.connect(self.parent.treeWidget.refreshCurrentProject)
self.action_Run = QAction(Icons.run, 'Run', self)
self.action_Run.setShortcut('Ctrl+R')
self.action_Run.triggered.connect(self.parent.adb.run)
self.action_RunFile = QAction(Icons.go, 'Cmd', self)
self.action_RunFile.triggered.connect(self.parent.openCommand)
self.parent.runButton.clicked.connect(self.parent.command.setCmdLine)
self.action_Stop = QAction(Icons.stop, 'Stop', self)
self.action_Stop.setShortcut('Ctrl+Q')
self.action_Stop.triggered.connect(self.parent.adb.stop)
self.action_Design = QAction(Icons.color_palette, 'Design', self)
self.action_Design.triggered.connect(self.parent.design)
self.action_Level = QAction(Icons.cmpC_pal, 'Level', self)
self.action_Level.triggered.connect(self.parent.level)
self.action_Todo = QAction(Icons.task_set, 'Todo', self)
self.action_Todo.triggered.connect(self.parent.todo)
self.action_Help = QAction(Icons.toc_open, 'Help', self)
self.action_Help.triggered.connect(self.parent.help)
self.action_Full = QAction(Icons.fullscreen, 'Full', self)
self.action_Full.triggered.connect(self.parent.full)
self.action_Stop.setDisabled(True)
self.setToolLabel()
self.setAllowedAreas(Qt.AllToolBarAreas)
#self.setFixedHeight(40)
#self.setIconSize(QSize(config.iconSize(),config.iconSize()))
''' Adding all Actions '''
self.addAction(self.action_NewProject)
self.addAction(self.action_Open)
self.addAction(self.action_Save)
self.addAction(self.action_SaveAll)
#self.addAction(self.action_Refresh)
self.addSeparator()
self.addAction(self.action_Build)
self.addAction(self.action_Run)
#self.addAction(self.action_RunFile)
self.addAction(self.action_Stop)
self.addAction(self.action_Debug)
self.addSeparator()
self.addAction(self.action_Design)
self.addAction(self.action_Level)
self.addAction(self.action_Todo)
self.initOptionsMenu()
self.addSeparator()
self.initStyleMenu()
self.initLexerMenu()
self.initApiMenu()
#self.addAction(self.action_Help)
#self.addAction(self.action_Full)
self.addSeparator()
self.initModeMenu()
def colorChange(self, text, color):
#print "colorChange ",text,color
editStyle = config.readStyle()
editStyle[text] = color
config.writeStyle(editStyle)
for i in range(len(self.parent.files)):
self.parent.tabWidget.widget(i).setEditorStyle()
def setColors(self,action):
print action.text()
def changeAll(self):
self.colorChange("base", "#ffffff")
def setIcon(self,val):
config.setIconSize(val)
self.setIconSize(QSize(val,val))
def setToolLabel(self):
if (config.toolLabel()):
self.setToolButtonStyle(Qt.ToolButtonIconOnly)
self.setIconSize(QSize(24,24))
else:
self.setIconSize(QSize(16,16))
self.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
'''Important for multiple callbacks in for loop'''
def make_callback(self, text):
return lambda:self.colorChange(text)
''' Options Menu '''
def initOptionsMenu(self):
men = QMenu()
#Threshold Slider
self.threshSlider = QSlider()
self.threshSlider.setTickPosition(QSlider.TicksLeft)
self.threshSlider.setOrientation(Qt.Horizontal)
self.threshSlider.setValue(config.thresh())
self.threshSlider.setMinimum(0)
self.threshSlider.setMaximum(5)
self.threshSlider.valueChanged.connect(self.parent.setThreshold)
self.threshSliderAction = QWidgetAction(men)
self.threshSliderAction.setDefaultWidget(self.threshSlider)
#TabsWidth Slider
self.tabsSlider = QSlider()
self.tabsSlider.setTickPosition(QSlider.TicksLeft)
self.tabsSlider.setOrientation(Qt.Horizontal)
self.tabsSlider.setValue(config.tabwidth())
self.tabsSlider.setMinimum(0)
self.tabsSlider.setMaximum(8)
self.tabsSlider.valueChanged.connect(self.parent.setTabWidth)
self.tabsSliderAction = QWidgetAction(men)
self.tabsSliderAction.setDefaultWidget(self.tabsSlider)
#iconSize Slider
self.iconSlider = QSlider()
self.iconSlider.setTickPosition(QSlider.TicksLeft)
self.iconSlider.setOrientation(Qt.Horizontal)
self.iconSlider.setValue(config.iconSize())
self.iconSlider.setMinimum(16)
self.iconSlider.setMaximum(32)
self.iconSlider.setSingleStep(2)
self.iconSlider.valueChanged.connect(self.setIcon)
self.iconSliderAction = QWidgetAction(men)
self.iconSliderAction.setDefaultWidget(self.iconSlider)
'''Font Button'''
self.fontCombo = QFontComboBox()
self.fontCombo.currentFontChanged.connect(self.parent.setFont)
self.fontCombo.setCurrentFont(QFont(config.fontName()))
self.fontComboMenu = QWidgetAction(men)
self.fontComboMenu.setDefaultWidget(self.fontCombo)
'''Font Size'''
self.fontSizeCombo = QComboBox()
for size in range(1,40):
self.fontSizeCombo.addItem(str(size))
self.fontSizeCombo.setCurrentIndex(config.fontSize())
self.fontSizeCombo.currentIndexChanged.connect(self.parent.setFontSize)
self.fontSizeComboMenu = QWidgetAction(men)
self.fontSizeComboMenu.setDefaultWidget(self.fontSizeCombo)
action_Android = QAction(Icons.android,'Android', self)
action_Android.triggered.connect(self.parent.android)
action_Ant = QAction(Icons.ant_view,'Ant', self)
action_Ant.triggered.connect(self.parent.antt)
action_Squirrel = QAction(Icons.nut,'Squirrel', self)
action_Squirrel.triggered.connect(self.parent.squirrel)
action_Ios1 = QAction(Icons.ios,'iOS', self)
action_Update = QAction(Icons.update,"Update",self)
action_Update.triggered.connect(self.parent.update)
action_explorer = QAction("Explorer",self)
action_explorer.triggered.connect(self.parent.exp)
action_explorer.setCheckable(True)
action_explorer.setChecked(True)
action_console = QAction("Console",self)
action_console.triggered.connect(self.parent.cmd)
action_console.setCheckable(True)
action_console.setChecked(False)
#action_designer = QAction("Designer",self)
#action_designer.triggered.connect(self.parent.design)
action_Indentation = QAction("Indentation Guides",self)
action_Indentation.triggered.connect(self.parent.setIndent)
action_Indentation.setCheckable(True)
action_Indentation.setChecked(config.indent())
action_WhiteSpace = QAction("WhiteSpace",self)
action_WhiteSpace.triggered.connect(self.parent.setWhiteSpace)
action_WhiteSpace.setCheckable(True)
action_WhiteSpace.setChecked(config.whiteSpace())
action_EndLine = QAction("End of Lines",self)
action_EndLine.triggered.connect(self.parent.setEndLine)
action_EndLine.setCheckable(True)
action_Margin = QAction("Line Numbers",self)
action_Margin.triggered.connect(self.parent.setMargin)
action_Margin.setCheckable(True)
action_Margin.setChecked(config.margin())
action_ToolLabel = QAction("Tool Labels",self)
action_ToolLabel.triggered.connect(self.setToolLabel)
action_ToolLabel.setCheckable(True)
#action_ToolLabel.setChecked(config.toolLabel())
'''Encoding'''
encodingGroup = QActionGroup(self)
encodingGroup.setExclusive(True)
action_Ascii = QAction("Ascii",encodingGroup)
action_Ascii.setCheckable(True)
action_Unicode = QAction("Unicode",encodingGroup)
action_Unicode.setCheckable(False)
encodingGroup.addAction(action_Ascii)
encodingGroup.addAction(action_Unicode)
encodingGroup.selected.connect(self.parent.setEncoding)
if(config.encoding() == Encoding.ASCII):
action_Ascii.setChecked(True)
else:
action_Unicode.setChecked(True)
men.addAction(action_Update)
men.addAction(self.action_Help)
men.addAction(self.action_Full)
men.addSeparator()
men.addAction(action_Android)
men.addAction(action_Ant)
men.addAction(action_Squirrel)
men.addAction(action_Ios1)
men.addSeparator()
men.addAction(action_explorer)
men.addAction(action_console)
#men.addAction(action_designer)
men.addSeparator()
men.addAction(action_Indentation)
men.addAction(action_WhiteSpace)
men.addAction(action_EndLine)
men.addAction(action_Margin)
men.addAction(action_ToolLabel)
men.addSeparator()
men.addActions(encodingGroup.actions())
men.addSeparator()
head_font = QLabel("Font---------------------")
fnt = head_font.font()
fnt.setBold(True)
head_font.setFont(fnt)
head_fontWidgetAction = QWidgetAction(men)
head_fontWidgetAction.setDefaultWidget(head_font)
men.addAction(head_fontWidgetAction)
men.addAction(self.fontComboMenu)
men.addAction(self.fontSizeComboMenu)
men.addSeparator()
men.addAction(QAction("TabWidth",self))
men.addAction(self.tabsSliderAction)
men.addSeparator()
men.addAction(QAction("Threshold",self))
men.addAction(self.threshSliderAction)
#men.addAction(QAction("Icon Size",self))
#men.addAction(self.iconSliderAction)
self.action_Options = QAction(Icons.emblem_system, 'Options', self)
self.action_Options.setMenu(men)
self.addAction(self.action_Options)
''' Mode Menu '''
def initModeMenu(self):
self.modeGroup = QActionGroup(self)
self.modeGroup.setExclusive(True)
self.modeGroup.selected.connect(self.parent.setMode)
self.action_Squirrel = QAction(Icons.nut, 'Squ', self.modeGroup)
self.action_Squirrel.setCheckable(True)
self.action_Emo = QAction(Icons.emo, 'Emo', self.modeGroup)
self.action_Emo.setCheckable(True)
self.action_And = QAction(Icons.android, 'Android', self.modeGroup)
self.action_And.setCheckable(True)
self.action_Ios = QAction(Icons.ios, 'ios', self.modeGroup)
self.action_Ios.setCheckable(True)
self.modeGroup.addAction(self.action_Squirrel)
self.modeGroup.addAction(self.action_Emo)
self.modeGroup.addAction(self.action_And)
self.modeGroup.addAction(self.action_Ios)
self.addActions(self.modeGroup.actions())
if(config.mode() == 0):
self.action_Squirrel.setChecked(True)
self.action_Build.setEnabled(False)
self.action_Run.setEnabled(False)
elif(config.mode() == 1):
self.action_Emo.setChecked(True)
self.action_Build.setEnabled(True)
self.action_Run.setEnabled(True)
elif(config.mode() == 2):
self.action_And.setChecked(True)
self.action_Build.setEnabled(True)
self.action_Run.setEnabled(True)
elif(config.mode() == 3):
self.action_Ios.setChecked(True)
self.action_Build.setEnabled(False)
self.action_Run.setEnabled(False)
''' Style Menu '''
def initStyleMenu(self):
editStyle = config.readStyle()
self.action_Style = QAction(Icons.style, 'Style', self)
men = QMenu(self)
men1 = QMenu()
self.base = StyleWidget(self,"base",editStyle["base"])
self.back = StyleWidget(self,"back",editStyle["back"])
self.caret = StyleWidget(self,"caret",editStyle["caret"])
self.margin = StyleWidget(self,"margin",editStyle["margin"])
self.marker = StyleWidget(self,"marker",editStyle["marker"])
self.comment = StyleWidget(self,"comment",editStyle["comment"])
self.number = StyleWidget(self,"number",editStyle["number"])
self.keyword = StyleWidget(self,"keyword",editStyle["keyword"])
self.string = StyleWidget(self,"string",editStyle["string"])
self.operator = StyleWidget(self,"operator",editStyle["operator"])
self.connect(self.base, SIGNAL("colorChange"),self.colorChange)
self.connect(self.back, SIGNAL("colorChange"),self.colorChange)
self.connect(self.caret, SIGNAL("colorChange"),self.colorChange)
self.connect(self.margin, SIGNAL("colorChange"),self.colorChange)
self.connect(self.marker, SIGNAL("colorChange"),self.colorChange)
self.connect(self.comment, SIGNAL("colorChange"),self.colorChange)
self.connect(self.number, SIGNAL("colorChange"),self.colorChange)
self.connect(self.keyword, SIGNAL("colorChange"),self.colorChange)
self.connect(self.string, SIGNAL("colorChange"),self.colorChange)
self.connect(self.operator, SIGNAL("colorChange"),self.colorChange)
self.baseMenu = QWidgetAction(men)
self.baseMenu.setDefaultWidget(self.base)
self.backMenu = QWidgetAction(men)
self.backMenu.setDefaultWidget(self.back)
self.caretMenu = QWidgetAction(men)
self.caretMenu.setDefaultWidget(self.caret)
self.marginMenu = QWidgetAction(men)
self.marginMenu.setDefaultWidget(self.margin)
self.markerMenu = QWidgetAction(men)
self.markerMenu.setDefaultWidget(self.marker)
self.commentMenu = QWidgetAction(men)
self.commentMenu.setDefaultWidget(self.comment)
self.numberMenu = QWidgetAction(men)
self.numberMenu.setDefaultWidget(self.number)
self.keywordMenu = QWidgetAction(men)
self.keywordMenu.setDefaultWidget(self.keyword)
self.stringMenu = QWidgetAction(men)
self.stringMenu.setDefaultWidget(self.string)
self.operatorMenu = QWidgetAction(men)
self.operatorMenu.setDefaultWidget(self.operator)
self.styleGroup = QActionGroup(self)
self.styleGroup.setExclusive(True)
self.styleGroup.selected.connect(self.setColors)
self.style1 = QAction("All Hallow's Eve",self.styleGroup)
self.style1.setCheckable(True)
self.style2 = QAction("Amy",self.styleGroup)
self.style2.setCheckable(True)
self.style3 = QAction("Aptana Studio",self.styleGroup)
self.style3.setCheckable(True)
self.style4 = QAction("Bespin",self.styleGroup)
self.style4.setCheckable(True)
self.style5 = QAction("Blackboard",self.styleGroup)
self.style5.setCheckable(True)
self.style6 = QAction("Choco",self.styleGroup)
self.style6.setCheckable(True)
self.style7 = QAction("Cobalt",self.styleGroup)
self.style7.setCheckable(True)
self.style8 = QAction("Dawn",self.styleGroup)
self.style8.setCheckable(True)
self.style9 = QAction("Eclipse",self.styleGroup)
self.style9.setCheckable(True)
self.styleGroup.addAction(self.style1)
self.styleGroup.addAction(self.style2)
self.styleGroup.addAction(self.style3)
self.styleGroup.addAction(self.style4)
self.styleGroup.addAction(self.style5)
self.styleGroup.addAction(self.style6)
self.styleGroup.addAction(self.style7)
self.styleGroup.addAction(self.style8)
self.styleGroup.addAction(self.style9)
men1.addAction(self.baseMenu)
men1.addAction(self.backMenu)
men1.addAction(self.caretMenu)
men1.addAction(self.marginMenu)
men1.addAction(self.markerMenu)
men1.addAction(self.commentMenu)
men1.addAction(self.numberMenu)
men1.addAction(self.keywordMenu)
men1.addAction(self.stringMenu)
men1.addAction(self.operatorMenu)
men1.addSeparator()
men2 = QMenu(self)
men2.setTitle("Styles")
men2.addActions(self.styleGroup.actions())
men1.addMenu(men2)
self.action_Style.setMenu(men1)
self.addAction(self.action_Style)
''' Lexer Menu'''
def make_action_lex(self, text):
action = QAction(text, self.lexGroup)
action.setCheckable(True)
return action
def initLexerMenu(self):
self.action_Lexer = QAction(Icons.file_obj, 'Lexer', self)
men = QMenu()
self.lexGroup = QActionGroup(self)
self.lexGroup.setExclusive(True)
self.lexGroup.selected.connect(self.parent.setLexer)
#langs = [i for i in dir(Qsci) if i.startswith('QsciLexer')]
langs = ['Bash', 'Batch', 'CMake', 'CPP', 'CSS', 'C#','HTML','Java', 'JavaScript', 'Lua', 'Makefile','Python', 'SQL', 'XML', 'YAML']
for l in langs:
act = self.make_action_lex(l)
self.lexGroup.addAction(act)
if(langs.index(l) == 8): #For javascript
act.setChecked(True)
#print l[9:] # we don't need to print "QsciLexer" before each name
men.addActions(self.lexGroup.actions())
self.action_Lexer.setMenu(men)
self.addAction(self.action_Lexer)
''' Api Menu '''
def make_action_api(self, text):
action = QAction(text, self.apiGroup)
action.setCheckable(True)
return action
def initApiMenu(self):
self.action_Api = QAction(Icons.lib, 'Api', self)
men = QMenu()
self.apiGroup = QActionGroup(self)
self.apiGroup.setExclusive(True)
self.apiGroup.selected.connect(self.parent.setApi)
list = oslistdir(apiDir)
apis = []
if(list != None):
for i in list:
if i.endswith("api"):
apis.append(i.replace(".api", ""))
if(apis != None):
for i in apis:
act = self.make_action_api(i)
self.apiGroup.addAction(act)
if(i == "emo"): #For emo
act.setChecked(True)
men.addActions(self.apiGroup.actions())
self.action_Api.setMenu(men)
self.addAction(self.action_Api)
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", type(""))
self.romanCombo.setCurrentFont(QFont(roman))
sans = s.value("sans", "sans-serif", type(""))
self.sansCombo.setCurrentFont(QFont(sans))
typewriter = s.value("typewriter", "monospace", type(""))
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())