def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.minimum_value = -100
self.maximum_value = 100
self.value_range = self.maximum_value - self.minimum_value
self.total_angle = 200 # degree
self.pressed = False
self.scale_visible = True
self.scale_arc_visible = True
self.scale_text_visible = True
self.scale_step_size = 10
self.scale_step_divisions = 2
self.knob_radius = 20 # px
self.knob_style = KnobWidget.STYLE_ROUND
self.dynamic_resize = False
self.dynamic_knob_radius = None
self.needle_base_radius = 7 # px
self.needle_color = Qt.red
self.knob_to_scale = 4 # px
self.knob_scaleless_to_border = 1 # px, applied if scale not visible
self.base_color = QColor(245, 245, 245)
self.base_color_pressed = Qt.red
self.mark_color = Qt.black
self.border_color = QColor(190, 190, 190)
self.tick_size_large = 9 # px
self.tick_size_small = 5 # px
self.tick_to_text = 4 # px
self.text_to_border = 2 # px
self.text_radius = None
self.title_text = None
self.value = self.value_range / 2
self.value_factor = float(self.value -
self.minimum_value) / self.value_range
self.font_metrics = QFontMetrics(self.font())
self.recalculate_size()
def mousePressEvent(self, event):
if self.foldArea > 0:
xofs = self.width() - self.foldArea
font_metrics = QFontMetrics(self.edit.document().defaultFont())
fh = font_metrics.lineSpacing()
ys = event.posF().y()
lineNumber = 0
if event.pos().x() > xofs:
pattern = self.pat
if self.edit.lang != "python":
pattern = self.patNotPython
block = self.edit.firstVisibleBlock()
viewport_offset = self.edit.contentOffset()
page_bottom = self.edit.viewport().height()
while block.isValid():
position = self.edit.blockBoundingGeometry(
block).topLeft() + viewport_offset
if position.y() > page_bottom:
break
if position.y() < ys and (position.y() + fh) > ys and \
pattern.match(str(block.text())):
if not block.blockNumber() in self._endDocstringBlocks:
lineNumber = block.blockNumber() + 1
break
if position.y() < ys and (position.y() + fh) > ys and \
event.button() == Qt.LeftButton:
line = block.blockNumber()
self.set_breakpoint(line)
break
elif position.y() < ys and (position.y() + fh) > ys and \
event.button() == Qt.RightButton:
line = block.blockNumber()
self.set_bookmark(line)
break
block = block.next()
if lineNumber > 0:
self.code_folding_event(lineNumber)
def create_values_text(self):
painter = QPainter(self)
# painter.setRenderHint(QPainter.HighQualityAntialiasing)
painter.setRenderHint(QPainter.Antialiasing)
# Koordinatenursprung in die Mitte der Flaeche legen
painter.translate(self.width() / 2, self.height() / 2)
# painter.save()
# xShadow = 3.0
# yShadow = 3.0
font = QFont(self.value_fontname, self.value_fontsize)
fm = QFontMetrics(font)
pen_shadow = QPen()
pen_shadow.setBrush(self.DisplayValueColor)
painter.setPen(pen_shadow)
text_radius = self.widget_diameter / 2 * self.text_radius_factor
# angle_distance = (float(self.scale_angle_size) / float(self.scala_main_count))
# for i in range(self.scala_main_count + 1):
text = str(int(self.value))
w = fm.width(text) + 1
h = fm.height()
painter.setFont(QFont(self.value_fontname, self.value_fontsize))
# Mitte zwischen Skalenstart und Skalenende:
# Skalenende = Skalenanfang - 360 + Skalenlaenge
# Skalenmitte = (Skalenende - Skalenanfang) / 2 + Skalenanfang
angle_end = float(self.scale_angle_start_value + self.scale_angle_size - 360)
angle = (angle_end - self.scale_angle_start_value) / 2 + self.scale_angle_start_value
x = text_radius * math.cos(math.radians(angle))
y = text_radius * math.sin(math.radians(angle))
# print(w, h, x, y, text)
text = [x - int(w/2), y - int(h/2), int(w), int(h), Qt.AlignCenter, text]
painter.drawText(text[0], text[1], text[2], text[3], text[4], text[5])
def _calc_size(self):
realSize = self.realsize
canvaswidth = self.canvas.width()
mapunitsperpixel = abs(self.canvas.mapUnitsPerPixel())
mapunits = self.canvas.mapUnits()
prefered_units = roam.config.settings.get("prefer_units", "meters")
newunits = QGis.fromLiteral(prefered_units, QGis.Meters)
mapunitsperpixel *= QGis.fromUnitToUnitFactor(mapunits, newunits)
mapunits = newunits
# Convert the real distance into pixels
barwidth = realSize / mapunitsperpixel
if barwidth < 30:
barwidth = canvaswidth / 4
while barwidth > canvaswidth / 3:
barwidth /= 3
realSize = barwidth * mapunitsperpixel
# Round
powerof10 = math.floor(math.log10(realSize))
scaler = math.pow(10.0, powerof10)
realSize = round(realSize / scaler) * scaler
barwidth = realSize / mapunitsperpixel
label, realSize = self._label_size(mapunits, realSize)
metrics = QFontMetrics(self.font)
fontwidth = metrics.width(label)
fontheight = metrics.height()
sizelabel = QLocale.system().toString(realSize)
sizelabel = "{} {}".format(sizelabel, label)
barwidth = self._adjust_bar_size(barwidth, mapunits)
barwidth = barwidth + fontwidth
return barwidth, realSize, sizelabel, (fontwidth, fontheight)
def paintEvent(self, event):
"""QLineEdit.paintEvent implementation.
Draws prompt
"""
QLineEdit.paintEvent(self, event)
if self._promptText and not self.text() and self.isEnabled():
option = QStyleOptionFrameV3()
self.initStyleOption(option)
left, top, right, bottom = self.getTextMargins()
va = self.style().visualAlignment(self.layoutDirection(),
self.alignment())
rect = self.style().subElementRect(
QStyle.SE_LineEditContents, option,
self).adjusted(2, 0, 0, 0).adjusted(left, top, -right, -bottom)
fm = QFontMetrics(self.font())
text = fm.elidedText(self._promptText, Qt.ElideRight, rect.width())
painter = QPainter(self)
painter.setPen(self.palette().color(QPalette.Disabled,
QPalette.Text))
painter.drawText(rect, va, text)
def updateAlexaAppImgCoords(self):
self.edit._alexaAppImgIconsCoords = []
#block = self.edit.document().findBlock(0)
block = self.edit.firstVisibleBlock()
line_count = block.blockNumber()
pat = re.compile('\s*#AppImage:')
viewport_offset = self.edit.contentOffset()
while block.isValid():
line_count += 1
#maxLine = math.ceil(math.log10(self.edit.blockCount()))
font_metrics = QFontMetrics(self.edit.document().defaultFont())
position = self.edit.blockBoundingGeometry(block).topLeft() + viewport_offset
width = self.edit.blockBoundingGeometry(block).width()
'''
width = 4
for char in block.text():
width += font_metrics.width(char)
'''
x = 5 + viewport_offset.x()
if pat.match(block.text()):
try:
if self.edit.useTabs:
x += block.text().index(" #") * (font_metrics.width('.') * self.edit.indent)
else:
x += block.text().index(" #") * font_metrics.width('.')
except:
pass
if block.isVisible(): # da notare che il blocco è la riga e non il blocco compreso tra i tag di Al'exa
self.edit._alexaAppImgIconsCoords.append((x, position.y(), width, line_count))
block = block.next()
def __init__(self, parent=None):
super(RichTextLineEdit, self).__init__(parent)
self.monofamily = QString("courier")
self.sansfamily = QString("helvetica")
self.seriffamily = QString("times")
self.setLineWrapMode(QTextEdit.NoWrap)
self.setTabChangesFocus(True)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
fm = QFontMetrics(self.font())
h = int(fm.height() * (1.4 if platform.system() == "Windows" else 1.2))
self.setMinimumHeight(h)
self.setMaximumHeight(int(h * 1.2))
self.setToolTip(
"Press <b>Ctrl+M</b> for text effects menu and <b>Ctrl+K</b> for the color menu"
)
def splash_screen():
path = pkg_resources.resource_filename(
__name__, "icons/oasys-splash-screen.png")
pm = QPixmap(path)
version = QCoreApplication.applicationVersion()
size = 21 if len(version) < 5 else 16
font = QFont("Helvetica")
font.setPixelSize(size)
font.setBold(True)
font.setItalic(True)
font.setLetterSpacing(QFont.AbsoluteSpacing, 2)
metrics = QFontMetrics(font)
br = metrics.boundingRect(version).adjusted(-5, 0, 5, 0)
br.moveCenter(QPoint(436, 224))
p = QPainter(pm)
p.setRenderHint(QPainter.Antialiasing)
p.setRenderHint(QPainter.TextAntialiasing)
p.setFont(font)
p.setPen(QColor("#231F20"))
p.drawText(br, Qt.AlignCenter, version)
p.end()
return pm, QRect(88, 193, 200, 20)
def resizeEvent(self, event):
super(VersionItemWidget, self).resizeEvent(event)
# make sure we have finished initializing before we resize
if (not '_version' in self.__dict__):
return
metrics = QFontMetrics(self.font())
version = self._version
# update the labels with eliding based on new spacing
self.uiUserLBL.setText(
metrics.elidedText(version.username(), Qt.ElideRight,
self.uiUserLBL.width()))
# convert out any html data
comments = str(version.comments())
doc = QTextDocument()
doc.setHtml(comments)
comments = str(doc.toPlainText())
self.uiCommentsLBL.setText(
metrics.elidedText(comments.replace('\n', ' '), Qt.ElideRight,
self.uiCommentsLBL.width()))
def __init__(self, parent, *args):
QToolBar.__init__(self, parent, *args)
self.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum))
self._dock = parent
self.aClose = QToolBar.addAction(
self,
self.style().standardIcon(QStyle.SP_TitleBarCloseButton), "")
self.setMovable(False)
self.setFloatable(False)
self.aClose.triggered.connect(self._dock.close)
textHeight = QFontMetrics(self.font()).height()
self.setIconSize(QSize(textHeight, textHeight))
# a fake spacer widget
self._spacer = QWidget(self)
self._spacer.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.MinimumExpanding))
self.addWidget(self._spacer)
def gen_font(font_configs,
font_type=FONT_TYPES.font01,
img_width=1024,
draw_outlines=False):
img_height = HEIGHT_FACTOR
seen_chars = []
game_font = GameFont(width=img_width)
painter = QPainter(game_font.trans)
text_brush = QtGui.QBrush(QColor(255, 255, 255, 255))
painter.setBrush(text_brush)
outline_brush = QtGui.QBrush()
outline_pen = QtGui.QPen(QColor(255, 0, 0, 255),
1,
style=Qt.Qt.DotLine,
join=Qt.Qt.MiterJoin)
x_pos = 0
y_pos = 0
line_height = LINE_HEIGHT[font_type]
for config in font_configs:
font = QFont(config.family, config.size, config.weight, italic=False)
font.setKerning(False)
metric = QFontMetrics(font)
painter.setFont(font)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.Antialiasing, True)
text_pen = painter.pen()
text_pen.setBrush(QColor(255, 255, 255, 255))
text_pen.setWidthF(config.pen_size)
text_pen.setCapStyle(config.pen_cap)
text_pen.setJoinStyle(config.pen_join)
text_pen.setStyle(Qt.Qt.SolidLine if config.use_pen else Qt.Qt.NoPen)
painter.setPen(text_pen)
for char in sorted(config.chars):
if char in seen_chars:
continue
else:
seen_chars.append(char)
# If we want a character to represent something it's not.
char_to_print = char
if char in config.subs:
char_to_print = config.subs[char]
char_w = metric.width(char_to_print)
if x_pos + char_w > img_width:
x_pos = 0
y_pos += line_height + config.y_margin
if y_pos < 0:
y_pos = 0
if y_pos + line_height > MAX_HEIGHT:
_LOGGER.warning(
"Ran out of vertical space. Generated font does not include all characters."
)
break
game_font.font_data.data.append({
'char': char,
'x': x_pos,
'y': y_pos,
'w': char_w,
'h': line_height,
'y_shift': config.y_shift
})
path = QPainterPath()
path.addText(x_pos + config.x_offset,
y_pos + metric.ascent() + config.y_offset, font,
char_to_print)
painter.drawPath(path)
if draw_outlines:
painter.setBrush(outline_brush)
painter.setPen(outline_pen)
painter.setRenderHint(QPainter.Antialiasing, False)
painter.drawRect(x_pos, y_pos, char_w, line_height)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setBrush(text_brush)
painter.setPen(text_pen)
x_pos += char_w + config.x_margin
painter.end()
painter = QPainter(game_font.opaque)
painter.drawImage(game_font.opaque.rect(), game_font.trans,
game_font.trans.rect())
painter.end()
# Crop our images so they only take up as much space as they need.
final_height = int(
math.ceil(float(y_pos + line_height) / float(HEIGHT_FACTOR)) *
HEIGHT_FACTOR)
game_font.trans = game_font.trans.copy(0, 0, img_width, final_height)
game_font.opaque = game_font.opaque.copy(0, 0, img_width, final_height)
return game_font
# if __name__ == '__main__':
# app = QtGui.QApplication(sys.argv)
# chars = load_text(CHAR_LIST)
# We can't have dupes, and why not put them in order while we're at it?
# chars = sorted(make_unique(chars))
# game_font = gen_font(chars)
# game_font.save(SAVE_AS)
### EOF ###
def _setMinimumHeight(self):
fnt = self.settings.value("pythonConsole/fontfamilytext", "Monospace")
fntSize = self.settings.value("pythonConsole/fontsize", 10, type=int)
fm = QFontMetrics(QFont(fnt, fntSize))
self.setMinimumHeight(fm.height() + 10)
def paintEvent(self, event):
page_bottom = self.edit.viewport().height()
font_metrics = QFontMetrics(self.edit.document().defaultFont())
current_block = self.edit.document().findBlock(
self.edit.textCursor().position())
pattern = self.pat if self.edit.lang == "python" else self.patNotPython
painter = QPainter(self)
background = resources.CUSTOM_SCHEME.get('sidebar-background',
resources.COLOR_SCHEME['sidebar-background'])
foreground = resources.CUSTOM_SCHEME.get('sidebar-foreground',
resources.COLOR_SCHEME['sidebar-foreground'])
pep8color = resources.CUSTOM_SCHEME.get('pep8-underline',
resources.COLOR_SCHEME['pep8-underline'])
errorcolor = resources.CUSTOM_SCHEME.get('error-underline',
resources.COLOR_SCHEME['error-underline'])
painter.fillRect(self.rect(), QColor(background))
block = self.edit.firstVisibleBlock()
viewport_offset = self.edit.contentOffset()
line_count = block.blockNumber()
painter.setFont(self.edit.document().defaultFont())
while block.isValid():
line_count += 1
# The top left position of the block in the document
position = self.edit.blockBoundingGeometry(block).topLeft() + \
viewport_offset
# Check if the position of the block is outside of the visible area
if position.y() > page_bottom:
break
# Set the Painter Pen depending on special lines
error = False
if settings.CHECK_STYLE and \
((line_count - 1) in self._pep8Lines):
painter.setPen(QColor(pep8color))
font = painter.font()
font.setItalic(True)
font.setUnderline(True)
painter.setFont(font)
error = True
elif settings.FIND_ERRORS and \
((line_count - 1) in self._errorsLines):
painter.setPen(QColor(errorcolor))
font = painter.font()
font.setItalic(True)
font.setUnderline(True)
painter.setFont(font)
error = True
else:
painter.setPen(QColor(foreground))
# We want the line number for the selected line to be bold.
bold = False
if block == current_block:
bold = True
font = painter.font()
font.setBold(True)
painter.setFont(font)
# Draw the line number right justified at the y position of the
# line. 3 is a magic padding number. drawText(x, y, text).
if block.isVisible():
painter.drawText(self.width() - self.foldArea -
font_metrics.width(str(line_count)) - 3,
round(position.y()) + font_metrics.ascent() +
font_metrics.descent() - 1,
str(line_count))
# Remove the bold style if it was set previously.
if bold:
font = painter.font()
font.setBold(False)
painter.setFont(font)
if error:
font = painter.font()
font.setItalic(False)
font.setUnderline(False)
painter.setFont(font)
block = block.next()
self.highest_line = line_count
#Code Folding
xofs = self.width() - self.foldArea
painter.fillRect(xofs, 0, self.foldArea, self.height(),
QColor(resources.CUSTOM_SCHEME.get('fold-area',
resources.COLOR_SCHEME['fold-area'])))
if self.foldArea != self.rightArrowIcon.width():
polygon = QPolygonF()
self.rightArrowIcon = QPixmap(self.foldArea, self.foldArea)
self.rightArrowIcon.fill(Qt.transparent)
self.downArrowIcon = QPixmap(self.foldArea, self.foldArea)
self.downArrowIcon.fill(Qt.transparent)
polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.25))
polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.75))
polygon.append(QPointF(self.foldArea * 0.8, self.foldArea * 0.5))
iconPainter = QPainter(self.rightArrowIcon)
iconPainter.setRenderHint(QPainter.Antialiasing)
iconPainter.setPen(Qt.NoPen)
iconPainter.setBrush(QColor(
resources.CUSTOM_SCHEME.get('fold-arrow',
resources.COLOR_SCHEME['fold-arrow'])))
iconPainter.drawPolygon(polygon)
polygon.clear()
polygon.append(QPointF(self.foldArea * 0.25, self.foldArea * 0.4))
polygon.append(QPointF(self.foldArea * 0.75, self.foldArea * 0.4))
polygon.append(QPointF(self.foldArea * 0.5, self.foldArea * 0.8))
iconPainter = QPainter(self.downArrowIcon)
iconPainter.setRenderHint(QPainter.Antialiasing)
iconPainter.setPen(Qt.NoPen)
iconPainter.setBrush(QColor(
resources.CUSTOM_SCHEME.get('fold-arrow',
resources.COLOR_SCHEME['fold-arrow'])))
iconPainter.drawPolygon(polygon)
block = self.edit.firstVisibleBlock()
while block.isValid():
position = self.edit.blockBoundingGeometry(
block).topLeft() + viewport_offset
#Check if the position of the block is outside of the visible area
if position.y() > page_bottom:
break
if pattern.match(block.text()) and block.isVisible():
if block.blockNumber() in self._foldedBlocks:
painter.drawPixmap(xofs, round(position.y()),
self.rightArrowIcon)
else:
painter.drawPixmap(xofs, round(position.y()),
self.downArrowIcon)
#Add Bookmarks and Breakpoint
elif block.blockNumber() in self._breakpoints:
linear_gradient = QLinearGradient(
xofs, round(position.y()),
xofs + self.foldArea, round(position.y()) + self.foldArea)
linear_gradient.setColorAt(0, QColor(255, 11, 11))
linear_gradient.setColorAt(1, QColor(147, 9, 9))
painter.setRenderHints(QPainter.Antialiasing, True)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(linear_gradient))
painter.drawEllipse(
xofs + 1,
round(position.y()) + 6,
self.foldArea - 1, self.foldArea - 1)
elif block.blockNumber() in self._bookmarks:
linear_gradient = QLinearGradient(
xofs, round(position.y()),
xofs + self.foldArea, round(position.y()) + self.foldArea)
linear_gradient.setColorAt(0, QColor(13, 62, 243))
linear_gradient.setColorAt(1, QColor(5, 27, 106))
painter.setRenderHints(QPainter.Antialiasing, True)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(linear_gradient))
painter.drawRoundedRect(
xofs + 1,
round(position.y()) + 6,
self.foldArea - 2, self.foldArea - 1,
3, 3)
block = block.next()
painter.end()
QWidget.paintEvent(self, event)
def setElidedText(label, text):
text = QFontMetrics(label.font()).elidedText(text, 1, label.width() - 2)
label.setText(text)
def setupTabs(self, elmerDefs, Section, ID):
"""Creates the tabs of the dynamic widget according to the elmerDefs
Args:
-----
elmerDefs: QDomDocument
contents of the Elmder efs files in xml-format
Section: str
Type of base layout
ID: int
ID of the dynamiceditor-instance
"""
self.ID = ID
self.qhash.clear()
layout = self.layout()
if (layout is not None):
item = layout.takeAt(0)
while (item != 0):
item = None
if (self.tabWidget is not None):
self.tabWidget.clear()
self.tabWidget = None
item = layout.takeAt(0)
self.layout = None
# get root element
self._root = elmerDefs.documentElement()
self.tabWidget = QtGui.QTabWidget()
self.tabWidget.setUsesScrollButtons(True)
self.tabWidget.setElideMode(QtCore.Qt.ElideNone)
self._all_stuff = self._root.firstChildElement("ALL")
self._element = self._root.firstChildElement("PDE")
self.tabs = 0
while (self._element.isNull() is False):
self._name = self._element.firstChildElement("Name")
grid = QtGui.QGridLayout()
params = 0
for x in range(0, 2):
if (x == 0):
if (str(self._name.text()).strip() == "General"):
continue
self._section = self._all_stuff.firstChildElement(Section)
else:
self._section = self._element.firstChildElement(Section)
self._param = self._section.firstChildElement("Parameter")
while (self._param.isNull() is False):
h = hash_entry_t()
# label
widget_type = self._param.attribute("Widget", "Edit")
widget_enabled = self._param.attribute("Enabled", "True")
widget_visible = self._param.attribute("Visible", "True")
paramType = str(
self._param.firstChildElement("Type").text()).strip()
labelName = str(
self._param.firstChildElement("Name").text()).strip()
sifName = str(
self._param.firstChildElement(
"SifName").text()).strip()
if (sifName == ""):
sifName = labelName
paramDefault = str(
self._param.firstChildElement(
"DefaultValue").text()).strip()
whatis = str(
self._param.firstChildElement(
"Whatis").text()).strip()
statusTip = str(
self._param.firstChildElement(
"StatusTip").text()).strip()
fullName = "/" + str(self._name.text()).strip() + "/"
fullName = fullName + Section + "/" + labelName + "/" + str(
ID)
h.widget = None
if (widget_type == "Edit"):
edit = DynLineEdit()
h.widget = edit.lineEdit
edit.lineEdit.setText(paramDefault)
edit.name = fullName
edit.lineEdit.returnPressed.connect(edit.editSlot)
edit.lineEdit.textChanged.connect(
self._textChangedSlot)
elif (widget_type == "TextEdit"):
textEdit = QtGui.QTextEdit()
currentFont = textEdit.currentFont()
fontMetrics = QFontMetrics(currentFont)
fontHeight = fontMetrics.height()
textEdit.setMinimumHeight(5 * fontHeight)
textEdit.setMaximumHeight(8 * fontHeight)
h.widget = textEdit
elif (widget_type == "Combo"):
combo = QtGui.QComboBox()
h.widget = combo
count = 0
active = 0
item = self._param.firstChildElement("Item")
while (item.isNull() is False):
itemType = item.attribute("Type", "")
if (itemType == "Active"):
active = count
itemName = item.firstChildElement("Name")
count += 1
combo.insertItem(count,
str(itemName.text()).strip())
item = item.nextSiblingElement("Item")
combo.setCurrentIndex(active)
combo.currentIndexChanged.connect(self._comboSlot)
elif (widget_type == "CheckBox"):
l = QtGui.QCheckBox()
h.widget = l
l.setText("")
l.setChecked(False)
if (paramDefault == "True"):
l.setChecked(True)
l.stateChanged.connect(self._lSlot)
elif (widget_type == "Label"):
label = QtGui.QLabel()
font = QFont()
font.setBold(True)
font.setUnderline(True)
label.setFont(font)
label.setText(labelName)
h.widget = label
if (h.widget):
h.widget.setWhatsThis(whatis)
h.widget.setStatusTip(statusTip)
h.widget.setProperty("dom address", fullName)
h.elem = self._param
if (widget_enabled == "False"):
h.widget.setEnabled(False)
if (widget_type != "TextEdit"):
h.widget.setFixedHeight(18)
if (widget_type == "TextEdit"):
textEditLabel = QtGui.QLabel()
textEditLabel.setText(labelName)
h.label = textEditLabel
grid.addWidget(h.widget, params, 0, 1, 2)
if (widget_visible == "False"):
h.label.hide()
h.widget.hide()
elif (widget_type != "Label"):
label = QtGui.QLabel()
label.setText(labelName)
h.label = label
grid.addWidget(h.label, params, 0)
grid.addWidget(h.widget, params, 1)
if (widget_visible == "False"):
h.label.hide()
h.widget.hide()
else:
h.label = None
grid.addWidget(h.widget, params, 0)
self.qhash.update({fullName: h})
self._param = self._param.nextSiblingElement("Parameter")
params += 1
dummyWidget = QtGui.QWidget()
grid.addWidget(dummyWidget, params, 0)
grid.setRowStretch(params, 1)
frmWidget = QtGui.QWidget()
frmWidget.setLayout(grid)
src = QtGui.QScrollArea()
src.setWidget(frmWidget)
src.setMinimumHeight(300)
src.setWidgetResizable(True)
if (params > 0):
self.tabWidget.addTab(src, str(self._name.text()).strip())
self.tabs += 1
self._element = self._element.nextSiblingElement("PDE")
# Buttons:
lbl = QtGui.QLabel()
lbl.setText("Name:")
self.nameEdit = QtGui.QLineEdit()
self.nameEdit.setText(Section + " " + str(ID + 1))
self.applyButton = QtGui.QPushButton("&Apply")
# applyButton.setIcon(addIcon)
self.applyButton.clicked.connect(self._applyButtonClicked)
self.discardButton = QtGui.QPushButton("&Remove")
# discardButton.setIcon(removeIcon)
self.discardButton.clicked.connect(self._discardButtonClicked)
self.okButton = QtGui.QPushButton("&OK")
# okButton.setIcon(okIcon)
self.okButton.clicked.connect(self._okButtonClicked)
self.newButton = QtGui.QPushButton("&New")
# self.newButton.setIcon(newIcon)
self.newButton.clicked.connect(self._newButtonClicked)
nameLayout = QtGui.QHBoxLayout()
nameLayout.addWidget(lbl)
nameLayout.addWidget(self.nameEdit)
buttonLayout = QtGui.QHBoxLayout()
buttonLayout.addWidget(self.newButton)
buttonLayout.addWidget(self.applyButton)
buttonLayout.addWidget(self.okButton)
buttonLayout.addWidget(self.discardButton)
spareButtonLayout = QtGui.QHBoxLayout()
self.spareButton = QtGui.QPushButton("SpareButton")
self.spareButton.setVisible(False)
spareButtonLayout.addWidget(self.spareButton)
self.spareButton.clicked.connect(self._spareButtonClicked)
self.spareScroll = QtGui.QScrollArea()
self.spareScroll.hide()
mainLayout = QtGui.QVBoxLayout()
mainLayout.addWidget(self.tabWidget)
mainLayout.addWidget(self.spareScroll)
mainLayout.addLayout(spareButtonLayout)
mainLayout.addLayout(nameLayout)
mainLayout.addLayout(buttonLayout)
self.setLayout(mainLayout)
self.setWindowTitle(Section)
def sizeHint(self):
fm = QFontMetrics(self.font())
return QSize(self._movieWidth + 6 + fm.width(self._text),
self._movieHeight)
def setBadgeFont( self, font ):
" Sets the badge font "
self.badgeFont = font
self.badgeFontMetrics = QFontMetrics( self.badgeFont,
self.__paintDevice )
return
def __paintEventNoStyle(self):
p = QPainter(self)
opt = QStyleOptionToolButton()
self.initStyleOption(opt)
fm = QFontMetrics(opt.font)
palette = opt.palette
# highlight brush is used as the background for the icon and background
# when the tab is expanded and as mouse hover color (lighter).
brush_highlight = palette.highlight()
if opt.state & QStyle.State_Sunken:
# State 'down' pressed during a mouse press (slightly darker).
background_brush = brush_darker(brush_highlight, 110)
elif opt.state & QStyle.State_MouseOver:
background_brush = brush_darker(brush_highlight, 95)
elif opt.state & QStyle.State_On:
background_brush = brush_highlight
else:
# The default button brush.
background_brush = palette.button()
rect = opt.rect
icon = opt.icon
icon_size = opt.iconSize
# TODO: add shift for pressed as set by the style (PM_ButtonShift...)
pm = None
if not icon.isNull():
if opt.state & QStyle.State_Enabled:
mode = QIcon.Normal
else:
mode = QIcon.Disabled
pm = opt.icon.pixmap(
rect.size().boundedTo(icon_size), mode,
QIcon.On if opt.state & QStyle.State_On else QIcon.Off)
icon_area_rect = QRect(rect)
icon_area_rect.setRight(int(icon_area_rect.height() * 1.26))
text_rect = QRect(rect)
text_rect.setLeft(icon_area_rect.right() + 10)
# Background (TODO: Should the tab button have native
# toolbutton shape, drawn using PE_PanelButtonTool or even
# QToolBox tab shape)
# Default outline pen
pen = QPen(palette.color(QPalette.Mid))
p.save()
p.setPen(Qt.NoPen)
p.setBrush(QBrush(background_brush))
p.drawRect(rect)
# Draw the background behind the icon if the background_brush
# is different.
if not opt.state & QStyle.State_On:
p.setBrush(brush_highlight)
p.drawRect(icon_area_rect)
# Line between the icon and text
p.setPen(pen)
p.drawLine(icon_area_rect.topRight(), icon_area_rect.bottomRight())
if opt.state & QStyle.State_HasFocus:
# Set the focus frame pen and draw the border
pen = QPen(QColor(FOCUS_OUTLINE_COLOR))
p.setPen(pen)
p.setBrush(Qt.NoBrush)
# Adjust for pen
rect = rect.adjusted(0, 0, -1, -1)
p.drawRect(rect)
else:
p.setPen(pen)
# Draw the top/bottom border
if self.position == QStyleOptionToolBoxV2.OnlyOneTab or \
self.position == QStyleOptionToolBoxV2.Beginning or \
self.selected & \
QStyleOptionToolBoxV2.PreviousIsSelected:
p.drawLine(rect.topLeft(), rect.topRight())
p.drawLine(rect.bottomLeft(), rect.bottomRight())
p.restore()
p.save()
text = fm.elidedText(opt.text, Qt.ElideRight, text_rect.width())
p.setPen(QPen(palette.color(QPalette.ButtonText)))
p.setFont(opt.font)
p.drawText(text_rect,
int(Qt.AlignVCenter | Qt.AlignLeft) | \
int(Qt.TextSingleLine),
text)
if pm:
pm_rect = QRect(QPoint(0, 0), pm.size())
centered_rect = QRect(pm_rect)
centered_rect.moveCenter(icon_area_rect.center())
p.drawPixmap(centered_rect, pm, pm_rect)
p.restore()
def setDisplayFontSize(self, size):
self._font.setPointSize(size)
self._square = max(24, QFontMetrics(self._font).xHeight() * 3)
self.adjustSize()
self.update()
def sizeHint(self):
metrics = QFontMetrics(self.font())
rect = metrics.boundingRect(self.text())
size = QSize(rect.height() + self.margin(),
rect.width() + self.margin())
return size
def true_height(node=None):
"""Calculates the UI height for all node types, due to a bug in NUKE
which evaluates to zero for height upon node creation or in non-UI
modes. By convention, height and width are represented by h and w
"""
node_class = node.Class()
# ------------------- Size Determined by Prefs ------------------------- #
# the UI Prefs determine the size of dots directly:
if node_class in DOTS:
return utils.pref('dot_node_scale') * 12
# TileWidth is the driving preference for round "3D" nodes
elif node_class in THREE_DS:
tile_w = utils.pref('TileWidth')
three_d_w = int(float(tile_w) * (3.0 / 4.0))
three_d_h = three_d_w if three_d_w % 2 == 0 else (three_d_w + 1)
return three_d_h
# ------------------- Size Determined by Labels ------------------------ #
# All other nodes can be determined via screenheight + labels
screen_h = node.screenHeight()
# If the node is a note-type, screenheight will suffice
if node_class in NOTES:
return screen_h
# If the node is returning a value greater than the default, then we
# assume that the call was made after node creation, unless the node
# happens to be one of the classes which add a postage stamp
# by default.
tile_h = utils.pref('TileHeight')
if screen_h - tile_h > 3 and node_class not in AUTO_POSTAGES:
return screen_h
# all other nodes, we need to do the work to add up the base height
# to any labels that are included
base_h = screen_h if screen_h else tile_h
# each line of text in the label will have a height determined by:
# * font size in pixels
# * a one-pixel buffer
try:
font_size = node['note_font_size'].getValue()
except NameError:
font_size = utils.pref('UIFontSize')
try:
font_name = node['note_font'].value()
except NameError:
font_name = utils.pref('UIFont')
else:
# due to a bug in previous versions of NUKE, occassionally our
# font names got corrupted by adding 'Bold' to the font name
while font_name.endswith('Bold Bold'):
font_name = ' '.join(font_name.split(' ')[-1])
# because the node might use a font other than the default, we have
# to get the font-size in pixels using PyQt
font = QFont(font_name, font_size)
ui_font_h = QFontMetrics(font).height()
padding_per_line = ui_font_h + 1
# the full label will include the user notes and any autolabel lines
full_label = nuke.runIn(node.fullName(), 'nuke.autolabel()')
lines = full_label.split('\n')
added_h = padding_per_line * (len(lines) - 1)
# ------------------- Postage Stamp Sizes ------------------------------ #
# postage stamps add height in relation to the width of the node
try:
has_postage_stamp = node['postage_stamp'].value()
except NameError:
return base_h + added_h
else:
if not has_postage_stamp:
return base_h + added_h
# Only add the postage stamp size if it has been added manually
if node_class not in AUTO_POSTAGES:
tile_w = utils.pref('TileWidth')
added_h += (int(float(tile_w) / sqrt(3)) + 2)
return base_h + added_h
def __init__(self, idx):
object.__init__(self)
self.idx = idx
# Default theme settings
# Canvas
self.canvas_bg = QColor(0, 0, 0)
# Boxes
self.box_pen = QPen(QColor(143 - 70, 143 - 70, 143 - 70), 1,
Qt.SolidLine)
self.box_pen_sel = QPen(QColor(143, 143, 143), 1, Qt.CustomDashLine,
Qt.RoundCap)
self.box_pen_sel.setDashPattern([3, 4])
self.box_bg_1 = QColor(30, 34, 36)
self.box_bg_2 = QColor(30, 34, 36)
self.box_shadow = QColor(89, 89, 89, 180)
self.box_hover = QColor(255, 255, 255, 60)
self.box_header_pixmap = None
self.box_header_height = 19
self.box_header_spacing = 0
self.box_rounding = 0.0
self.box_bottom_space = 3
self.box_text = QPen(QColor(255, 255, 255), 0)
self.box_text_sel = self.box_text
self.box_font_name = "Sans"
self.box_font_size = 9
self.box_font_state = QFont.Normal
self.box_bg_type = self.THEME_BG_GRADIENT
self.box_use_icon = False
# Ports
self.port_text = QPen(QColor(250, 250, 250, 150), 0)
self.port_hover = QColor(255, 255, 255, 150)
self.port_bg_pixmap = None
self.port_font_name = "Sans"
self.port_font_size = 8
self.port_font_state = QFont.Normal
self.port_mode = self.THEME_PORT_SQUARE
self.port_audio_jack_bg = hsvAdjusted(QColor(41, 61, 99),
saturation=120)
self.port_audio_jack_bg_sel = QColor(255, 0, 0)
self.port_midi_jack_bg = hsvAdjusted(QColor(120, 15, 16),
saturation=150)
self.port_midi_jack_bg_sel = QColor(255, 0, 0)
self.port_midi_a2j_bg = hsvAdjusted(QColor(101, 47, 17),
saturation=150)
self.port_midi_a2j_bg_sel = QColor(255, 0, 0)
self.port_midi_alsa_bg = hsvAdjusted(QColor(63, 112, 19),
saturation=120)
self.port_midi_alsa_bg_sel = QColor(255, 0, 0)
port_pen = QPen(QColor(255, 255, 255, 50), 1)
self.port_audio_jack_pen_sel = self.port_audio_jack_pen = QPen(
hsvAdjustedRel(self.port_audio_jack_bg.lighter(180),
saturation=-60), 1)
self.port_midi_jack_pen_sel = self.port_midi_jack_pen = QPen(
hsvAdjustedRel(self.port_midi_jack_bg.lighter(180),
saturation=-60), 1)
self.port_midi_a2j_pen_sel = self.port_midi_a2j_pen = QPen(
hsvAdjustedRel(self.port_midi_a2j_bg.lighter(180), saturation=-60),
1)
self.port_midi_alsa_pen_sel = self.port_midi_alsa_pen = QPen(
hsvAdjustedRel(self.port_midi_alsa_bg.lighter(180),
saturation=-60), 1)
self.port_audio_jack_text = self.port_audio_jack_pen_sel
self.port_audio_jack_text_sel = self.port_audio_jack_pen_sel
self.port_midi_jack_text = self.port_midi_jack_pen_sel
self.port_midi_jack_text_sel = self.port_midi_jack_pen_sel
self.port_midi_a2j_text = self.port_midi_a2j_pen_sel
self.port_midi_a2j_text_sel = self.port_midi_a2j_pen_sel
self.port_midi_alsa_text = self.port_midi_alsa_pen_sel
self.port_midi_alsa_text_sel = self.port_midi_alsa_pen_sel
self.port_text_padding = 0
self.port_offset = 0
self.port_spacing = 1
self.port_spacingT = 0
self.port_rounding = 0.0
self.port_inglow_alpha = 0
self.port_inglow_size = 0
self.port_side_min_space = 3
# Lines
self.line_audio_jack = QColor(53, 78, 116)
self.line_audio_jack_sel = QColor(255, 0, 0)
self.line_audio_jack_glow = QColor(255, 0, 0)
self.line_midi_jack = QColor(139, 32, 32)
self.line_midi_jack_sel = QColor(255, 0, 0)
self.line_midi_jack_glow = QColor(255, 0, 0)
self.line_midi_a2j = QColor(120, 65, 33)
self.line_midi_a2j_sel = QColor(255, 0, 0)
self.line_midi_a2j_glow = QColor(255, 0, 0)
self.line_midi_alsa = QColor(81, 130, 36)
self.line_midi_alsa_sel = QColor(255, 0, 0)
self.line_midi_alsa_glow = QColor(255, 0, 0)
self.rubberband_pen = QPen(QColor(147, 151, 143), 1, Qt.SolidLine)
self.rubberband_brush = QColor(35, 61, 99, 100)
if idx == self.THEME_MODERN_DARK:
# Canvas
self.canvas_bg = QColor(0, 0, 0)
# Boxes
self.box_pen = QPen(QColor(76, 77, 78), 1, Qt.SolidLine)
self.box_pen_sel = QPen(QColor(206, 207, 208), 1, Qt.DashLine)
self.box_bg_1 = QColor(32, 34, 35)
self.box_bg_2 = QColor(43, 47, 48)
self.box_shadow = QColor(89, 89, 89, 180)
self.box_hover = QColor(255, 255, 255, 60)
self.box_header_pixmap = None
self.box_header_height = 24
self.box_header_spacing = 0
self.box_rounding = 3.0
self.box_bottom_space = 3
self.box_text = QPen(QColor(240, 240, 240), 0)
self.box_text_sel = self.box_text
self.box_font_name = "Deja Vu Sans"
self.box_font_size = 8
self.box_font_state = QFont.Bold
self.box_bg_type = self.THEME_BG_GRADIENT
self.box_use_icon = True
# Ports
self.port_text = QPen(QColor(250, 250, 250, 180), 0)
self.port_hover = QColor(255, 255, 255, 80)
self.port_bg_pixmap = None
self.port_font_name = "Deja Vu Sans"
self.port_font_size = 8
self.port_font_state = QFont.Normal
self.port_mode = self.THEME_PORT_POLYGON
self.port_audio_jack_pen = QPen(QColor(63, 90, 126), 1)
self.port_audio_jack_pen_sel = QPen(
QColor(63 + 30, 90 + 30, 126 + 30), 1)
self.port_midi_jack_pen = QPen(QColor(159, 44, 42), 1)
self.port_midi_jack_pen_sel = QPen(
QColor(159 + 30, 44 + 30, 42 + 30), 1)
self.port_midi_a2j_pen = QPen(QColor(137, 76, 43), 1)
self.port_midi_a2j_pen_sel = QPen(
QColor(137 + 30, 76 + 30, 43 + 30), 1)
self.port_midi_alsa_pen = QPen(QColor(93, 141, 46), 1)
self.port_midi_alsa_pen_sel = QPen(
QColor(93 + 30, 141 + 30, 46 + 30), 1)
self.port_audio_jack_bg = QColor(35, 61, 99)
self.port_audio_jack_bg_sel = QColor(35 + 50, 61 + 50, 99 + 50)
self.port_midi_jack_bg = QColor(120, 15, 16)
self.port_midi_jack_bg_sel = QColor(120 + 50, 15 + 50, 16 + 50)
self.port_midi_a2j_bg = QColor(101, 47, 16)
self.port_midi_a2j_bg_sel = QColor(101 + 50, 47 + 50, 16 + 50)
self.port_midi_alsa_bg = QColor(64, 112, 18)
self.port_midi_alsa_bg_sel = QColor(64 + 50, 112 + 50, 18 + 50)
self.port_audio_jack_text = self.port_text
self.port_audio_jack_text_sel = self.port_text
self.port_midi_jack_text = self.port_text
self.port_midi_jack_text_sel = self.port_text
self.port_midi_a2j_text = self.port_text
self.port_midi_a2j_text_sel = self.port_text
self.port_midi_alsa_text = self.port_text
self.port_midi_alsa_text_sel = self.port_text
self.port_text_padding = 1
self.port_offset = 0
self.port_spacing = 3
self.port_spacingT = 2
self.port_rounding = 0.0
# To not scale some line widths
self.box_pen.setCosmetic(True)
self.box_pen_sel.setCosmetic(True)
self.port_audio_jack_pen.setCosmetic(True)
self.port_audio_jack_pen_sel.setCosmetic(True)
self.port_midi_jack_pen.setCosmetic(True)
self.port_midi_jack_pen_sel.setCosmetic(True)
self.port_midi_a2j_pen.setCosmetic(True)
self.port_midi_a2j_pen_sel.setCosmetic(True)
self.port_midi_alsa_pen.setCosmetic(True)
self.port_midi_alsa_pen_sel.setCosmetic(True)
# Lines
self.line_audio_jack = QColor(63, 90, 126)
self.line_audio_jack_sel = QColor(63 + 90, 90 + 90, 126 + 90)
self.line_audio_jack_glow = QColor(100, 100, 200)
self.line_midi_jack = QColor(159, 44, 42)
self.line_midi_jack_sel = QColor(159 + 90, 44 + 90, 42 + 90)
self.line_midi_jack_glow = QColor(200, 100, 100)
self.line_midi_a2j = QColor(137, 76, 43)
self.line_midi_a2j_sel = QColor(137 + 90, 76 + 90, 43 + 90)
self.line_midi_a2j_glow = QColor(166, 133, 133)
self.line_midi_alsa = QColor(93, 141, 46)
self.line_midi_alsa_sel = QColor(93 + 90, 141 + 90, 46 + 90)
self.line_midi_alsa_glow = QColor(100, 200, 100)
self.rubberband_pen = QPen(QColor(206, 207, 208), 1, Qt.SolidLine)
self.rubberband_brush = QColor(76, 77, 78, 100)
elif idx == self.THEME_MODERN_DARK_TINY:
# Canvas
self.canvas_bg = QColor(0, 0, 0)
# Boxes
self.box_pen = QPen(QColor(76, 77, 78), 1, Qt.SolidLine)
self.box_pen_sel = QPen(QColor(206, 207, 208), 1, Qt.DashLine)
self.box_bg_1 = QColor(32, 34, 35)
self.box_bg_2 = QColor(43, 47, 48)
self.box_shadow = QColor(89, 89, 89, 180)
self.box_hover = QColor(255, 255, 255, 60)
self.box_header_pixmap = None
self.box_header_height = 14
self.box_header_spacing = 0
self.box_rounding = 2.0
self.box_bottom_space = 2
self.box_text = QPen(QColor(240, 240, 240), 0)
self.box_text_sel = self.box_text
self.box_font_name = "Deja Vu Sans"
self.box_font_size = 7
self.box_font_state = QFont.Bold
self.box_bg_type = self.THEME_BG_GRADIENT
self.box_use_icon = False
# Ports
self.port_text = QPen(QColor(250, 250, 250, 220), 0)
self.port_hover = QColor(255, 255, 255, 80)
self.port_bg_pixmap = None
self.port_font_name = "Deja Vu Sans"
self.port_font_size = 6
self.port_font_state = QFont.Normal
self.port_mode = self.THEME_PORT_POLYGON
self.port_audio_jack_pen = QPen(QColor(63, 90, 126), 1)
self.port_audio_jack_pen_sel = QPen(
QColor(63 + 30, 90 + 30, 126 + 30), 1)
self.port_midi_jack_pen = QPen(QColor(159, 44, 42), 1)
self.port_midi_jack_pen_sel = QPen(
QColor(159 + 30, 44 + 30, 42 + 30), 1)
self.port_midi_a2j_pen = QPen(QColor(137, 76, 43), 1)
self.port_midi_a2j_pen_sel = QPen(
QColor(137 + 30, 76 + 30, 43 + 30), 1)
self.port_midi_alsa_pen = QPen(QColor(93, 141, 46), 1)
self.port_midi_alsa_pen_sel = QPen(
QColor(93 + 30, 141 + 30, 46 + 30), 1)
self.port_audio_jack_bg = QColor(35, 61, 99)
self.port_audio_jack_bg_sel = QColor(35 + 50, 61 + 50, 99 + 50)
self.port_midi_jack_bg = QColor(120, 15, 16)
self.port_midi_jack_bg_sel = QColor(120 + 50, 15 + 50, 16 + 50)
self.port_midi_a2j_bg = QColor(101, 47, 16)
self.port_midi_a2j_bg_sel = QColor(101 + 50, 47 + 50, 16 + 50)
self.port_midi_alsa_bg = QColor(64, 112, 18)
self.port_midi_alsa_bg_sel = QColor(64 + 50, 112 + 50, 18 + 50)
self.port_audio_jack_text = self.port_text
self.port_audio_jack_text_sel = self.port_text
self.port_midi_jack_text = self.port_text
self.port_midi_jack_text_sel = self.port_text
self.port_midi_a2j_text = self.port_text
self.port_midi_a2j_text_sel = self.port_text
self.port_midi_alsa_text = self.port_text
self.port_midi_alsa_text_sel = self.port_text
self.port_text_padding = 1
self.port_offset = 0
self.port_spacing = -1
self.port_spacingT = 2
self.port_rounding = 0.0
# To not scale some line widths
self.box_pen.setCosmetic(True)
self.box_pen_sel.setCosmetic(True)
self.port_audio_jack_pen.setCosmetic(True)
self.port_audio_jack_pen_sel.setCosmetic(True)
self.port_midi_jack_pen.setCosmetic(True)
self.port_midi_jack_pen_sel.setCosmetic(True)
self.port_midi_a2j_pen.setCosmetic(True)
self.port_midi_a2j_pen_sel.setCosmetic(True)
self.port_midi_alsa_pen.setCosmetic(True)
self.port_midi_alsa_pen_sel.setCosmetic(True)
# Lines
self.line_audio_jack = QColor(63, 90, 126)
self.line_audio_jack_sel = QColor(63 + 90, 90 + 90, 126 + 90)
self.line_audio_jack_glow = QColor(100, 100, 200)
self.line_midi_jack = QColor(159, 44, 42)
self.line_midi_jack_sel = QColor(159 + 90, 44 + 90, 42 + 90)
self.line_midi_jack_glow = QColor(200, 100, 100)
self.line_midi_a2j = QColor(137, 76, 43)
self.line_midi_a2j_sel = QColor(137 + 90, 76 + 90, 43 + 90)
self.line_midi_a2j_glow = QColor(166, 133, 133)
self.line_midi_alsa = QColor(93, 141, 46)
self.line_midi_alsa_sel = QColor(93 + 90, 141 + 90, 46 + 90)
self.line_midi_alsa_glow = QColor(100, 200, 100)
self.rubberband_pen = QPen(QColor(206, 207, 208), 1, Qt.SolidLine)
self.rubberband_brush = QColor(76, 77, 78, 100)
if idx == self.THEME_MODERN_DARK_TEXT:
# Canvas
self.canvas_bg = QColor(0, 0, 0)
# Boxes
self.box_pen = QPen(QColor(76, 77, 78), 1, Qt.SolidLine)
self.box_pen_sel = QPen(QColor(206, 207, 208), 1, Qt.DashLine)
self.box_bg_1 = QColor(15, 15, 15)
self.box_bg_2 = self.box_bg_1
self.box_shadow = QColor(89, 89, 89, 180)
self.box_hover = QColor(255, 255, 255, 60)
self.box_header_pixmap = None
self.box_header_height = 14
self.box_header_spacing = 0
self.box_rounding = 3.0
self.box_bottom_space = 3
self.box_text = QPen(QColor(240, 240, 240), 0)
self.box_text_sel = self.box_text
self.box_font_name = "Deja Vu Sans"
self.box_font_size = 7
self.box_font_state = QFont.Bold
self.box_bg_type = self.THEME_BG_SOLID
self.box_use_icon = False
# Ports
self.port_text = QPen(QColor(250, 250, 250, 180), 1)
self.port_hover = QColor(255, 255, 255, 40)
self.port_bg_pixmap = None
self.port_font_name = "Deja Vu Sans"
self.port_font_size = 6
self.port_font_state = QFont.Normal
self.port_mode = self.THEME_PORT_SQUARE
self.port_audio_jack_pen = Qt.NoPen
self.port_audio_jack_pen_sel = Qt.NoPen
self.port_midi_jack_pen = Qt.NoPen
self.port_midi_jack_pen_sel = Qt.NoPen
self.port_midi_a2j_pen = Qt.NoPen
self.port_midi_a2j_pen_sel = Qt.NoPen
self.port_midi_alsa_pen = Qt.NoPen
self.port_midi_alsa_pen_sel = Qt.NoPen
self.port_audio_jack_bg = QColor(0, 0, 0, 0)
self.port_midi_jack_bg = QColor(0, 0, 0, 0)
self.port_midi_a2j_bg = QColor(0, 0, 0, 0)
self.port_midi_alsa_bg = QColor(0, 0, 0, 0)
self.port_audio_jack_bg_sel = QColor(60, 71, 99)
self.port_midi_jack_bg_sel = QColor(120, 70, 70)
self.port_midi_a2j_bg_sel = QColor(120, 80, 60)
self.port_midi_alsa_bg_sel = QColor(64, 112, 48)
self.port_audio_jack_text = QPen(
hsvAdjusted(QColor(63, 90, 126), value=255), 1)
self.port_midi_jack_text = QPen(
hsvAdjusted(QColor(159, 44, 42), value=255), 1)
self.port_midi_a2j_text = QPen(
hsvAdjusted(QColor(137, 76, 43), value=255), 1)
self.port_midi_alsa_text = QPen(
hsvAdjusted(QColor(93, 141, 46), value=255), 1)
self.port_audio_jack_text_sel = QPen(
self.port_audio_jack_text.color().lighter(130), 1)
self.port_midi_jack_text_sel = QPen(
self.port_midi_jack_text.color().lighter(150), 1)
self.port_midi_a2j_text_sel = QPen(
self.port_midi_a2j_text.color().lighter(150), 1)
self.port_midi_alsa_text_sel = QPen(
self.port_midi_alsa_text.color().lighter(150), 1)
self.port_text_padding = 0
self.port_offset = 0
self.port_spacing = 0
self.port_spacingT = 2
self.port_rounding = 6.0
# Lines
self.line_audio_jack = QColor(63, 90, 126)
self.line_audio_jack_sel = QColor(63 + 90, 90 + 90, 126 + 90)
self.line_audio_jack_glow = QColor(100, 100, 200)
self.line_midi_jack = QColor(159, 44, 42)
self.line_midi_jack_sel = QColor(159 + 90, 44 + 90, 42 + 90)
self.line_midi_jack_glow = QColor(200, 100, 100)
self.line_midi_a2j = QColor(137, 76, 43)
self.line_midi_a2j_sel = QColor(137 + 90, 76 + 90, 43 + 90)
self.line_midi_a2j_glow = QColor(166, 133, 133)
self.line_midi_alsa = QColor(93, 141, 46)
self.line_midi_alsa_sel = QColor(93 + 90, 141 + 90, 46 + 90)
self.line_midi_alsa_glow = QColor(100, 200, 100)
self.rubberband_pen = QPen(QColor(206, 207, 208), 1, Qt.SolidLine)
self.rubberband_brush = QColor(76, 77, 78, 100)
elif idx == self.THEME_MODERN_LIGHT:
# Canvas
self.canvas_bg = QColor(248, 249, 250)
# Boxes
self.box_pen = QPen(QColor(0, 0, 0, 60), 1, Qt.SolidLine)
self.box_pen_sel = QPen(QColor(1, 2, 3), 2, Qt.DashLine)
self.box_bg_1 = QColor(220, 220, 220)
self.box_bg_2 = self.box_bg_1.darker(120)
self.box_shadow = QColor(1, 1, 1, 100)
self.box_hover = QColor(0, 0, 0, 60)
self.box_header_pixmap = None
self.box_header_height = 24
self.box_header_spacing = 0
self.box_rounding = 3.0
self.box_bottom_space = 3
self.box_text = QPen(QColor(1, 1, 1), 0)
self.box_text_sel = self.box_text
self.box_font_name = "Ubuntu"
self.box_font_size = 10
self.box_font_state = QFont.Bold
self.box_bg_type = self.THEME_BG_GRADIENT
self.box_use_icon = True
# Ports
self.port_text = QPen(QColor(255, 255, 255, 220), 1)
self.port_hover = QColor(0, 0, 0, 255)
self.port_bg_pixmap = None
self.port_font_name = "Ubuntu"
self.port_font_size = 9
self.port_font_state = QFont.Bold
self.port_mode = self.THEME_PORT_POLYGON
# Port colors
port_audio_jack_color = QColor.fromHsv(240, 214, 181)
port_midi_jack_color = QColor.fromHsv(0, 214, 130)
port_midi_a2j_color = QColor.fromHsv(22, 214, 102)
port_midi_alsa_color = QColor.fromHsv(91, 214, 112)
port_lineW = 1
port_pen_shade = 130
self.port_audio_jack_pen = QPen(
port_audio_jack_color.darker(port_pen_shade), port_lineW)
self.port_midi_jack_pen = QPen(
port_midi_jack_color.darker(port_pen_shade), port_lineW)
self.port_midi_a2j_pen = QPen(
port_midi_a2j_color.darker(port_pen_shade), port_lineW)
self.port_midi_alsa_pen = QPen(
port_midi_alsa_color.darker(port_pen_shade), port_lineW)
port_selW = 1.5
self.port_audio_jack_pen_sel = QPen(
port_audio_jack_color.lighter(port_pen_shade), port_selW)
self.port_midi_jack_pen_sel = QPen(
port_midi_jack_color.lighter(port_pen_shade), port_selW)
self.port_midi_a2j_pen_sel = QPen(
port_midi_a2j_color.lighter(port_pen_shade), port_selW)
self.port_midi_alsa_pen_sel = QPen(
port_midi_alsa_color.lighter(port_pen_shade), port_selW)
port_bg_shade = 170
self.port_audio_jack_bg = port_audio_jack_color
self.port_midi_jack_bg = port_midi_jack_color
self.port_midi_a2j_bg = port_midi_a2j_color
self.port_midi_alsa_bg = port_midi_alsa_color
self.port_audio_jack_bg_sel = hsvAdjustedRel(
self.port_audio_jack_bg, saturation=-80).lighter(130)
self.port_midi_jack_bg_sel = hsvAdjustedRel(
self.port_midi_jack_bg, saturation=-80).lighter(130)
self.port_midi_a2j_bg_sel = hsvAdjustedRel(
self.port_midi_a2j_bg, saturation=-80).lighter(130)
self.port_midi_alsa_bg_sel = hsvAdjustedRel(
self.port_midi_alsa_bg, saturation=-80).lighter(130)
self.port_audio_jack_text = QPen(
hsvAdjustedRel(port_audio_jack_color,
hue=-30,
saturation=-70,
value=70), 1)
self.port_midi_jack_text = QPen(
hsvAdjustedRel(port_midi_jack_color,
hue=10,
saturation=-70,
value=70), 1)
self.port_midi_a2j_text = QPen(
hsvAdjustedRel(port_midi_a2j_color,
hue=8,
saturation=-70,
value=70), 1)
self.port_midi_alsa_text = QPen(
hsvAdjustedRel(port_midi_alsa_color,
hue=-8,
saturation=-70,
value=70), 1)
self.port_audio_jack_text_sel = self.port_text
self.port_midi_jack_text_sel = self.port_text
self.port_midi_a2j_text_sel = self.port_text
self.port_midi_alsa_text_sel = self.port_text
self.port_text_padding = 0.5
self.port_offset = 0
self.port_spacing = 2
self.port_spacingT = 1
self.port_rounding = 0.0
# To not scale some line widths
self.box_pen.setCosmetic(True)
self.box_pen_sel.setCosmetic(True)
self.port_audio_jack_pen.setCosmetic(True)
self.port_audio_jack_pen_sel.setCosmetic(True)
self.port_midi_jack_pen.setCosmetic(True)
self.port_midi_jack_pen_sel.setCosmetic(True)
self.port_midi_a2j_pen.setCosmetic(True)
self.port_midi_a2j_pen_sel.setCosmetic(True)
self.port_midi_alsa_pen.setCosmetic(True)
self.port_midi_alsa_pen_sel.setCosmetic(True)
# Lines
self.line_audio_jack = QColor(63, 90, 126)
self.line_audio_jack_sel = QColor(63 + 63, 90 + 90, 126 + 90)
self.line_audio_jack_glow = QColor(100, 100, 200)
self.line_midi_jack = QColor(159, 44, 42)
self.line_midi_jack_sel = QColor(159 + 44, 44 + 90, 42 + 90)
self.line_midi_jack_glow = QColor(200, 100, 100)
self.line_midi_a2j = QColor(137, 43, 43)
self.line_midi_a2j_sel = QColor(137 + 90, 76 + 90, 43 + 90)
self.line_midi_a2j_glow = QColor(166, 133, 133)
self.line_midi_alsa = QColor(93, 141, 46)
self.line_midi_alsa_sel = QColor(93 + 90, 141 + 90, 46 + 90)
self.line_midi_alsa_glow = QColor(100, 200, 100)
self.rubberband_pen = QPen(QColor(76, 77, 78, 130), 1,
Qt.SolidLine)
self.rubberband_brush = QColor(76, 77, 78, 100)
elif idx == self.THEME_CLASSIC_DARK:
# Canvas
self.canvas_bg = QColor(0, 0, 0)
# Boxes
self.box_pen = QPen(QColor(143 - 70, 143 - 70, 143 - 70), 2,
Qt.SolidLine)
self.box_pen_sel = QPen(QColor(143, 143, 143), 2,
Qt.CustomDashLine, Qt.RoundCap)
self.box_pen_sel.setDashPattern([1.5, 3])
self.box_bg_1 = QColor(30, 34, 36)
self.box_bg_2 = QColor(30, 34, 36)
self.box_shadow = QColor(89, 89, 89, 180)
self.box_hover = QColor(255, 255, 255, 60)
self.box_header_pixmap = None
self.box_header_height = 19
self.box_header_spacing = 0
self.box_rounding = 0
self.box_bottom_space = 3
self.box_text = QPen(QColor(255, 255, 255), 0)
self.box_text_sel = self.box_text
self.box_font_name = "Sans"
self.box_font_size = 9
self.box_font_state = QFont.Normal
self.box_bg_type = self.THEME_BG_GRADIENT
self.box_use_icon = False
# Ports
self.port_text = QPen(QColor(250, 250, 250), 0)
self.port_hover = QColor(255, 255, 255, 80)
self.port_bg_pixmap = None
self.port_font_name = "Sans"
self.port_font_size = 8
self.port_font_state = QFont.Normal
self.port_mode = self.THEME_PORT_SQUARE
port_pen = Qt.NoPen
self.port_audio_jack_pen = port_pen
self.port_midi_jack_pen = port_pen
self.port_midi_a2j_pen = port_pen
self.port_midi_alsa_pen = port_pen
self.port_audio_jack_pen_sel = port_pen
self.port_midi_jack_pen_sel = port_pen
self.port_midi_a2j_pen_sel = port_pen
self.port_midi_alsa_pen_sel = port_pen
self.port_audio_jack_bg = QColor(35, 61, 99)
self.port_midi_jack_bg = QColor(120, 15, 16)
self.port_midi_a2j_bg = QColor(101, 47, 17)
self.port_midi_alsa_bg = QColor(63, 112, 19)
self.port_audio_jack_bg_sel = hsvAdjustedRel(
self.port_audio_jack_bg.lighter(150), saturation=-60)
self.port_midi_jack_bg_sel = hsvAdjustedRel(
self.port_midi_jack_bg.lighter(150), saturation=-60)
self.port_midi_a2j_bg_sel = hsvAdjustedRel(
self.port_midi_a2j_bg.lighter(150), saturation=-60)
self.port_midi_alsa_bg_sel = hsvAdjustedRel(
self.port_midi_alsa_bg.lighter(150), saturation=-60)
self.port_audio_jack_text = self.port_text
self.port_audio_jack_text_sel = self.port_text
self.port_midi_jack_text = self.port_text
self.port_midi_jack_text_sel = self.port_text
self.port_midi_a2j_text = self.port_text
self.port_midi_a2j_text_sel = self.port_text
self.port_midi_alsa_text = self.port_text
self.port_midi_alsa_text_sel = self.port_text
self.port_text_padding = 0
self.port_offset = 0
self.port_spacing = 1
self.port_spacingT = 0
self.port_rounding = 0
# Lines
self.line_audio_jack = QColor(53, 78, 116)
self.line_audio_jack_sel = self.line_audio_jack.lighter(200)
self.line_audio_jack_glow = self.line_audio_jack.lighter(180)
self.line_midi_jack = QColor(139, 32, 32)
self.line_midi_jack_sel = self.line_midi_jack.lighter(200)
self.line_midi_jack_glow = self.line_midi_jack.lighter(180)
self.line_midi_a2j = QColor(120, 65, 33)
self.line_midi_a2j_sel = self.line_midi_a2j.lighter(200)
self.line_midi_a2j_glow = self.line_midi_a2j.lighter(180)
self.line_midi_alsa = QColor(81, 130, 36)
self.line_midi_alsa_sel = self.line_midi_alsa.lighter(200)
self.line_midi_alsa_glow = self.line_midi_alsa.lighter(180)
self.rubberband_pen = QPen(QColor.fromHsv(191, 100, 120, 170), 2,
Qt.SolidLine)
self.rubberband_brush = QColor.fromHsv(191, 100, 99, 100)
elif idx == self.THEME_PROTOCLASSIC_DARK:
# Canvas
self.canvas_bg = QColor(0, 0, 0)
# Boxes
self.box_bg_1 = QColor(30, 41, 58)
self.box_bg_2 = QColor(30, 41, 58)
self.box_shadow = QColor(89, 89, 89, 180)
self.box_hover = hsvAdjusted(self.box_bg_1,
value=255,
saturation=80)
self.box_pen = QPen(
hsvAdjusted(self.box_bg_1, value=180, saturation=60), 1,
Qt.SolidLine)
self.box_pen_sel = QPen(self.box_pen)
self.box_pen_sel.setDashPattern([3, 4])
self.box_header_pixmap = None
self.box_header_height = 19
self.box_header_spacing = 0
self.box_rounding = 0.0
self.box_bottom_space = 2
self.box_text = QPen(
hsvAdjusted(self.box_bg_1, value=255, saturation=60), 1,
Qt.SolidLine)
self.box_text_sel = QPen(
hsvAdjusted(self.box_bg_1, value=255, saturation=30), 1)
self.box_font_name = "Dejavu Sans"
self.box_font_size = 8
self.box_font_state = QFont.Normal
self.box_bg_type = self.THEME_BG_GRADIENT
self.box_use_icon = False
# Ports
self.port_text = QPen(QColor(255, 255, 255), 1)
self.port_hover = QColor(255, 255, 255, 150)
self.port_bg_pixmap = None
self.port_font_name = "Dejavu Sans"
self.port_font_size = 6
self.port_font_state = QFont.Normal
self.port_mode = self.THEME_PORT_SQUARE
self.port_audio_jack_bg = QColor(63, 88, 133)
self.port_midi_jack_bg = hsvAdjusted(QColor(120, 15, 16),
saturation=150)
self.port_midi_a2j_bg = hsvAdjusted(QColor(101, 47, 17),
saturation=150)
self.port_midi_alsa_bg = hsvAdjusted(QColor(44, 141, 92),
saturation=150,
value=120)
self.port_audio_jack_bg_sel = hsvAdjusted(
self.port_audio_jack_bg.lighter(140), saturation=80)
self.port_midi_jack_bg_sel = hsvAdjusted(
self.port_midi_jack_bg.lighter(140), saturation=80)
self.port_midi_a2j_bg_sel = hsvAdjusted(
self.port_midi_a2j_bg.lighter(140), saturation=80)
self.port_midi_alsa_bg_sel = hsvAdjusted(
self.port_midi_alsa_bg.lighter(140), saturation=80)
port_pen = QPen(QColor(255, 255, 255, 50), 1)
self.port_audio_jack_pen_sel = self.port_audio_jack_pen = QPen(
hsvAdjusted(self.port_audio_jack_bg.lighter(140),
saturation=80), 1)
self.port_midi_jack_pen_sel = self.port_midi_jack_pen = QPen(
hsvAdjusted(self.port_midi_jack_bg.lighter(140),
saturation=80), 1)
self.port_midi_a2j_pen_sel = self.port_midi_a2j_pen = QPen(
hsvAdjusted(self.port_midi_a2j_bg.lighter(140), saturation=80),
1)
self.port_midi_alsa_pen_sel = self.port_midi_alsa_pen = QPen(
hsvAdjusted(self.port_midi_alsa_bg.lighter(140),
saturation=80), 1)
self.port_audio_jack_text = QPen(
hsvAdjusted(self.port_audio_jack_bg, saturation=40, value=255),
1)
self.port_midi_jack_text = QPen(
hsvAdjusted(self.port_midi_jack_bg, saturation=40, value=255),
1)
self.port_midi_a2j_text = QPen(
hsvAdjusted(self.port_midi_a2j_bg, saturation=40, value=255),
1)
self.port_midi_alsa_text = QPen(
hsvAdjusted(self.port_midi_alsa_bg, saturation=40, value=255),
1)
self.port_audio_jack_text_sel = self.port_text
self.port_midi_jack_text_sel = self.port_text
self.port_midi_a2j_text_sel = self.port_text
self.port_midi_alsa_text_sel = self.port_text
self.port_text_padding = 1.5
self.port_offset = 0
self.port_spacing = 1
self.port_spacingT = 0
self.port_rounding = 0.0
self.port_inglow_alpha = 0
self.port_inglow_size = 0
# Lines
self.line_audio_jack = self.port_audio_jack_bg
self.line_audio_jack_sel = self.port_audio_jack_bg_sel
self.line_audio_jack_glow = self.port_audio_jack_bg_sel
self.line_midi_jack = self.port_midi_jack_bg
self.line_midi_jack_sel = self.port_midi_jack_bg_sel
self.line_midi_jack_glow = self.port_midi_jack_bg_sel
self.line_midi_a2j = self.port_midi_a2j_bg
self.line_midi_a2j_sel = self.port_midi_a2j_bg_sel
self.line_midi_a2j_glow = self.port_midi_a2j_bg_sel
self.line_midi_alsa = self.port_midi_alsa_bg
self.line_midi_alsa_sel = self.port_midi_alsa_bg_sel
self.line_midi_alsa_glow = self.port_midi_alsa_bg_sel
self.rubberband_pen = QPen(self.box_pen)
self.rubberband_pen.setDashPattern([3, 4])
self.rubberband_brush = QColor(0, 0, 0, 0)
elif idx == self.THEME_NEOCLASSIC_DARK:
# Canvas
self.canvas_bg = QColor(0, 0, 0)
# Boxes
self.box_pen = QPen(QColor(143 - 70, 143 - 70, 143 - 70), 2,
Qt.SolidLine)
self.box_pen_sel = QPen(QColor(143, 143, 143), 2,
Qt.CustomDashLine, Qt.RoundCap)
self.box_pen_sel.setDashPattern([1.5, 3])
self.box_bg_1 = QColor(30, 34, 36)
self.box_bg_2 = QColor(30, 34, 36)
self.box_shadow = QColor(89, 89, 89, 180)
self.box_hover = QColor(255, 255, 255, 60)
self.box_header_pixmap = None
self.box_header_height = 19
self.box_header_spacing = 0
self.box_rounding = 4.0
self.box_bottom_space = 6
self.box_text = QPen(QColor(255, 255, 255), 0)
self.box_text_sel = self.box_text
self.box_font_name = "Sans"
self.box_font_size = 8
self.box_font_state = QFont.Normal
self.box_bg_type = self.THEME_BG_GRADIENT
self.box_use_icon = False
# Ports
self.port_text = QPen(QColor(250, 250, 250), 0)
self.port_hover = QColor(255, 255, 255, 80)
self.port_bg_pixmap = None
self.port_font_name = "Sans"
self.port_font_size = 8
self.port_font_state = QFont.Normal
self.port_mode = self.THEME_PORT_SQUARE
port_dash = [4, 3]
self.port_audio_jack_pen = QPen(QColor(55, 91, 149), 1)
self.port_midi_jack_pen = QPen(QColor(150, 25, 26), 1)
self.port_midi_a2j_pen = QPen(QColor(141, 67, 27), 1)
self.port_midi_alsa_pen = QPen(QColor(83, 152, 29), 1)
self.port_audio_jack_pen_sel = QPen(
hsvAdjustedRel(QColor(55, 91, 149), saturation=-80, value=80),
1)
self.port_midi_jack_pen_sel = QPen(
hsvAdjustedRel(QColor(150, 25, 26), saturation=-80, value=80),
1)
self.port_midi_a2j_pen_sel = QPen(
hsvAdjustedRel(QColor(141, 67, 27), saturation=-80, value=80),
1)
self.port_midi_alsa_pen_sel = QPen(
hsvAdjustedRel(QColor(83, 152, 29), saturation=-80, value=80),
1)
self.port_audio_jack_pen_sel.setDashPattern(port_dash)
self.port_midi_jack_pen_sel.setDashPattern(port_dash)
self.port_midi_a2j_pen_sel.setDashPattern(port_dash)
self.port_midi_alsa_pen_sel.setDashPattern(port_dash)
self.port_audio_jack_bg = QColor(35, 61, 99)
self.port_midi_jack_bg = QColor(120, 15, 16)
self.port_midi_a2j_bg = QColor(101, 47, 17)
self.port_midi_alsa_bg = QColor(63, 112, 19)
self.port_audio_jack_bg_sel = self.port_audio_jack_bg.darker(130)
self.port_midi_jack_bg_sel = self.port_midi_jack_bg.darker(130)
self.port_midi_a2j_bg_sel = self.port_midi_a2j_bg.darker(130)
self.port_midi_alsa_bg_sel = self.port_midi_alsa_bg.darker(130)
self.port_audio_jack_text = self.port_text
self.port_audio_jack_text_sel = self.port_text
self.port_midi_jack_text = self.port_text
self.port_midi_jack_text_sel = self.port_text
self.port_midi_a2j_text = self.port_text
self.port_midi_a2j_text_sel = self.port_text
self.port_midi_alsa_text = self.port_text
self.port_midi_alsa_text_sel = self.port_text
self.port_text_padding = 1
self.port_offset = 0
self.port_spacing = 1
self.port_spacingT = 0
self.port_rounding = 4.0
# Lines
self.line_audio_jack = QColor(53, 78, 116)
self.line_audio_jack_sel = self.line_audio_jack.lighter(200)
self.line_audio_jack_glow = self.line_audio_jack.lighter(180)
self.line_midi_jack = QColor(139, 32, 32)
self.line_midi_jack_sel = self.line_midi_jack.lighter(200)
self.line_midi_jack_glow = self.line_midi_jack.lighter(180)
self.line_midi_a2j = QColor(120, 65, 33)
self.line_midi_a2j_sel = self.line_midi_a2j.lighter(200)
self.line_midi_a2j_glow = self.line_midi_a2j.lighter(180)
self.line_midi_alsa = QColor(81, 130, 36)
self.line_midi_alsa_sel = self.line_midi_alsa.lighter(200)
self.line_midi_alsa_glow = self.line_midi_alsa.lighter(180)
self.rubberband_pen = QPen(QColor.fromHsv(191, 100, 120, 170), 2,
Qt.SolidLine)
self.rubberband_brush = QColor.fromHsv(191, 100, 99, 100)
elif idx == self.THEME_OOSTUDIO:
# Canvas
self.canvas_bg = QColor(11, 11, 11)
# Boxes
self.box_pen = QPen(QColor(76, 77, 78), 1, Qt.SolidLine)
self.box_pen_sel = QPen(QColor(189, 122, 214), 1, Qt.DashLine)
self.box_bg_1 = QColor(46, 46, 46)
self.box_bg_2 = QColor(23, 23, 23)
self.box_shadow = QColor(89, 89, 89, 180)
self.box_hover = QColor(255, 255, 255, 60)
self.box_header_pixmap = QPixmap(
":/bitmaps/canvas/frame_node_header.png")
self.box_header_height = 22
self.box_header_spacing = 6
self.box_rounding = 3.0
self.box_bottom_space = 4
self.box_text = QPen(QColor(144, 144, 144), 0)
self.box_text_sel = QPen(QColor(189, 122, 214), 0)
self.box_font_name = "Deja Vu Sans"
self.box_font_size = 8
self.box_font_state = QFont.Bold
self.box_bg_type = self.THEME_BG_SOLID
self.box_use_icon = False
# Ports
normalPortBG = QColor(46, 46, 46)
selPortBG = QColor(23, 23, 23)
self.port_text = QPen(QColor(155, 155, 155), 0)
self.port_hover = QColor(255, 255, 255, 80)
self.port_bg_pixmap = QPixmap(":/bitmaps/canvas/frame_port_bg.png")
self.port_font_name = "Deja Vu Sans"
self.port_font_size = 8
self.port_font_state = QFont.Normal
self.port_mode = self.THEME_PORT_SQUARE
self.port_audio_jack_pen = QPen(selPortBG, 2)
self.port_audio_jack_pen_sel = QPen(QColor(1, 230, 238), 1)
self.port_midi_jack_pen = QPen(selPortBG, 2)
self.port_midi_jack_pen_sel = QPen(QColor(252, 118, 118), 1)
self.port_midi_a2j_pen = QPen(selPortBG, 2)
self.port_midi_a2j_pen_sel = QPen(QColor(137, 76, 43), 1)
self.port_midi_alsa_pen = QPen(selPortBG, 2)
self.port_midi_alsa_pen_sel = QPen(QColor(129, 244, 118), 0)
self.port_audio_jack_bg = normalPortBG
self.port_audio_jack_bg_sel = selPortBG
self.port_midi_jack_bg = normalPortBG
self.port_midi_jack_bg_sel = selPortBG
self.port_midi_a2j_bg = normalPortBG
self.port_midi_a2j_bg_sel = selPortBG
self.port_midi_alsa_bg = normalPortBG
self.port_midi_alsa_bg_sel = selPortBG
self.port_audio_jack_text = self.port_text
self.port_audio_jack_text_sel = self.port_audio_jack_pen_sel
self.port_midi_jack_text = self.port_text
self.port_midi_jack_text_sel = self.port_midi_jack_pen_sel
self.port_midi_a2j_text = self.port_text
self.port_midi_a2j_text_sel = self.port_midi_a2j_pen_sel
self.port_midi_alsa_text = self.port_text
self.port_midi_alsa_text_sel = self.port_midi_alsa_pen_sel
# missing, ports 2
self.port_text_padding = 3
self.port_offset = -1
self.port_spacing = 3
self.port_spacingT = 0
self.port_rounding = 3.0
# Lines
self.line_audio_jack = QColor(64, 64, 64)
self.line_audio_jack_sel = QColor(1, 230, 238)
self.line_audio_jack_glow = QColor(100, 200, 100)
self.line_midi_jack = QColor(64, 64, 64)
self.line_midi_jack_sel = QColor(252, 118, 118)
self.line_midi_jack_glow = QColor(200, 100, 100)
self.line_midi_a2j = QColor(64, 64, 64)
self.line_midi_a2j_sel = QColor(137 + 90, 76 + 90, 43 + 90)
self.line_midi_a2j_glow = QColor(166, 133, 133)
self.line_midi_alsa = QColor(64, 64, 64)
self.line_midi_alsa_sel = QColor(129, 244, 118)
self.line_midi_alsa_glow = QColor(100, 200, 100)
self.rubberband_pen = QPen(QColor(1, 230, 238), 2, Qt.SolidLine)
self.rubberband_brush = QColor(90, 90, 90, 100)
# Font-dependant port height
port_font = QFont(self.port_font_name, self.port_font_size,
self.port_font_state)
self.port_height = QFontMetrics(
port_font).height() + 2 * self.port_text_padding
def update(self, zoom_only=False):
self.update_ticks()
line_color = self.plot.color(OWPalette.Axis)
text_color = self.plot.color(OWPalette.Text)
if not self.graph_line or not self.scene():
return
self.line_item.setLine(self.graph_line)
self.line_item.setPen(line_color)
if self.title:
self.title_item.setHtml('<b>' + self.title + '</b>')
self.title_item.setDefaultTextColor(text_color)
if self.title_location == AxisMiddle:
title_p = 0.5
elif self.title_location == AxisEnd:
title_p = 0.95
else:
title_p = 0.05
title_pos = self.graph_line.pointAt(title_p)
v = self.graph_line.normalVector().unitVector()
dense_text = False
if hasattr(self, 'title_margin'):
offset = self.title_margin
elif self._ticks:
if self.should_be_expanded():
offset = 55
dense_text = True
else:
offset = 35
else:
offset = 10
if self.title_above:
title_pos = title_pos + (v.p2() - v.p1()) * (
offset + QFontMetrics(self.title_item.font()).height())
else:
title_pos = title_pos - (v.p2() - v.p1()) * offset
## TODO: Move it according to self.label_pos
self.title_item.setVisible(self.show_title)
self.title_item.setRotation(-self.graph_line.angle())
c = self.title_item.mapToParent(
self.title_item.boundingRect().center())
tl = self.title_item.mapToParent(
self.title_item.boundingRect().topLeft())
self.title_item.setPos(title_pos - c + tl)
## Arrows
if not zoom_only:
if self.start_arrow_item:
self.scene().removeItem(self.start_arrow_item)
self.start_arrow_item = None
if self.end_arrow_item:
self.scene().removeItem(self.end_arrow_item)
self.end_arrow_item = None
if self.arrows & AxisStart:
if not zoom_only or not self.start_arrow_item:
self.start_arrow_item = QGraphicsPathItem(
self.arrow_path, self)
self.start_arrow_item.setPos(self.graph_line.p1())
self.start_arrow_item.setRotation(-self.graph_line.angle() + 180)
self.start_arrow_item.setBrush(line_color)
self.start_arrow_item.setPen(line_color)
if self.arrows & AxisEnd:
if not zoom_only or not self.end_arrow_item:
self.end_arrow_item = QGraphicsPathItem(self.arrow_path, self)
self.end_arrow_item.setPos(self.graph_line.p2())
self.end_arrow_item.setRotation(-self.graph_line.angle())
self.end_arrow_item.setBrush(line_color)
self.end_arrow_item.setPen(line_color)
## Labels
n = len(self._ticks)
resize_plot_item_list(self.label_items, n, QGraphicsTextItem, self)
resize_plot_item_list(self.label_bg_items, n, QGraphicsRectItem, self)
resize_plot_item_list(self.tick_items, n, QGraphicsLineItem, self)
test_rect = QRectF(self.graph_line.p1(),
self.graph_line.p2()).normalized()
test_rect.adjust(-1, -1, 1, 1)
n_v = self.graph_line.normalVector().unitVector()
if self.title_above:
n_p = n_v.p2() - n_v.p1()
else:
n_p = n_v.p1() - n_v.p2()
l_v = self.graph_line.unitVector()
l_p = l_v.p2() - l_v.p1()
for i in range(n):
pos, text, size, step = self._ticks[i]
hs = 0.5 * step
tick_pos = self.map_to_graph(pos)
if not test_rect.contains(tick_pos):
self.tick_items[i].setVisible(False)
self.label_items[i].setVisible(False)
continue
item = self.label_items[i]
item.setVisible(True)
if not zoom_only:
if self.id in XAxes or getattr(self, 'is_horizontal', False):
item.setHtml('<center>' + Qt.escape(text.strip()) +
'</center>')
else:
item.setHtml(Qt.escape(text.strip()))
item.setTextWidth(-1)
text_angle = 0
if dense_text:
w = min(item.boundingRect().width(), self.max_text_width)
item.setTextWidth(w)
if self.title_above:
label_pos = tick_pos + n_p * (
w + self.text_margin
) + l_p * item.boundingRect().height() / 2
else:
label_pos = tick_pos + n_p * self.text_margin + l_p * item.boundingRect(
).height() / 2
text_angle = -90 if self.title_above else 90
else:
w = min(
item.boundingRect().width(),
QLineF(self.map_to_graph(pos - hs),
self.map_to_graph(pos + hs)).length())
label_pos = tick_pos + n_p * self.text_margin - l_p * w / 2
item.setTextWidth(w)
if not self.always_horizontal_text:
if self.title_above:
item.setRotation(-self.graph_line.angle() - text_angle)
else:
item.setRotation(self.graph_line.angle() - text_angle)
item.setPos(label_pos)
item.setDefaultTextColor(text_color)
self.label_bg_items[i].setRect(item.boundingRect())
self.label_bg_items[i].setPen(QPen(Qt.NoPen))
self.label_bg_items[i].setBrush(self.plot.color(OWPalette.Canvas))
item = self.tick_items[i]
item.setVisible(True)
tick_line = QLineF(v)
tick_line.translate(-tick_line.p1())
tick_line.setLength(size)
if self.title_above:
tick_line.setAngle(tick_line.angle() + 180)
item.setLine(tick_line)
item.setPen(line_color)
item.setPos(self.map_to_graph(pos))
def __init__( self, paintDevice ):
# Visibility of the virtual cells (dotted outline)
self.debug = False
self.__paintDevice = paintDevice
self.monoFont = buildFont( "Ubuntu mono,12,-1,5,50,0,0,0,0,0" )
self.monoFontMetrics = QFontMetrics( self.monoFont, paintDevice )
self.badgeFont = buildFont( "Ubuntu mono,9,-1,5,50,0,0,0,0,0" )
self.badgeFontMetrics = QFontMetrics( self.badgeFont, paintDevice )
self.hCellPadding = 8 # in pixels (left and right)
self.vCellPadding = 8 # in pixels (top and bottom)
self.hTextPadding = 5 # in pixels (left and right)
self.vTextPadding = 5 # in pixels (top and bottom)
self.hHeaderPadding = 5 # Scope header (file, decor, loops etc) paddings
self.vHeaderPadding = 5
self.vSpacer = 10
self.rectRadius = 6 # Rounded rectangles radius for the scopes
self.returnRectRadius = 16 # Rounded rectangles radius for the return-like statements
self.minWidth = 100
self.ifWidth = 10 # One if wing width
self.commentCorner = 6 # Top right comment corner
self.lineWidth = 1 # used for connections and box edges
self.lineColor = QColor( 16, 16, 16, 255 )
# Selection
self.selectColor = QColor( 63, 81, 181, 255 )
self.selectPenWidth = 3
# Code blocks and other statements
self.boxBGColor = QColor( 250, 250, 250, 255 )
self.boxFGColor = QColor( 0, 0, 0, 255 )
# Badges
self.badgeBGColor = QColor( 230, 230, 230, 255 )
self.badgeFGColor = QColor( 0, 0, 0, 255 )
self.badgeLineWidth = 1
self.badgeLineColor = QColor( 180, 180, 180, 255 )
# Labels
self.labelBGColor = QColor( 230, 230, 230, 255 )
self.labelFGColor = QColor( 0, 0, 0, 255 )
self.labelLineWidth = 1
self.labelLineColor = QColor( 0, 0, 0, 255 )
# Comments: leading, side & independent
self.commentBGColor = QColor( 255, 255, 153, 255 )
self.commentFGColor = QColor( 0, 0, 0, 255 )
self.commentLineColor = QColor( 102, 102, 61, 255 )
self.commentLineWidth = 1
self.mainLine = 25
self.fileScopeBGColor = QColor( 255, 255, 230, 255 )
self.funcScopeBGColor = QColor( 230, 230, 255, 255 )
self.decorScopeBGColor = QColor( 230, 255, 255, 255 )
self.classScopeBGColor = QColor( 230, 255, 230, 255 )
self.forScopeBGColor = QColor( 187, 222, 251, 255 )
self.whileScopeBGColor = QColor( 187, 222, 251, 255 )
self.elseScopeBGColor = QColor( 209, 196, 233, 255 )
self.withScopeBGColor = QColor( 255, 255, 255, 255 )
self.tryScopeBGColor = QColor( 255, 255, 255, 255 )
self.exceptScopeBGColor = QColor( 255, 255, 255, 255 )
self.finallyScopeBGColor = QColor( 192, 192, 192, 255 )
self.breakBGColor = QColor( 144, 202, 249, 255 )
self.continueBGColor = QColor( 144, 202, 249, 255 )
self.ifBGColor = QColor( 255, 229, 127, 255 )
return
def __init__(self, parent):
QDialog.__init__(self, parent)
self.ui = ui_settings_jack.Ui_JackSettingsW()
self.ui.setupUi(self)
# -------------------------------------------------------------
# Check if we've got valid control interface
global gJackctl
if gJackctl is None:
QTimer.singleShot(0, self, SLOT("slot_closeWithError()"))
return
# -------------------------------------------------------------
# Align driver text and hide non available ones
driverList = gJackctl.ReadContainer(["drivers"])[1]
maxWidth = 75
for i in range(self.ui.obj_server_driver.rowCount()):
self.ui.obj_server_driver.item(0, i).setTextAlignment(Qt.AlignCenter)
itexText = self.ui.obj_server_driver.item(0, i).text()
itemWidth = QFontMetrics(self.ui.obj_server_driver.font()).width(itexText)+25
if itemWidth > maxWidth:
maxWidth = itemWidth
if dbus.String(itexText.lower()) not in driverList:
self.ui.obj_server_driver.hideRow(i)
self.ui.obj_server_driver.setMinimumWidth(maxWidth)
self.ui.obj_server_driver.setMaximumWidth(maxWidth)
# -------------------------------------------------------------
# Set-up connections
self.connect(self, SIGNAL("accepted()"), SLOT("slot_saveJackSettings()"))
self.connect(self.ui.buttonBox.button(QDialogButtonBox.Reset), SIGNAL("clicked()"), SLOT("slot_resetJackSettings()"))
self.connect(self.ui.obj_driver_duplex, SIGNAL("clicked(bool)"), SLOT("slot_checkDuplexSelection(bool)"))
self.connect(self.ui.obj_server_driver, SIGNAL("currentCellChanged(int, int, int, int)"), SLOT("slot_checkDriverSelection(int)"))
self.connect(self.ui.obj_driver_capture, SIGNAL("currentIndexChanged(int)"), SLOT("slot_checkALSASelection()"))
self.connect(self.ui.obj_driver_playback, SIGNAL("currentIndexChanged(int)"), SLOT("slot_checkALSASelection()"))
# -------------------------------------------------------------
# Load initial settings
self.fDriverName = ""
self.fBrokenServerClockSource = False
self.checkEngine()
self.loadServerSettings()
self.loadDriverSettings(True) # reset because we'll change it below
# -------------------------------------------------------------
# Load selected JACK driver
self.fDriverName = str(gJackctl.GetParameterValue(["engine", "driver"])[2])
for i in range(self.ui.obj_server_driver.rowCount()):
if self.ui.obj_server_driver.item(i, 0).text().lower() == self.fDriverName:
self.ui.obj_server_driver.setCurrentCell(i, 0)
break
# Special ALSA check
self.slot_checkALSASelection()
# -------------------------------------------------------------
# Load last GUI settings
self.loadSettings()
def minimumSizeHint(self):
fm = QFontMetrics(self.font())
return QSize(fm.width("WWWW"), self.minimumHeight())
def update_position(self):
font_size = QFontMetrics(self._parent.font()).height()
height = self._parent.lines_count * font_size
self.setFixedHeight(height)
self.setFixedWidth(self._parent.width())
self.__scroll_margins = (height, self._parent.height() - height)
def setMonoFont( self, font ):
" Sets the mono font "
self.monoFont = font
self.monoFontMetrics = QFontMetrics( self.monoFont,
self.__paintDevice )
return
def __createLayout(self):
""" Creates the dialog layout """
self.resize(700, 300)
self.setSizeGripEnabled(True)
layout = QVBoxLayout(self)
gridLayout = QGridLayout()
# Columns
colsLabel = QLabel("Columns")
self.__colsEdit = QLineEdit()
self.__colsEdit.setText(str(self.__settings.settings["COL_LIMIT"]))
self.__colsEdit.setToolTip(self.__settings.getDescription("COL_LIMIT"))
self.__colsEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(colsLabel, 0, 0, 1, 1)
gridLayout.addWidget(self.__colsEdit, 0, 1, 1, 1)
font = self.__colsEdit.font()
font.setFamily(GlobalData().skin.baseMonoFontFace)
self.__colsEdit.setFont(font)
# Assignment
assignmentLabel = QLabel("Assignment")
self.__assignmentEdit = QLineEdit()
self.__assignmentEdit.setText(self.__settings.settings["ASSIGNMENT"])
self.__assignmentEdit.setToolTip(
self.__settings.getDescription("ASSIGNMENT"))
self.__assignmentEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(assignmentLabel, 0, 3, 1, 1)
gridLayout.addWidget(self.__assignmentEdit, 0, 4, 1, 1)
self.__assignmentEdit.setFont(font)
# Function parameters assignment
funcAssignLabel = QLabel("Function params\nassignment")
self.__funcAssignEdit = QLineEdit()
self.__funcAssignEdit.setText(
self.__settings.settings["FUNCTION_PARAM_ASSIGNMENT"])
self.__funcAssignEdit.setToolTip(
self.__settings.getDescription("FUNCTION_PARAM_ASSIGNMENT"))
self.__funcAssignEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(funcAssignLabel, 1, 0, 1, 1)
gridLayout.addWidget(self.__funcAssignEdit, 1, 1, 1, 1)
self.__funcAssignEdit.setFont(font)
# Dictionary separator
dictSepLabel = QLabel("Dictionary separator")
self.__dictSepEdit = QLineEdit()
self.__dictSepEdit.setText(self.__settings.settings["DICT_COLON"])
self.__dictSepEdit.setToolTip(
self.__settings.getDescription("DICT_COLON"))
self.__dictSepEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(dictSepLabel, 1, 3, 1, 1)
gridLayout.addWidget(self.__dictSepEdit, 1, 4, 1, 1)
self.__dictSepEdit.setFont(font)
# Slice separator
sliceSepLabel = QLabel("Slice separator")
self.__sliceSepEdit = QLineEdit()
self.__sliceSepEdit.setText(self.__settings.settings["SLICE_COLON"])
self.__sliceSepEdit.setToolTip(
self.__settings.getDescription("SLICE_COLON"))
self.__sliceSepEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(sliceSepLabel, 2, 0, 1, 1)
gridLayout.addWidget(self.__sliceSepEdit, 2, 1, 1, 1)
self.__sliceSepEdit.setFont(font)
# Interpreter
inLabel = QLabel("Interpreter")
self.__inEdit = QLineEdit()
self.__inEdit.setText(self.__settings.settings["SHEBANG"])
self.__inEdit.setToolTip(self.__settings.getDescription("SHEBANG"))
self.__inEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(inLabel, 2, 3, 1, 1)
gridLayout.addWidget(self.__inEdit, 2, 4, 1, 1)
self.__inEdit.setFont(font)
# Coding spec
codingLabel = QLabel("Output encoding")
self.__outCodingEdit = QLineEdit()
self.__outCodingEdit.setText(self.__settings.settings["CODING"])
self.__outCodingEdit.setToolTip(
self.__settings.getDescription("CODING"))
self.__outCodingEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(codingLabel, 3, 0, 1, 1)
gridLayout.addWidget(self.__outCodingEdit, 3, 1, 1, 1)
self.__outCodingEdit.setFont(font)
# Src coding comment
srcCodingLabel = QLabel("File encoding\ncomment")
self.__srcCodingEdit = QLineEdit()
self.__srcCodingEdit.setText(self.__settings.settings["CODING_SPEC"])
self.__srcCodingEdit.setToolTip(
self.__settings.getDescription("CODING_SPEC"))
self.__srcCodingEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(srcCodingLabel, 3, 3, 1, 1)
gridLayout.addWidget(self.__srcCodingEdit, 3, 4, 1, 1)
self.__srcCodingEdit.setFont(font)
layout.addLayout(gridLayout)
# Boilerplate
boilLabel = QLabel("Boilerplate ")
boilLabel.setAlignment(Qt.AlignTop)
self.__boilEdit = QTextEdit()
self.__boilEdit.setPlainText(self.__settings.settings["BOILERPLATE"])
self.__boilEdit.setToolTip(
self.__settings.getDescription("BOILERPLATE"))
self.__boilEdit.setTabChangesFocus(True)
self.__boilEdit.setAcceptRichText(False)
self.__boilEdit.setFont(font)
self.__boilEdit.textChanged.connect(self.__validate)
boilLayout = QHBoxLayout()
boilLayout.addWidget(boilLabel)
boilLayout.addWidget(self.__boilEdit)
layout.addLayout(boilLayout)
# Now check boxes and radio buttons
cbGridLayout = QGridLayout()
self.__keepBlanks = QCheckBox("Keep blank lines")
self.__keepBlanks.setChecked(
self.__settings.settings["KEEP_BLANK_LINES"])
self.__keepBlanks.setToolTip(
self.__settings.getDescription("KEEP_BLANK_LINES"))
cbGridLayout.addWidget(self.__keepBlanks, 0, 0, 1, 1)
self.__addBlanks = QCheckBox("Add blank lines around comments")
self.__addBlanks.setChecked(
self.__settings.settings["ADD_BLANK_LINES_AROUND_COMMENTS"])
self.__addBlanks.setToolTip(
self.__settings.getDescription("ADD_BLANK_LINES_AROUND_COMMENTS"))
cbGridLayout.addWidget(self.__addBlanks, 0, 2, 1, 1)
self.__justifyDoc = QCheckBox("Left justify doc strings")
self.__justifyDoc.setChecked(
self.__settings.settings["LEFTJUST_DOC_STRINGS"])
self.__justifyDoc.setToolTip(
self.__settings.getDescription("LEFTJUST_DOC_STRINGS"))
cbGridLayout.addWidget(self.__justifyDoc, 1, 0, 1, 1)
self.__wrapDoc = QCheckBox("Wrap long doc strings")
self.__wrapDoc.setChecked(self.__settings.settings["WRAP_DOC_STRINGS"])
self.__wrapDoc.setToolTip(
self.__settings.getDescription("WRAP_DOC_STRINGS"))
cbGridLayout.addWidget(self.__wrapDoc, 1, 2, 1, 1)
self.__recodeStrings = QCheckBox("Try to decode strings")
self.__recodeStrings.setChecked(
self.__settings.settings["RECODE_STRINGS"])
self.__recodeStrings.setToolTip(
self.__settings.getDescription("RECODE_STRINGS"))
cbGridLayout.addWidget(self.__recodeStrings, 2, 0, 1, 1)
self.__splitStrings = QCheckBox("Split long strings")
self.__splitStrings.setChecked(
self.__settings.settings["CAN_SPLIT_STRINGS"])
self.__splitStrings.setToolTip(
self.__settings.getDescription("CAN_SPLIT_STRINGS"))
cbGridLayout.addWidget(self.__splitStrings, 2, 2, 1, 1)
self.__keepUnassignedConst = QCheckBox("Keep unassigned constants")
self.__keepUnassignedConst.setChecked(
self.__settings.settings["KEEP_UNASSIGNED_CONSTANTS"])
self.__keepUnassignedConst.setToolTip(
self.__settings.getDescription("KEEP_UNASSIGNED_CONSTANTS"))
cbGridLayout.addWidget(self.__keepUnassignedConst, 3, 0, 1, 1)
self.__parenTuple = QCheckBox("Parenthesize tuple display")
self.__parenTuple.setChecked(
self.__settings.settings["PARENTHESIZE_TUPLE_DISPLAY"])
self.__parenTuple.setToolTip(
self.__settings.getDescription("PARENTHESIZE_TUPLE_DISPLAY"))
cbGridLayout.addWidget(self.__parenTuple, 3, 2, 1, 1)
self.__javaListDedent = QCheckBox("Java style list dedent")
self.__javaListDedent.setChecked(
self.__settings.settings["JAVA_STYLE_LIST_DEDENT"])
self.__javaListDedent.setToolTip(
self.__settings.getDescription("JAVA_STYLE_LIST_DEDENT"))
cbGridLayout.addWidget(self.__javaListDedent, 4, 0, 1, 1)
layout.addLayout(cbGridLayout)
# Quotes radio buttons
quotesGroupbox = QGroupBox("Quotes")
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth( \
quotesGroupbox.sizePolicy().hasHeightForWidth() )
quotesGroupbox.setSizePolicy(sizePolicy)
layoutQG = QVBoxLayout(quotesGroupbox)
self.__use1RButton = QRadioButton(
"Use apostrophes instead of quotes for string literals",
quotesGroupbox)
layoutQG.addWidget(self.__use1RButton)
self.__use2RButton = QRadioButton(
"Use quotes instead of apostrophes for string literals",
quotesGroupbox)
layoutQG.addWidget(self.__use2RButton)
self.__useAsIsRButton = QRadioButton("Do not make changes",
quotesGroupbox)
layoutQG.addWidget(self.__useAsIsRButton)
use1 = self.__settings.settings["SINGLE_QUOTED_STRINGS"]
use2 = self.__settings.settings["DOUBLE_QUOTED_STRINGS"]
if use1:
self.__use1RButton.setChecked(True)
elif use2:
self.__use2RButton.setChecked(True)
else:
self.__useAsIsRButton.setChecked(True)
layout.addWidget(quotesGroupbox)
fontMetrics = QFontMetrics(font)
editWidth = fontMetrics.width("iso8859-10 ") + 20
self.__colsEdit.setFixedWidth(editWidth)
self.__funcAssignEdit.setFixedWidth(editWidth)
self.__sliceSepEdit.setFixedWidth(editWidth)
self.__outCodingEdit.setFixedWidth(editWidth)
# Buttons at the bottom
buttonBox = QDialogButtonBox(self)
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Cancel)
self.__resetButton = buttonBox.addButton("Reset to Default",
QDialogButtonBox.ActionRole)
self.__resetButton.setToolTip(
"Mostly as recommended by PEP 8 / PEP 308")
self.__resetButton.clicked.connect(self.__reset)
self.__tidyButton = buttonBox.addButton("Tidy",
QDialogButtonBox.ActionRole)
self.__tidyButton.setToolTip("Save settings and run PythonTidy")
self.__tidyButton.setDefault(True)
self.__tidyButton.clicked.connect(self.__saveAndAccept)
layout.addWidget(buttonBox)
buttonBox.rejected.connect(self.close)
return
def __createLayout(self, pathsToCommit, pathsToIgnore):
" Creates the dialog layout "
self.resize(640, 480)
self.setSizeGripEnabled(True)
vboxLayout = QVBoxLayout(self)
# Paths to commit part
commitHeaderFrame = QFrame()
commitHeaderFrame.setFrameStyle(QFrame.StyledPanel)
commitHeaderFrame.setAutoFillBackground(True)
self.__setLightPalette(commitHeaderFrame)
commitHeaderFrame.setFixedHeight(24)
expandingCommitSpacer = QSpacerItem(10, 10, QSizePolicy.Expanding)
self.__selectAllButton = QToolButton()
self.__selectAllButton.setAutoRaise(True)
self.__selectAllButton.setIcon(
PixmapCache().getIcon(pluginHomeDir + 'svnselectall.png'))
self.__selectAllButton.setFixedSize(20, 20)
self.__selectAllButton.setToolTip("Select all")
self.__selectAllButton.setFocusPolicy(Qt.NoFocus)
self.__selectAllButton.clicked.connect(self.__onSelectAll)
commitHeaderLayout = QHBoxLayout()
commitHeaderLayout.setContentsMargins(3, 0, 0, 0)
commitHeaderLayout.addWidget(
QLabel("Paths to commit (total: " + str(len(pathsToCommit)) + ")"))
commitHeaderLayout.addSpacerItem(expandingCommitSpacer)
commitHeaderLayout.addWidget(self.__selectAllButton)
commitHeaderFrame.setLayout(commitHeaderLayout)
vboxLayout.addWidget(commitHeaderFrame)
self.__pathToCommitView = QTreeWidget()
self.__configTable(self.__pathToCommitView)
self.__pathToCommitHeader = QTreeWidgetItem(["", "Path", "Status", ""])
self.__pathToCommitView.setHeaderItem(self.__pathToCommitHeader)
self.__pathToCommitView.header().setSortIndicator(
PATH_COL, Qt.AscendingOrder)
self.__pathToCommitView.itemChanged.connect(self.__onCommitPathChanged)
vboxLayout.addWidget(self.__pathToCommitView)
# Paths to ignore part
headerFrame = QFrame()
headerFrame.setFrameStyle(QFrame.StyledPanel)
headerFrame.setAutoFillBackground(True)
self.__setLightPalette(headerFrame)
headerFrame.setFixedHeight(24)
ignoreLabel = QLabel("Ignored paths (total: " +
str(len(pathsToIgnore)) + ")")
expandingSpacer = QSpacerItem(10, 10, QSizePolicy.Expanding)
self.__showHideIgnoredButton = QToolButton()
self.__showHideIgnoredButton.setAutoRaise(True)
self.__showHideIgnoredButton.setIcon(PixmapCache().getIcon('less.png'))
self.__showHideIgnoredButton.setFixedSize(20, 20)
self.__showHideIgnoredButton.setToolTip("Show ignored path list")
self.__showHideIgnoredButton.setFocusPolicy(Qt.NoFocus)
self.__showHideIgnoredButton.clicked.connect(self.__onShowHideIgnored)
ignoredHeaderLayout = QHBoxLayout()
ignoredHeaderLayout.setContentsMargins(3, 0, 0, 0)
ignoredHeaderLayout.addWidget(ignoreLabel)
ignoredHeaderLayout.addSpacerItem(expandingSpacer)
ignoredHeaderLayout.addWidget(self.__showHideIgnoredButton)
headerFrame.setLayout(ignoredHeaderLayout)
vboxLayout.addWidget(headerFrame)
self.__pathToIgnoreView = QTreeWidget()
self.__configTable(self.__pathToIgnoreView)
self.__pathToIgnoreView.setVisible(False)
pathToIgnoreHeader = QTreeWidgetItem(["Path", "Status"])
self.__pathToIgnoreView.setHeaderItem(pathToIgnoreHeader)
self.__pathToIgnoreView.header().setSortIndicator(0, Qt.AscendingOrder)
vboxLayout.addWidget(self.__pathToIgnoreView)
# Message part
vboxLayout.addWidget(QLabel("Message"))
self.__message = QTextEdit()
self.__message.setAcceptRichText(False)
metrics = QFontMetrics(self.__message.font())
rect = metrics.boundingRect("X")
self.__message.setFixedHeight(rect.height() * 4 + 5)
vboxLayout.addWidget(self.__message)
# Diff part
diffHeaderFrame = QFrame()
diffHeaderFrame.setFrameStyle(QFrame.StyledPanel)
diffHeaderFrame.setAutoFillBackground(True)
self.__setLightPalette(diffHeaderFrame)
diffHeaderFrame.setFixedHeight(24)
diffLabel = QLabel("Diff")
diffExpandingSpacer = QSpacerItem(10, 10, QSizePolicy.Expanding)
self.__showHideDiffButton = QToolButton()
self.__showHideDiffButton.setAutoRaise(True)
self.__showHideDiffButton.setIcon(PixmapCache().getIcon('less.png'))
self.__showHideDiffButton.setFixedSize(20, 20)
self.__showHideDiffButton.setToolTip("Show diff")
self.__showHideDiffButton.setFocusPolicy(Qt.NoFocus)
self.__showHideDiffButton.clicked.connect(self.__onShowHideDiff)
diffLayout = QHBoxLayout()
diffLayout.setContentsMargins(3, 0, 0, 0)
diffLayout.addWidget(diffLabel)
diffLayout.addSpacerItem(diffExpandingSpacer)
diffLayout.addWidget(self.__showHideDiffButton)
diffHeaderFrame.setLayout(diffLayout)
self.__diffViewer = DiffTabWidget()
self.__diffViewer.setHTML(self.NODIFF)
self.__diffViewer.setVisible(False)
vboxLayout.addWidget(diffHeaderFrame)
vboxLayout.addWidget(self.__diffViewer)
# Buttons at the bottom
buttonBox = QDialogButtonBox(self)
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.__OKButton = buttonBox.button(QDialogButtonBox.Ok)
self.__OKButton.setText("Commit")
buttonBox.button(QDialogButtonBox.Cancel).setDefault(True)
buttonBox.accepted.connect(self.userAccept)
buttonBox.rejected.connect(self.close)
vboxLayout.addWidget(buttonBox)
return
