def toggle_node_color_reg(self):
"""Update the node color for regression trees"""
def_color = QColor(192, 192, 255)
if self.regression_colors == self.COL_DEFAULT:
brush = QBrush(def_color.lighter(100))
for node in self.scene.nodes():
node.backgroundBrush = brush
elif self.regression_colors == self.COL_INSTANCE:
max_insts = len(self.model.instances)
for node in self.scene.nodes():
node.backgroundBrush = QBrush(
def_color.lighter(120 - 20 * len(node.node_inst.subset) /
max_insts))
elif self.regression_colors == self.COL_MEAN:
minv = np.nanmin(self.dataset.Y)
maxv = np.nanmax(self.dataset.Y)
fact = 1 / (maxv - minv) if minv != maxv else 1
colors = self.scene.colors
for node in self.scene.nodes():
node.backgroundBrush = QBrush(
colors[fact * (node.node_inst.value[0] - minv)])
else:
nodes = list(self.scene.nodes())
variances = [node.node_inst.value[1] for node in nodes]
max_var = max(variances)
for node, var in zip(nodes, variances):
node.backgroundBrush = QBrush(
def_color.lighter(120 - 20 * var / max_var))
self.scene.update()
def new_point_color(self, color):
col = QColor(color)
if col.isValid() and col != self._new_point_color:
self._new_point_color = col
self.new_point_hover_color = col.lighter(150)
if self.new_point_hover_color == col:
self.new_point_hover_color = col.lighter(50)
self.pointParameterChange.emit()
def cell_color(self, color):
col = QColor(color)
if col.isValid() and col != self._cell_color:
self._cell_color = col
self.cell_hover_color = col.lighter(150)
if self.cell_hover_color == col:
self.cell_hover_color = col.lighter(50)
self.cellParameterChange.emit()
def cell_color(self, color):
col = QColor(color)
if col.isValid() and col != self._cell_color:
self._cell_color = col
self.cell_hover_color = col.lighter(150)
if self.cell_hover_color == col:
self.cell_hover_color = col.lighter(50)
self.cellParameterChange.emit()
def new_point_color(self, color):
col = QColor(color)
if col.isValid() and col != self._new_point_color:
self._new_point_color = col
self.new_point_hover_color = col.lighter(150)
if self.new_point_hover_color == col:
self.new_point_hover_color = col.lighter(50)
self.pointParameterChange.emit()
def make_color_legend(self):
color_index = self.get_color_index()
if color_index == -1:
return
color_var = self.data_domain[color_index]
use_shape = self.get_shape_index() == color_index
if isinstance(color_var, DiscreteVariable):
if not self.legend:
self.create_legend()
palette = self.discrete_palette
for i, value in enumerate(color_var.values):
color = QColor(*palette.getRGB(i))
brush = color.lighter(self.DarkerValue)
self.legend.addItem(
ScatterPlotItem(
pen=color, brush=brush, size=10,
symbol=self.CurveSymbols[i] if use_shape else "o"),
value)
else:
legend = self.color_legend = PositionedLegendItem(
self.plot_widget.plotItem,
self, legend_id="colors", at_bottom=True)
label = PaletteItemSample(self.continuous_palette, self.scale)
legend.addItem(label, "")
legend.setGeometry(label.boundingRect())
def make_color_legend(self):
color_index = self.get_color_index()
if color_index == -1:
return
color_var = self.data_domain[color_index]
use_shape = self.get_shape_index() == color_index
if isinstance(color_var, DiscreteVariable):
if not self.legend:
self.create_legend()
palette = self.discrete_palette
for i, value in enumerate(color_var.values):
color = QColor(*palette.getRGB(i))
brush = color.lighter(self.DarkerValue)
self.legend.addItem(
ScatterPlotItem(
pen=color,
brush=brush,
size=10,
symbol=self.CurveSymbols[i] if use_shape else "o"),
value)
else:
legend = self.color_legend = PositionedLegendItem(
self.plot_widget.plotItem,
self,
legend_id="colors",
at_bottom=True)
label = PaletteItemSample(self.continuous_palette, self.scale)
legend.addItem(label, "")
legend.setGeometry(label.boundingRect())
def make_color_legend(self):
color_index = self.get_color_index()
if color_index == -1:
return
color_var = self.domain[color_index]
use_shape = self.get_shape_index() == color_index
if color_var.is_discrete:
if not self.legend:
self.create_legend()
palette = self.discrete_palette
for i, value in enumerate(color_var.values):
color = QColor(*palette.getRGB(i))
brush = color.lighter(self.DarkerValue)
self.legend.addItem(
ScatterPlotItem(
pen=color,
brush=brush,
size=10,
symbol=self.CurveSymbols[i] if use_shape else "o"),
escape(value))
else:
legend = self.color_legend = LegendItem()
legend.setParentItem(self.plot_widget.getViewBox())
legend.restoreAnchor(self.__color_legend_anchor)
label = PaletteItemSample(self.continuous_palette, self.scale)
legend.addItem(label, "")
legend.setGeometry(label.boundingRect())
def make_color_legend(self):
color_index = self.get_color_index()
if color_index == -1:
return
color_var = self.data_domain[color_index]
use_shape = self.get_shape_index() == color_index
if color_var.is_discrete:
if not self.legend:
self.create_legend()
palette = self.discrete_palette
for i, value in enumerate(color_var.values):
color = QColor(*palette.getRGB(i))
brush = color.lighter(self.DarkerValue)
self.legend.addItem(
ScatterPlotItem(
pen=color, brush=brush, size=10,
symbol=self.CurveSymbols[i] if use_shape else "o"),
escape(value))
else:
legend = self.color_legend = LegendItem()
legend.setParentItem(self.plot_widget.getViewBox())
legend.restoreAnchor(self.__color_legend_anchor)
label = PaletteItemSample(self.continuous_palette, self.scale)
legend.addItem(label, "")
legend.setGeometry(label.boundingRect())
def drawItem(self, item, painter, option):
"""
Draws the inputed item as a bar graph.
:param item | <XChartDatasetItem>
painter | <QPainter>
option | <QStyleOptionGraphicsItem>
"""
dataset = item.dataset()
painter.save()
painter.setRenderHint(painter.Antialiasing)
pen = QPen(dataset.color())
pen.setWidth(0.75)
painter.setPen(pen)
for path in item.buildData('subpaths', []):
gradient = QLinearGradient()
clr = QColor(dataset.color())
clr.setAlpha(220)
gradient.setColorAt(0.0, clr.lighter(180))
gradient.setColorAt(0.1, clr.lighter(160))
gradient.setColorAt(0.25, clr.lighter(140))
gradient.setColorAt(1.0, clr.lighter(125))
if self.orientation() == Qt.Vertical:
gradient.setStart(0, path.boundingRect().bottom())
gradient.setFinalStop(0, path.boundingRect().top())
else:
gradient.setStart(path.boundingRect().left(), 0)
gradient.setFinalStop(path.boundingRect().right(), 0)
painter.setBrush(gradient)
painter.drawPath(path)
painter.restore()
def drawItem(self, item, painter, option):
"""
Draws the inputed item as a bar graph.
:param item | <XChartDatasetItem>
painter | <QPainter>
option | <QStyleOptionGraphicsItem>
"""
dataset = item.dataset()
painter.save()
painter.setRenderHint(painter.Antialiasing)
pen = QPen(dataset.color())
pen.setWidth(0.75)
painter.setPen(pen)
for path in item.buildData('subpaths', []):
gradient = QLinearGradient()
clr = QColor(dataset.color())
clr.setAlpha(220)
gradient.setColorAt(0.0, clr.lighter(180))
gradient.setColorAt(0.1, clr.lighter(160))
gradient.setColorAt(0.25, clr.lighter(140))
gradient.setColorAt(1.0, clr.lighter(125))
if self.orientation() == Qt.Vertical:
gradient.setStart(0, path.boundingRect().bottom())
gradient.setFinalStop(0, path.boundingRect().top())
else:
gradient.setStart(path.boundingRect().left(), 0)
gradient.setFinalStop(path.boundingRect().right(), 0)
painter.setBrush(gradient)
painter.drawPath(path)
painter.restore()
def kresliPolozku(self, painter, size, angle, nazov, color): col1 = QColor(color) col2 = QColor(color) col3 = QColor(color) col1 = col1.lighter(105) col2 = col1.darker(140) col3 = col3.darker() gradient = QRadialGradient(QPointF(size.width() / 2, size.height() / 2), size.width() / 2 - 20) gradient.setColorAt(0.0, col1) gradient.setColorAt(0.6, col2) gradient.setColorAt(1.0, col3) painter.setPen(Qt.NoPen) painter.setBrush(gradient) painter.drawPie(QRect(20, 20, size.width() - 40, size.height() - 40), self.__startAngle, angle) self.__startAngle = self.__startAngle + angle
def make_color_legend(self):
color_index = self.get_color_index()
if color_index == -1:
return
if not self.legend:
self.create_legend()
color_var = self.data_domain[color_index]
use_shape = self.get_shape_index() == color_index
if isinstance(color_var, DiscreteVariable):
palette = self.discrete_palette
for i, value in enumerate(color_var.values):
color = QColor(*palette.getRGB(i))
brush = color.lighter(self.LighterValue)
self.legend.addItem(
pg.ScatterPlotItem(
pen=color, brush=brush, size=10,
symbol=self.CurveSymbols[i] if use_shape else "o"),
value)
def updateColor(self, item):
pixmap = QPixmap(16, 16)
color = QColor()
if item:
color = item.backgroundColor()
if not color.isValid():
color = self.palette().base().color()
painter = QPainter(pixmap)
painter.fillRect(0, 0, 16, 16, color)
lighter = color.lighter()
painter.setPen(lighter)
# light frame
painter.drawPolyline(QPoint(0, 15), QPoint(0, 0), QPoint(15, 0))
painter.setPen(color.darker())
# dark frame
painter.drawPolyline(QPoint(1, 15), QPoint(15, 15), QPoint(15, 1))
painter.end()
self.colorAction.setIcon(QIcon(pixmap))
def drawData(self, painter, size, angle, dataname, color):
"""
Draw data
@param painter:
@type painter:
@param size:
@type size:
@param angle:
@type angle:
@param dataname:
@type dataname:
@param color:
@type color:
"""
col1 = QColor(color)
col2 = QColor(color)
col3 = QColor(color)
col1 = col1.lighter(105)
col2 = col1.darker(140)
col3 = col3.darker()
gradient = QRadialGradient(
QPointF(size.width() / 2,
size.height() / 2),
size.width() / 2 - 20)
gradient.setColorAt(0.0, col1)
gradient.setColorAt(0.6, col2)
gradient.setColorAt(1.0, col3)
painter.setPen(Qt.NoPen)
painter.setBrush(gradient)
painter.drawPie(QRect(20, 20,
size.width() - 40,
size.height() - 40), self.__startAngle, angle)
self.__startAngle = self.__startAngle + angle
class LetterItem(QGraphicsWidget):
'''
A dragable objects which represents a game tile and is used as
an intuitive way of interaction
'''
LETTER_SIZE = 50
LETTER_FONT = QFont('Sans', 50/2, QFont.DemiBold)
LETTER_PEN = QPen(QColor('#444444'), 1, Qt.SolidLine)
SCORE_FONT = QFont('Sans', 50/6)
SCORE_PEN = QPen(QColor('#666666'), 1, Qt.SolidLine)
LETTER_CENTER = QPointF(25, 25)
BOUNDING_RECT = QRectF(0, 0, 50, 50)
def __init__(self, char, score, color, safe=False):
''' Construct a new visual representation of a tile '''
super().__init__()
self.owner = None
self.char = char.upper()
self.score = str(score)
self.is_safe = safe
self.color_border = QColor(color).lighter(100)
self.color_bg = QColor(color).lighter(150)
self.normal_pen = QPen(self.color_border, 1, Qt.SolidLine)
self.safe_pen = QPen(self.color_border, 2, Qt.SolidLine)
self.selected_pen = QPen(self.color_border, 3, Qt.DashLine)
self.normal_brush = self.color_bg.lighter(110)
self.safe_brush = self.color_bg
self.hovers = set()
self.selected = False
self.view = None
self.animation = None
self.deleted = False
self.size = QSizeF(self.LETTER_SIZE, self.LETTER_SIZE)
self.setFlag(self.ItemIsMovable, not safe)
self.setFlag(self.ItemSendsGeometryChanges, not safe)
self.setCursor(Qt.ArrowCursor if safe else Qt.OpenHandCursor)
self.setZValue(1)
self.setOpacity(0)
def boundingRect(self):
''' Required by QGraphicsItem '''
return self.BOUNDING_RECT
def paint(self, painter, objects, widget):
''' Required by QGraphicsItem '''
painter.setBrush(self.safe_brush if self.is_safe else self.normal_brush)
if self.selected:
painter.setPen(self.selected_pen)
elif self.is_safe:
painter.setPen(self.safe_pen)
else:
painter.setPen(self.normal_pen)
painter.drawRoundedRect(0, 0, self.LETTER_SIZE, self.LETTER_SIZE,
self.LETTER_SIZE/8, self.LETTER_SIZE/8)
painter.setFont(self.LETTER_FONT)
painter.setPen(self.LETTER_PEN)
painter.drawText(QRect(0, 0, self.LETTER_SIZE, self.LETTER_SIZE),
Qt.AlignCenter, self.char)
painter.setFont(self.SCORE_FONT)
painter.setPen(self.SCORE_PEN)
painter.drawText(QRect(0, 0, self.LETTER_SIZE-3, self.LETTER_SIZE-1),
Qt.AlignRight | Qt.AlignBottom, self.score)
def itemChange(self, change, value):
''' Item change event to control item movement '''
if not self.view and self.scene() and self.scene().views():
self.view = self.scene().views()[0]
if change == self.ItemPositionChange and self.view:
rect = self.view.viewport().geometry()
rect.moveTo(0, 0)
rect = self.view.mapToScene(rect).boundingRect()
if not rect.contains(QRectF(value, self.size)):
value.setX(min(max(value.x(), rect.left()), rect.right() -
self.LETTER_SIZE))
value.setY(min(max(value.y(), rect.top()), rect.bottom() -
self.LETTER_SIZE))
return value
elif change == self.ItemVisibleChange and self.isVisible() and \
not self.deleted:
self.animation = QPropertyAnimation(self, 'opacity')
self.animation.setDuration(250)
self.animation.setStartValue(0)
self.animation.setEndValue(1)
self.animation.start()
return super().itemChange(change, value)
def mousePressEvent(self, event):
''' Fired when the LetterItem is pressed '''
self.last_valid_position = self.scenePos()
self.hovers = set()
self.setZValue(1000)
super().mousePressEvent(event)
def mouseMoveEvent(self, event):
'''
Fired when the LetterItem is moved, propagates a custom letter event
to underlying RackItem and BoardItem objects
'''
super().mouseMoveEvent(event)
pos = self.scenePos() + self.LETTER_CENTER
items = set(item for item in self.scene().items(pos)
if type(item) in (RackItem, BoardItem))
for item in items:
item.letterMoveEvent(self)
for item in self.hovers:
if item not in items:
item.letterMoveOutEvent(self)
self.hovers = items
def mouseReleaseEvent(self, event):
'''
Fired when the LetterItem is released, propagates a custom letter event
to underlying RackItem and BoardItem objects
'''
self.setZValue(1)
super().mouseReleaseEvent(event)
if self.last_valid_position == self.scenePos() and not self.is_safe:
self.selected = not self.selected
if self.scene() and self.scene().views():
self.scene().views()[0].letterChanged.emit()
else:
items = self.scene().items(self.scenePos() + self.LETTER_CENTER)
for item in items:
if type(item) in (RackItem, BoardItem):
return item.letterReleaseEvent(self)
self.move(self.last_valid_position)
def undo(self):
''' Moves the LetterItem back to the last valid position '''
self.move(self.last_valid_position)
def own(self, new_owner, *args, **kwargs):
'''
Removes the Letter from a maybe existing owner and calls the new
owners addLetter routine
'''
if self.owner:
self.owner.removeLetter(self, *self.owner_args,
**self.owner_kwargs)
if new_owner:
self.owner = new_owner
self.owner_args = args
self.owner_kwargs = kwargs
self.owner.addLetter(self, *args, **kwargs)
if self.scene() and self.scene().views():
self.scene().views()[0].letterChanged.emit()
def move(self, pos):
''' A simple animation to move the letter '''
self.animation = QPropertyAnimation(self, 'pos')
self.animation.setDuration(100)
self.animation.setStartValue(self.scenePos())
self.animation.setEndValue(pos)
self.animation.start()
def center(self):
''' Get the center position of the Letter '''
return self.scenePos() + self.LETTER_CENTER
def remove(self):
self.scene().removeItem(self)
del self
def fade(self):
if self.animation:
self.animation.stop()
self.deleted = True
self.animation = QPropertyAnimation(self, 'opacity')
self.animation.setDuration(250)
self.animation.setStartValue(self.opacity())
self.animation.setEndValue(0)
self.animation.finished.connect(self.remove)
self.animation.start()
def _setup_plot(self):
"""Setup the plot with new curve data."""
assert self.data is not None
legend = self.graph.plotItem.addLegend(offset=(-30, 30))
data, domain = self.data, self.data.domain
if is_discrete(domain.class_var):
class_col_data, _ = data.get_column_view(domain.class_var)
group_indices = [
np.flatnonzero(class_col_data == i)
for i in range(len(domain.class_var.values))
]
else:
group_indices = [np.arange(len(data))]
X = np.arange(1, len(domain.attributes) + 1)
groups = []
for i, indices in enumerate(group_indices):
if self.classes:
color = self.class_colors[i]
else:
color = QColor(Qt.darkGray)
group_data = data[indices, :]
plot_x, plot_y, connect = disconnected_curve_data(group_data.X,
x=X)
color.setAlpha(200)
lightcolor = QColor(color.lighter(factor=150))
lightcolor.setAlpha(150)
pen = QPen(color, 2)
pen.setCosmetic(True)
lightpen = QPen(lightcolor, 1)
lightpen.setCosmetic(True)
hoverpen = QPen(pen)
hoverpen.setWidth(2)
curve = pg.PlotCurveItem(
x=plot_x,
y=plot_y,
connect=connect,
pen=lightpen,
symbolSize=2,
antialias=True,
)
self.graph.addItem(curve)
hovercurves = []
for index, profile in zip(indices, group_data.X):
hcurve = HoverCurve(x=X,
y=profile,
pen=hoverpen,
antialias=True)
hcurve.setToolTip('{}'.format(index))
hcurve._data_index = index
hovercurves.append(hcurve)
self.graph.addItem(hcurve)
mean = np.nanmean(group_data.X, axis=0)
meancurve = pg.PlotDataItem(x=X,
y=mean,
pen=pen,
size=5,
symbol="o",
pxMode=True,
symbolSize=5,
antialias=True)
hoverpen = QPen(hoverpen)
hoverpen.setWidth(5)
hc = HoverCurve(x=X, y=mean, pen=hoverpen, antialias=True)
hc.setFlag(QGraphicsItem.ItemIsSelectable, False)
self.graph.addItem(hc)
self.graph.addItem(meancurve)
legend.addItem(meancurve, " {}".format(self.classes[i]))
q1, q2, q3 = np.nanpercentile(group_data.X, [25, 50, 75], axis=0)
# TODO: implement and use a box plot item
errorbar = pg.ErrorBarItem(x=X,
y=mean,
bottom=np.clip(mean - q1, 0, mean - q1),
top=np.clip(q3 - mean, 0, q3 - mean),
beam=0.5)
self.graph.addItem(errorbar)
groups.append(
namespace(data=group_data,
indices=indices,
profiles=curve,
hovercurves=hovercurves,
mean=meancurve,
boxplot=errorbar))
self.__groups = groups
self.__update_visibility()
self.__update_tooltips()
class XChartWidgetItem(QGraphicsPathItem):
def __init__(self):
super(XChartWidgetItem, self).__init__()
self.setAcceptHoverEvents(True)
# set default information
self._chartType = None
self._pieCenter = QPointF(0, 0)
self._subpaths = []
self._keyColors = {}
self._ellipses = []
self._keyToolTips = {}
self._showPointsInLine = True
self._shaded = True
self._dragData = {}
self._radius = 6
self._title = ''
self._color = self.randomColor()
self._alternateColor = self._color.lighter(140)
self._points = []
self._barSize = 30
self._orientation = Qt.Horizontal
self._pieAxis = Qt.YAxis
self._pointRadius = 6
self._horizontalOffset = 0
self._verticalOffset = 0
self._hoveredPath = None
self._dirty = False
self._buildData = {}
def addPoint(self, x, y):
"""
Adds a new chart point to this item.
:param x | <variant>
y | <variant>
"""
self._points.append((x, y))
self._dirty = True
def alternateColor(self):
"""
Returns the alternate color for this item.
:return <QColor>
"""
return QColor(self._alternateColor)
def barSize(self):
"""
Returns the size that the bar chart should be rendered with.
:return <int>
"""
return self._barSize
def chartType(self):
"""
Returns the chart type for this item. If no type is explicitely set,
then the scenes chart type will be utilized.
:return <XChartScene.Type>
"""
if (self._chartType):
return self._chartType
scene = self.scene()
if (not scene):
return 0
return scene.chartType()
def clear(self):
"""
Clears the chart points from this item.
"""
self._points = []
self._dirty = True
def color(self):
"""
Returns the primary color for this item.
:return <QColor>
"""
return QColor(self._color)
def dragData(self, x=None, y=None):
"""
Returns any drag information that will be used from this chart item.
:return <QMimeData> || None
"""
# look for specific drag information for this item
first = (x, y)
second = (x, None)
third = (None, y)
fourth = (None, None)
for key in (first, second, third, fourth):
data = self._dragData.get(key)
if data:
return data
return None
def hasCustomType(self):
"""
Returns true if this item defines its own chart type.
:return <bool>
"""
return self._chartType != None
def horizontalRuler(self):
"""
Returns the horizontal ruler for this widget item.
:return <projexui.widgets.xchartwidget.XChartRuler> || None
"""
if (not self.scene()):
return None
return self.scene().horizontalRuler()
def horizontalOffset(self):
"""
Returns the horizontal offset for this item.
:return <int>
"""
return self._horizontalOffset
def hoverMoveEvent(self, event):
"""
Tracks whether or not this item is being hovered.
:param event | <QEvent>
"""
point = event.pos()
found_key = ''
found = None
for key, value, subpath in self._subpaths:
if subpath.contains(point):
found = subpath
found_key = key
break
if found:
# update the tooltip
tip = self.keyToolTip(found_key)
if (tip):
widget = self.scene().chartWidget()
anchor = XPopupWidget.Anchor.RightCenter
# show the popup widget
XPopupWidget.showToolTip(tip,
anchor=anchor,
parent=widget,
foreground=self.color().darker(120),
background=self.alternateColor())
if (found != self._hoveredPath):
self._hoveredPath = found
self.update()
def hoverLeaveEvent(self, event):
"""
Tracks whether or not this item is being hovered.
:param event | <QEvent>
"""
super(XChartWidgetItem, self).hoverEnterEvent(event)
self._hoveredPath = None
self.update()
def isShaded(self):
"""
Returns the shaded state for this item.
:return <bool>
"""
return self._shaded
def keyColor(self, key):
"""
Returns a color for the inputed key (used in pie charts).
:param key | <str>
:return <QColor>
"""
self._keyColors.setdefault(str(key), self.color())
return self._keyColors[str(key)]
def keyToolTip(self, key):
"""
Returns the tool tip for this key.
:param key | <str>
:return <str>
"""
return self._keyToolTips.get(str(key), '')
def mousePressEvent(self, event):
"""
Creates the drag event for this item.
:param event | <QMousePressEvent>
"""
near_x, near_y = self.nearestPoint(event.pos())
data = self.dragData(x=near_x, y=near_y)
self.startDrag(data)
super(XChartWidgetItem, self).mousePressEvent(event)
def nearestPoint(self, pos):
"""
Returns the nearest graphing point for this item based on the
inputed graph position.
:param pos | <QPoint>
:return (<variant> x, <variant> y)
"""
# lookup subpaths
for x, y, path in self._subpaths:
if path.contains(pos):
return (x, y)
return (None, None)
def orientation(self):
"""
Returns the orienatation for this item (used in bar charts).
:return <Qt.Orienation>
"""
return self._orientation
def paint(self, painter, option, widget):
"""
Draws this item with the inputed painter.
:param painter | <QPainter>
rect | <QRect>
"""
if self._dirty:
self.rebuild()
scene = self.scene()
if not scene:
return
grid = scene.gridRect()
typ = self.chartType()
# draw the line chart
if typ == XChartScene.Type.Line:
painter.setRenderHint(painter.Antialiasing)
# draw the path area
area = self._buildData.get('path_area')
if area and self.isShaded():
clr = QColor(self.color())
clr.setAlpha(120)
painter.setPen(Qt.NoPen)
painter.setBrush(clr)
painter.drawPath(area)
# draw the line data
pen = QPen(self.color())
pen.setWidth(2)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
painter.drawPath(self.path())
if (self.showPointsInLine()):
palette = QApplication.palette()
pen = QPen(palette.color(palette.Base))
pen.setWidth(2)
painter.setBrush(self.color())
painter.setPen(pen)
for point in self._ellipses:
painter.drawEllipse(point, self.pointRadius(),
self.pointRadius())
# draw a bar chart
elif typ == XChartScene.Type.Bar:
painter.setRenderHint(painter.Antialiasing)
pen = QPen(self.color())
pen.setWidth(1)
painter.setPen(pen)
for key, value, sub_path in self._subpaths:
gradient = QLinearGradient()
clr = QColor(self.color())
if (sub_path != self._hoveredPath):
clr.setAlpha(130)
gradient.setColorAt(0.0, clr.lighter(140))
gradient.setColorAt(0.1, clr.lighter(120))
gradient.setColorAt(0.25, clr.lighter(110))
gradient.setColorAt(1.0, clr.lighter(105))
if (self.orientation() == Qt.Horizontal):
gradient.setStart(0, sub_path.boundingRect().top())
gradient.setFinalStop(0, sub_path.boundingRect().bottom())
else:
gradient.setStart(sub_path.boundingRect().left(), 0)
gradient.setFinalStop(sub_path.boundingRect().right(), 0)
painter.setBrush(gradient)
painter.drawPath(sub_path)
# draw a simple pie chart (calculated by scene)
elif typ == XChartScene.Type.Pie:
painter.setRenderHint(painter.Antialiasing)
center = self.pieCenter()
radius = self.radius()
for key, value, sub_path in self._subpaths:
clr = self.keyColor(key)
gradient = QRadialGradient(QPointF(0, 0), radius)
a = QColor(clr.lighter(140))
b = QColor(clr.lighter(110))
a.setAlpha(40)
b.setAlpha(80)
# look for mouse over
if (sub_path == self._hoveredPath):
a.setAlpha(100)
b.setAlpha(200)
gradient.setColorAt(0, a)
gradient.setColorAt(1, b)
pen = QPen(clr)
pen.setWidth(1)
painter.setBrush(gradient)
painter.setPen(pen)
painter.drawPath(sub_path)
def pieAxis(self):
"""
Returns the axis that is used as the pie value for this item.
:return <Qt.Axis>
"""
return self._pieAxis
def pieCenter(self):
"""
Returns the center point for the pie for this item.
:return <QPointF>
"""
return self._pieCenter
def pointRadius(self):
"""
Returns the radius for individual points on the line.
:return <int>
"""
return self._pointRadius
def randomColor(self):
"""
Generates a random color.
:return <QColor>
"""
r = random.randint(120, 180)
g = random.randint(120, 180)
b = random.randint(120, 180)
return QColor(r, g, b)
def radius(self):
"""
Returns the radius for this item for the pie chart.
:return <float>
"""
return self._radius
def rebuild(self):
"""
Rebuilds the item based on the current points.
"""
scene = self.scene()
if not scene:
return
self._subpaths = []
grid = scene.gridRect()
typ = self.chartType()
hruler = scene.horizontalRuler()
vruler = scene.verticalRuler()
path = QPainterPath()
area = QPainterPath()
self._buildData.clear()
self._buildData['path_area'] = area
self.setPos(0, 0)
# draw a line item
if typ == XChartScene.Type.Line:
first = True
pos = None
home = None
self._ellipses = []
points = self.points()
if (self.orientation() == Qt.Horizontal):
points.sort(hruler.compareValues, key=lambda x: x[0])
else:
points.sort(vruler.compareValues, key=lambda y: y[1])
points.reverse()
for x, y in self.points():
pos = scene.mapFromChart(x, y)
if first:
home = QPointF(pos.x(), grid.bottom())
area.moveTo(home)
area.lineTo(pos)
path.moveTo(pos)
self._ellipses.append(pos)
first = False
else:
path.lineTo(pos)
area.lineTo(pos)
self._ellipses.append(pos)
if pos and home:
area.lineTo(pos.x(), grid.bottom())
area.lineTo(home)
# draw a bar item
elif typ == XChartScene.Type.Bar:
barsize = self.barSize()
horiz = self.orientation() == Qt.Horizontal
for x, y in self.points():
pos = scene.mapFromChart(x, y)
subpath = QPainterPath()
if horiz:
r = min(grid.bottom() - pos.y(), 8)
subpath.moveTo(pos.x() - barsize / 2.0, grid.bottom())
subpath.lineTo(pos.x() - barsize / 2.0, pos.y() + r)
subpath.quadTo(pos.x() - barsize / 2.0, pos.y(),
pos.x() - barsize / 2.0 + r, pos.y())
subpath.lineTo(pos.x() + barsize / 2.0 - r, pos.y())
subpath.quadTo(pos.x() + barsize / 2.0, pos.y(),
pos.x() + barsize / 2.0,
pos.y() + r)
subpath.lineTo(pos.x() + barsize / 2.0, grid.bottom())
subpath.lineTo(pos.x() - barsize / 2.0, grid.bottom())
else:
subpath.moveTo(grid.left(), pos.y() - barsize / 2.0)
subpath.lineTo(pos.x(), pos.y() - barsize / 2.0)
subpath.lineTo(pos.x(), pos.y() + barsize / 2.0)
subpath.lineTo(grid.left(), pos.y() + barsize / 2.0)
subpath.lineTo(grid.left(), pos.y() - barsize / 2.0)
path.addPath(subpath)
self._subpaths.append((x, y, subpath))
# draw a pie chart
elif typ == XChartScene.Type.Pie:
if self.orientation() == Qt.Horizontal:
key_index = 0
value_index = 1
value_ruler = self.verticalRuler()
else:
key_index = 1
value_index = 0
value_ruler = self.horizontalRuler()
pie_values = {}
for point in self.points():
key = point[key_index]
value = point[value_index]
pie_values.setdefault(key, [])
pie_values[key].append(value)
for key, values in pie_values.items():
pie_values[key] = value_ruler.calcTotal(values)
total = max(1, value_ruler.calcTotal(pie_values.values()))
# calculate drawing parameters
center = self.pieCenter()
radius = self.radius()
diameter = radius * 2
angle = 0
bound = QRectF(-radius, -radius, diameter, diameter)
for key, value in sorted(pie_values.items(), key=lambda x: x[1]):
# calculate the percentage
perc = float(value) / total
# calculate the angle as the perc * 360
item_angle = perc * 360
self.setPos(center)
sub_path = QPainterPath()
sub_path.arcTo(bound, angle, item_angle)
sub_path.lineTo(0, 0)
path.addPath(sub_path)
self._subpaths.append((key, value, sub_path))
angle += item_angle
self.setPath(path)
self._dirty = False
def points(self):
"""
Returns a list of the points for this item.
:return [(<variant> x, <variant> y), ..]
"""
return self._points
def setAlternateColor(self, color):
"""
Sets the alternate color for this widget to the inputed color.
:param color | <QColor>
"""
self._alternateColor = QColor(color)
def setChartType(self, chartType):
"""
Sets the chart type for this item. Setting the item to a None chart
type will signal it to use the default scenes chart type.
:param chartType | <XChartScene.Type>
"""
self._chartType = chartType
self._dirty = True
def setColor(self, color):
"""
Sets the color for this widget to the inputed color.
:param color | <QColor>
"""
self._color = QColor(color)
self.setAlternateColor(self._color.lighter(140))
def setDirty(self, state=True):
"""
Sets whether or not this item is dirty.
:param state | <bool>
"""
self._dirty
def setDragData(self, data, x=None, y=None):
"""
Sets the drag data for this chart item to the inputed data.
:param data | <QMimeData> || None
"""
self._dragData[(x, y)] = data
def setKeyColor(self, key, color):
"""
Sets the color used when rendering pie charts.
:param key | <str>
color | <QColor>
"""
self._keyColors[str(key)] = QColor(color)
def setKeyToolTip(self, key, tip):
"""
Sets the tool tip for the specified key.
:param key | <str>
tip | <str>
"""
self._keyToolTips[str(key)] = tip
def setHorizontalOffset(self, offset):
"""
Sets the horizontal offset for this item.
:param offset | <int>
"""
self._horizontalOffset = offset
def setPieCenter(self, center):
"""
Sets the center for the pie for the chart.
:param center | <QPointF>
"""
self._pieCenter = center
def setPointRadius(self, radius):
"""
Sets the point radius for this line.
:param radius | <int>
"""
self._pointRadius = radius
def setPoints(self, points):
"""
Sets the points values for this chart widget item.
:param points | [(<variant> x, <variant> y), ..]
"""
self._points = points[:]
def setPos(self, *args):
super(XChartWidgetItem, self).setPos(*args)
if (self._horizontalOffset or self._verticalOffset):
offset = QPointF(self._horizontalOffset, self._verticalOffset)
super(XChartWidgetItem, self).setPos(self.pos() + offset)
def setPieAxis(self, pieAxis):
"""
Sets the axis that will be used for the pie chart for this item. This
will only apply when the item itself defines itself as a pie chart,
otherwise, the scene will determine it when the scene is rendered as a
pie chart.
:param pieAxis | <Qt.Axis>
"""
self._pieAxis = pieAxis
def setRadius(self, radius):
"""
Sets the radius size for this item.
:param radius | <float>
"""
self._radius = radius
def setShaded(self, state):
"""
Sets whether or not to shade line items in this graph.
:param state | <bool>
"""
self._shaded = state
def setShowPointsInLine(self, state):
"""
Sets whether or not to show points in line mode.
:param state | <bool>
"""
self._showPointsInLine = state
def setTitle(self, title):
"""
Sets the title text for this chart widget item.
:param title | <str>
"""
self._title = title
def startDrag(self, data):
"""
Starts dragging information from this chart widget based on the
dragData associated with this item.
"""
if not data:
return
widget = self.scene().chartWidget()
drag = QDrag(widget)
drag.setMimeData(data)
drag.exec_()
def showPointsInLine(self):
"""
Returns whether or not to show points in the line.
:return <bool>
"""
return self._showPointsInLine
def title(self):
"""
Returns the title for this item.
:return <str>
"""
return self._title
def verticalRuler(self):
"""
Returns the vertical ruler for this widget item.
:return <projexui.widgets.xchartwidget.XChartRuler> || None
"""
if (not self.scene()):
return None
return self.scene().verticalRuler()
def paint(self, painter, option, widget):
"""
Draws this item with the inputed painter.
:param painter | <QPainter>
rect | <QRect>
"""
if self._dirty:
self.rebuild()
scene = self.scene()
if not scene:
return
grid = scene.gridRect()
typ = self.chartType()
# draw the line chart
if typ == XChartScene.Type.Line:
painter.setRenderHint(painter.Antialiasing)
# draw the path area
area = self._buildData.get('path_area')
if area and self.isShaded():
clr = QColor(self.color())
clr.setAlpha(120)
painter.setPen(Qt.NoPen)
painter.setBrush(clr)
painter.drawPath(area)
# draw the line data
pen = QPen(self.color())
pen.setWidth(2)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
painter.drawPath(self.path())
if (self.showPointsInLine()):
palette = QApplication.palette()
pen = QPen(palette.color(palette.Base))
pen.setWidth(2)
painter.setBrush(self.color())
painter.setPen(pen)
for point in self._ellipses:
painter.drawEllipse(point, self.pointRadius(),
self.pointRadius())
# draw a bar chart
elif typ == XChartScene.Type.Bar:
painter.setRenderHint(painter.Antialiasing)
pen = QPen(self.color())
pen.setWidth(1)
painter.setPen(pen)
for key, value, sub_path in self._subpaths:
gradient = QLinearGradient()
clr = QColor(self.color())
if (sub_path != self._hoveredPath):
clr.setAlpha(130)
gradient.setColorAt(0.0, clr.lighter(140))
gradient.setColorAt(0.1, clr.lighter(120))
gradient.setColorAt(0.25, clr.lighter(110))
gradient.setColorAt(1.0, clr.lighter(105))
if (self.orientation() == Qt.Horizontal):
gradient.setStart(0, sub_path.boundingRect().top())
gradient.setFinalStop(0, sub_path.boundingRect().bottom())
else:
gradient.setStart(sub_path.boundingRect().left(), 0)
gradient.setFinalStop(sub_path.boundingRect().right(), 0)
painter.setBrush(gradient)
painter.drawPath(sub_path)
# draw a simple pie chart (calculated by scene)
elif typ == XChartScene.Type.Pie:
painter.setRenderHint(painter.Antialiasing)
center = self.pieCenter()
radius = self.radius()
for key, value, sub_path in self._subpaths:
clr = self.keyColor(key)
gradient = QRadialGradient(QPointF(0, 0), radius)
a = QColor(clr.lighter(140))
b = QColor(clr.lighter(110))
a.setAlpha(40)
b.setAlpha(80)
# look for mouse over
if (sub_path == self._hoveredPath):
a.setAlpha(100)
b.setAlpha(200)
gradient.setColorAt(0, a)
gradient.setColorAt(1, b)
pen = QPen(clr)
pen.setWidth(1)
painter.setBrush(gradient)
painter.setPen(pen)
painter.drawPath(sub_path)
def _setup_plot(self):
"""Setup the plot with new curve data."""
assert self.data is not None
legend = self.graph.plotItem.addLegend(offset=(-30, 30))
data, domain = self.data, self.data.domain
if is_discrete(domain.class_var):
class_col_data, _ = data.get_column_view(domain.class_var)
group_indices = [np.flatnonzero(class_col_data == i)
for i in range(len(domain.class_var.values))]
else:
group_indices = [np.arange(len(data))]
X = np.arange(1, len(domain.attributes)+1)
groups = []
for i, indices in enumerate(group_indices):
if self.classes:
color = self.class_colors[i]
else:
color = QColor(Qt.darkGray)
group_data = data[indices, :]
plot_x, plot_y, connect = disconnected_curve_data(group_data.X, x=X)
color.setAlpha(200)
lightcolor = QColor(color.lighter(factor=150))
lightcolor.setAlpha(150)
pen = QPen(color, 2)
pen.setCosmetic(True)
lightpen = QPen(lightcolor, 1)
lightpen.setCosmetic(True)
hoverpen = QPen(pen)
hoverpen.setWidth(2)
curve = pg.PlotCurveItem(
x=plot_x, y=plot_y, connect=connect,
pen=lightpen, symbolSize=2, antialias=True,
)
self.graph.addItem(curve)
hovercurves = []
for index, profile in zip(indices, group_data.X):
hcurve = HoverCurve(x=X, y=profile, pen=hoverpen,
antialias=True)
hcurve.setToolTip('{}'.format(index))
hcurve._data_index = index
hovercurves.append(hcurve)
self.graph.addItem(hcurve)
mean = np.nanmean(group_data.X, axis=0)
meancurve = pg.PlotDataItem(
x=X, y=mean, pen=pen, size=5, symbol="o", pxMode=True,
symbolSize=5, antialias=True
)
hoverpen = QPen(hoverpen)
hoverpen.setWidth(5)
hc = HoverCurve(x=X, y=mean, pen=hoverpen, antialias=True)
hc.setFlag(QGraphicsItem.ItemIsSelectable, False)
self.graph.addItem(hc)
self.graph.addItem(meancurve)
legend.addItem(meancurve, " {}".format(self.classes[i]))
q1, q2, q3 = np.nanpercentile(group_data.X, [25, 50, 75], axis=0)
# TODO: implement and use a box plot item
errorbar = pg.ErrorBarItem(
x=X, y=mean,
bottom=np.clip(mean - q1, 0, mean - q1),
top=np.clip(q3 - mean, 0, q3 - mean),
beam=0.5
)
self.graph.addItem(errorbar)
groups.append(
namespace(
data=group_data, indices=indices, profiles=curve,
hovercurves=hovercurves, mean=meancurve, boxplot=errorbar)
)
self.__groups = groups
self.__update_visibility()
self.__update_tooltips()
def _setup_plot(self):
"""Setup the plot with new curve data."""
assert self.data is not None
self.graph.clear()
data, domain = self.data, self.data.domain
var = domain[self.group_var]
class_col_data, _ = data.get_column_view(var)
group_indices = [np.flatnonzero(class_col_data == i)
for i in range(len(self.classes))]
self.graph.getAxis('bottom').setTicks([
[(i+1, str(a)) for i, a in enumerate(self.graph_variables)]
])
X = np.arange(1, len(self.graph_variables)+1)
groups = []
for i, indices in enumerate(group_indices):
if len(indices) == 0:
groups.append(None)
else:
if self.classes:
color = self.class_colors[i]
else:
color = QColor(Qt.darkGray)
group_data = data[indices, self.graph_variables]
plot_x, plot_y, connect = disconnected_curve_data(group_data.X, x=X)
color.setAlpha(200)
lightcolor = QColor(color.lighter(factor=150))
lightcolor.setAlpha(150)
pen = QPen(color, 2)
pen.setCosmetic(True)
lightpen = QPen(lightcolor, 1)
lightpen.setCosmetic(True)
curve = pg.PlotCurveItem(
x=plot_x, y=plot_y, connect=connect,
pen=lightpen, symbolSize=2, antialias=True,
)
self.graph.addItem(curve)
mean = np.nanmean(group_data.X, axis=0)
meancurve = pg.PlotDataItem(
x=X, y=mean, pen=pen, size=5, symbol="o", pxMode=True,
symbolSize=5, antialias=True
)
self.graph.addItem(meancurve)
q1, q2, q3 = np.nanpercentile(group_data.X, [25, 50, 75], axis=0)
# TODO: implement and use a box plot item
errorbar = pg.ErrorBarItem(
x=X, y=mean,
bottom=np.clip(mean - q1, 0, mean - q1),
top=np.clip(q3 - mean, 0, q3 - mean),
beam=0.5
)
self.graph.addItem(errorbar)
groups.append(
namespace(
data=group_data, indices=indices,
profiles=curve, mean=meancurve,
boxplot=errorbar)
)
self.__groups = groups
self.__update_visibility()
class Dial(QGraphicsItem):
"""
Dial
"""
def __init__(self):
super(Dial, self).__init__()
self.angle = 0
# Colors
self.color = QColor(120, 120, 120, 255)
self.notchColor = QColor(115, 115, 115, 255)
self.normalBorderColor = QColor( 255, 255, 255, 30 )
self.selectedBorderColor = QColor( 255, 191, 0, 102 )
self.textColor = QColor( 30, 30, 30, 255 )
self.shadowColor = QColor(0, 0, 0, 75)
self.selectedShadowColor = QColor( 100, 100, 100, 255 )
# Settings
self.width, self.height = 75, 75
# Drop Shadow
self.shadowBlurRadius = 8
self.shadow = QGraphicsDropShadowEffect()
self.shadow.setBlurRadius(self.shadowBlurRadius)
self.shadow.setOffset(0, 0.5)
self.shadow.setColor(self.shadowColor)
self.setGraphicsEffect(self.shadow)
# Painter Definitions
self.pen = QPen()
gradient = QRadialGradient(self.boundingRect().center() + QPointF(0, -20), 80)
gradient.setColorAt(0, self.color.lighter(117))
gradient.setColorAt(1, self.color)
self.brush = QBrush(gradient)
self.font = QFont()
self.pen.setWidth(1)
self.pen.setColor(self.normalBorderColor)
self.brush.setColor(self.color)
self.font.setPointSize(10)
# Nodegraph Definitions
self.dragPoint = None
self.dragAngle = 0
self.dragFactor = 0
# Notch Specifications
self.notch = DialNotch()
self.notch.setParentItem(self)
self.updateNotch()
def boundingRect(self):
"""
Overrides QGraphicsItem's boundingRect() virtual public function and
returns a valid bounding rect based on calculated width and height.
"""
return QRectF(0, 0, self.width, self.height).adjusted(
-self.shadowBlurRadius, -self.shadowBlurRadius,
self.shadowBlurRadius, self.shadowBlurRadius)
def paint(self, painter, option, widget):
"""
Overrides QGraphicsItem's paint() virtual public function.
"""
painter.setPen(self.pen)
painter.setBrush(self.brush)
painter.drawEllipse(self.boundingRect())
def mousePressEvent(self, event):
self.dragPoint = event.scenePos()
self.dragAngle = self.angle
part = self.height / 2
distance = event.pos().y() - part
if distance == 0:
self.dragFactor = 0
else:
self.dragFactor = part / distance
def mouseMoveEvent(self, event):
scenePos = event.scenePos()
d = scenePos - self.dragPoint
self.angle = self.dragAngle + d.x() * self.dragFactor
self.updateNotch()
def mouseReleaseEvent(self, event):
self.dragPoint = None
self.dragAngle = 0
def updateNotch(self):
f = 0.02
dx = (self.width - self.notch.width) / 2
dy = (self.height - self.notch.height) / 2
x = math.sin(math.radians(self.angle)) * dx + dx
y = math.cos(math.radians(self.angle)) * dy + dy
self.notch.setPos(x, y)
class DialNotch(QGraphicsItem):
"""
DialNotch
"""
def __init__(self):
super(DialNotch, self).__init__()
self.setAcceptHoverEvents(True)
# Colors
self.color = QColor(125, 125, 125, 255)
self.normalBorderColor = QColor( 255, 255, 255, 30 )
self.selectedBorderColor = QColor( 255, 191, 0, 102 )
self.textColor = QColor( 30, 30, 30, 255 )
self.shadowColor = QColor(0, 0, 0, 75)
self.selectedShadowColor = QColor( 100, 100, 100, 255 )
# Settings
self.width, self.height = 12, 12
self.highlighted = False
# Painter Definitions
self.pen = QPen()
self.pen.setWidth(1)
self.pen.setColor(self.normalBorderColor)
gradient = QRadialGradient(self.boundingRect().center() + QPointF(0, 1), self.width / 2.0)
gradient.setColorAt(0, self.color)
gradient.setColorAt(0.5, self.color)
gradient.setColorAt(1, self.color.darker(120))
self.brush = QBrush(gradient)
gradient = QRadialGradient(self.boundingRect().center() + QPointF(0, 1), self.width / 2.0)
gradient.setColorAt(0, self.color.lighter(110))
gradient.setColorAt(0.5, self.color.lighter(110))
gradient.setColorAt(1, self.color.darker(120).lighter(110))
self.highlightBrush = QBrush(gradient)
# Other
self.tracking = False
self.angle = None
def boundingRect(self):
"""
Overrides QGraphicsItem's boundingRect() virtual public function and
returns a valid bounding rect based on calculated width and height.
"""
return QRectF(0, 0, self.width, self.height)
def paint(self, painter, option, widget):
"""
Overrides QGraphicsItem's paint() virtual public function.
"""
painter.setPen(self.pen)
painter.setBrush(self.brush)
if self.highlighted:
painter.setBrush(self.highlightBrush)
painter.drawEllipse(self.boundingRect())
def highlight(self, value):
self.highlighted = value
self.update()
def hoverEnterEvent(self, event):
self.highlight(True)
def hoverLeaveEvent(self, event):
self.highlight(False)
def mousePressEvent(self, event):
self.tracking = True
parent = self.parentItem()
parent.dragPoint = event.pos()
parent.dragAngle = parent.angle
def mouseMoveEvent(self, event):
if self.tracking:
parent = self.parentItem()
d = event.scenePos() - parent.boundingRect().center()
if self.angle:
a = self.angle - math.degrees(math.atan2(-d.y(),d.x()))
else:
a = math.degrees(math.atan2(-d.y(),d.x()))
self.angle = a
parent.angle = parent.dragAngle - a
parent.updateNotch()
def mouseReleaseEvent(self, event):
self.tracking = False
parent = self.parentItem()
parent.dragPoint = None
parent.dragAngle = 0
self.angle = None
def _setup_plot(self):
"""Setup the plot with new curve data."""
assert self.data is not None
self.graph.clear()
data, domain = self.data, self.data.domain
var = domain[self.group_var]
class_col_data, _ = data.get_column_view(var)
group_indices = [
np.flatnonzero(class_col_data == i)
for i in range(len(self.classes))
]
self.graph.getAxis('bottom').setTicks([[
(i + 1, str(a)) for i, a in enumerate(self.graph_variables)
]])
X = np.arange(1, len(self.graph_variables) + 1)
groups = []
for i, indices in enumerate(group_indices):
if len(indices) == 0:
groups.append(None)
else:
if self.classes:
color = self.class_colors[i]
else:
color = QColor(Qt.darkGray)
group_data = data[indices, self.graph_variables]
plot_x, plot_y, connect = disconnected_curve_data(group_data.X,
x=X)
color.setAlpha(200)
lightcolor = QColor(color.lighter(factor=150))
lightcolor.setAlpha(150)
pen = QPen(color, 2)
pen.setCosmetic(True)
lightpen = QPen(lightcolor, 1)
lightpen.setCosmetic(True)
curve = pg.PlotCurveItem(
x=plot_x,
y=plot_y,
connect=connect,
pen=lightpen,
symbolSize=2,
antialias=True,
)
self.graph.addItem(curve)
mean = np.nanmean(group_data.X, axis=0)
meancurve = pg.PlotDataItem(x=X,
y=mean,
pen=pen,
size=5,
symbol="o",
pxMode=True,
symbolSize=5,
antialias=True)
self.graph.addItem(meancurve)
q1, q2, q3 = np.nanpercentile(group_data.X, [25, 50, 75],
axis=0)
# TODO: implement and use a box plot item
errorbar = pg.ErrorBarItem(x=X,
y=mean,
bottom=np.clip(
mean - q1, 0, mean - q1),
top=np.clip(q3 - mean, 0,
q3 - mean),
beam=0.5)
self.graph.addItem(errorbar)
groups.append(
namespace(data=group_data,
indices=indices,
profiles=curve,
mean=meancurve,
boxplot=errorbar))
self.__groups = groups
self.__update_visibility()
class Theme(object):
# enum PortType
THEME_PORT_SQUARE = 0
THEME_PORT_POLYGON = 1
# enum List
THEME_MODERN_DARK = 0
THEME_MODERN_DARK_TINY = 1
THEME_MODERN_DARK_TEXT = 2
THEME_MODERN_LIGHT = 3
THEME_CLASSIC_DARK = 4
THEME_PROTOCLASSIC_DARK = 5
THEME_NEOCLASSIC_DARK = 6
THEME_OOSTUDIO = 7
THEME_MAX = 8
# enum BackgroundType
THEME_BG_SOLID = 0
THEME_BG_GRADIENT = 1
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
