def testEmptyCopy(self):
from copy import deepcopy
original = QColor()
copy = deepcopy([original])[0]
self.assert_(original is not copy)
self.assertEqual(original, copy)
del original
self.assertEqual(copy, QColor())
def setObjectColorRGB(self, rgb):
"""
TOWRITE
:param `rgb`: TOWRITE
:type `rgb`: `QRgb`_
"""
objPen.setColor(QColor(rgb))
lwtPen.setColor(QColor(rgb))
class CustomFBX_Label(qg.QLabel):
_pen_text = QPen(QColor(180, 255, 180, 200), 1, qc.Qt.SolidLine)
_pen_Shadow = QPen(QColor(9, 10, 12), 1, qc.Qt.SolidLine)
_pen_border = QPen(QColor(9, 10, 12), 2, qc.Qt.SolidLine)
_pen_clear = QPen(QColor(0, 0, 0, 0), 1, qc.Qt.SolidLine)
_fontSize = 16
_fontMargin = 2
def __init__(self, *args, **kwargs):
super(CustomFBX_Label, self).__init__(*args, **kwargs)
font = qg.QFont()
font.setPointSize(self._fontSize)
font.setFamily('Source Code Pro SemiBold')
self.setFont(font)
self.setMargin(self._fontMargin)
self.setStyleSheet("background-color: transparent;")
self.setMargin(self._fontMargin)
#self.setStyleSheet("background-color: transparent;")
def paintEvent(self, event):
painter = qg.QPainter(self)
option = qg.QStyleOption()
option.initFrom(self)
x = option.rect.x()
y = option.rect.y()
height = option.rect.height() - 1
width = option.rect.width() - 1
painter.setRenderHint(qg.QPainter.Antialiasing)
painter.setRenderHint(qg.QPainter.TextAntialiasing)
alignment = (qc.Qt.AlignHCenter | qc.Qt.AlignVCenter)
text = self.text()
if text == '': return
font = self.font()
font_metrics = qg.QFontMetrics(font)
text_width = font_metrics.width(text)
text_height = font.pointSize()
textPath = qg.QPainterPath()
textPath.addText((width - text_width) / 2,
height - ((height - text_height) / 2), font, text)
if self.isEnabled():
pens_text = self._pen_text
pens_shadow = self._pen_Shadow
painter.setPen(pens_shadow)
painter.drawPath(textPath)
painter.setPen(pens_text)
painter.drawText(x, y, width, height, alignment, text)
def __init__(self, color, diameter, parent=None):
QCheckBox.__init__(self, parent)
self.color1 = QColor(color)
self.color2 = QColor(50, 50, 50)
self.resize(QSize(2 * float(diameter), diameter))
self.setStyleSheet("background-color: rgb(0, 0, 0);\n" +
"color: rgb(255, 255, 255);\n")
self.setChecked(True)
self.setEnabled(True)
self._enable = True
def __init__(self, color=QColor(127, 127, 127)):
"""Initialize ColorPicker.
Args:
color -- The default color of the picker
"""
super().__init__()
self.color = QColor(color)
self._set_icon(self.color)
QObject.connect(self, SIGNAL("clicked()"), self.on_button_clicked)
def __init__(self, parent):
'''Initialization'''
QStyledItemDelegate.__init__(self, parent)
self.bg_color = QColor('#000000')
self.bg_alternate_color = QColor('#333333')
self.new_bg_color = QColor('#0044dd')
self.new_bg_alternate_color = QColor('#223399')
self.user_color = QColor('#7AB4F5')
self.time_color = QColor('#7AB4F5')
self.replyto_color = QColor('#7AB4F5')
self.text_color = QColor('#FFFFFF')
self.separator_color = QColor('#000000')
self.fsize = 1.0
self.fm = None
self.minifm = None
self.normFont = None
self.miniFont = None
# print os.path.join(os.path.dirname(__file__),
# 'icons', 'reply.png')
self.reply_icon = QPixmap(
os.path.join(os.path.dirname(__file__), 'icons', 'reply.png'))
# print dir(self.reply_icon)
self.retweet_icon = QPixmap(
os.path.join(os.path.dirname(__file__), 'icons', 'retweet.png'))
self.geoloc_icon = QPixmap(
os.path.join(os.path.dirname(__file__), 'icons', 'geoloc.png'))
def __init__(self, parent=None):
QToolButton.__init__(self, parent)
self.badge_counter = 0x00
self.badge_size = 25
self.redGradient = QRadialGradient(0.0, 0.0, 17.0, self.badge_size - 3,
self.badge_size - 3)
self.redGradient.setColorAt(0.0, QColor(0xe0, 0x84, 0x9b))
self.redGradient.setColorAt(0.5, QColor(0xe9, 0x34, 0x43))
self.redGradient.setColorAt(1.0, QColor(0xdc, 0x0c, 0x00))
def paint(self, painter, option, index):
name_rect = option.rect.adjusted(4, 0, -4, 0)
item_rect = option.rect.adjusted(1, 1, -1, 0)
painter.fillRect(item_rect, QColor('#fe6'))
painter.save()
painter.setPen(QPen(QColor(0, 0, 0, 255)))
painter.drawText(name_rect, Qt.AlignHCenter, index.data())
painter.restore()
def realRender(self, painter, renderPath): # TODO/PORT: Still needs work.
"""
TOWRITE
:param `painter`: TOWRITE
:type `painter`: `QPainter`_
:param `renderPath`: TOWRITE
:type `renderPath`: `QPainterPath`_
"""
color1 = objectColor() #QColor # lighter color
color2 = color1.darker(150) #QColor # darker color
# If we have a dark color, lighten it
darkness = color1.lightness() #int
threshold = 32 #int #TODO: This number may need adjusted or maybe just add it to settings.
if darkness < threshold:
color2 = color1
if not darkness:
color1 = QColor(
threshold, threshold,
threshold) # lighter() does not affect pure black
else:
color1 = color2.lighter(100 + threshold)
count = renderPath.elementCount() # int
for i in range(0, count - 1): # for(int i = 0; i < count-1; ++i);
elem = renderPath.elementAt(i) # QPainterPath::Element
next = renderPath.elementAt(i + 1) # QPainterPath::Element
if next.isMoveTo():
continue
elemPath = QPainterPath()
elemPath.moveTo(elem.x, elem.y)
elemPath.lineTo(next.x, next.y)
renderPen = QPen(QColor(0, 0, 0, 0))
renderPen.setWidthF(0)
painter.setPen(renderPen)
stroker = QPainterPathStroker()
stroker.setWidth(0.35)
stroker.setCapStyle(Qt.RoundCap)
stroker.setJoinStyle(Qt.RoundJoin)
realPath = stroker.createStroke(elemPath) # QPainterPath
painter.drawPath(realPath)
grad = QLinearGradient(elemPath.pointAtPercent(0.5),
elemPath.pointAtPercent(0.0))
grad.setColorAt(0, color1)
grad.setColorAt(1, color2)
grad.setSpread(QGradient.ReflectSpread)
painter.fillPath(realPath, QBrush(grad))
def __init__(self, pos, edge):
''' Set the original control point - with color, shape '''
path = QPainterPath()
path.addEllipse(pos.x() - 5, pos.y() - 5, 10, 10)
super(Controlpoint, self).__init__(path, parent=edge)
self.setPen(QColor(50, 100, 120, 200))
self.setBrush(QColor(200, 200, 210, 120))
self.setFlags(QGraphicsItem.ItemIsSelectable
| QGraphicsItem.ItemIsMovable)
self.edge = edge
self.hide()
def __init__(self):
super(MyProgress, self).__init__()
self.setMaximumHeight(50)
self.maxValue = 100
self.currentValue = 0
self.outLine = QPen(QColor("#999999"))
self.fillColor = QBrush(QColor("green"))
self.textPen = QPen(QColor("black"))
def testDeepCopy(self):
'''QColor deepcopy'''
from copy import deepcopy
original = QColor(0, 0, 255)
copy = deepcopy([original])[0]
self.assert_(original is not copy)
self.assertEqual(original, copy)
del original
self.assertEqual(copy, QColor(0, 0, 255))
def get_status_color(self, obj):
c = QColor(Qt.lightGray)
if obj.visited:
c = QColor(Qt.green)
elif obj.active:
c = QColor('orange')
# if obj.status == 'ran':
# c = QColor('green')
# elif obj.status == 'paused':
# c = QColor('orange')
return c
def __init__(self, parent=None):
super(QConsole, self).__init__(parent)
font = QFont("Monospace", 9)
font.setStyleHint(QFont.TypeWriter)
self.setFont(font)
# self.setFontWeight(QFont.Light)
# self.setFontPointSize(9)
self.setTextColor(QColor("LightGreen"))
p = self.palette()
p.setColor(QPalette.Base, QColor(0, 0, 0))
self.setPalette(p)
self.setText(">\n")
def paint(self, painter):
"""
:param QPainter painter:
:return:
"""
# selection background
if self.selected:
painter.setPen(QColor(0xef, 0xbf, 0xba))
painter.setBrush(QColor(0xef, 0xbf, 0xba))
painter.drawRect(self.x, self.y, self.width, self.height)
x = self.x
# address
if self.disasm_view.show_address:
painter.setPen(Qt.black)
painter.drawText(x, self.y + self._config.disasm_font_ascent,
self._addr)
x += self._addr_width + self.ADDR_SPACING
# mnemonic
painter.setPen(QColor(0, 0, 0x80))
painter.drawText(x, self.y + self._config.disasm_font_ascent,
self._mnemonic)
x += self._mnemonic_width + self.MNEMONIC_SPACING
# operands
for i, op in enumerate(self._operands):
op.x = x
op.y = self.y
op.paint(painter)
x += op.width
if i != len(self._operands) - 1:
# draw the comma
painter.drawText(x, self.y + self._config.disasm_font_ascent,
",")
x += self._config.disasm_font_width * 1
x += self.OPERAND_SPACING
# string
if self._string is not None:
x += self.STRING_SPACING
painter.setPen(Qt.gray)
painter.drawText(x, self.y + self._config.disasm_font_ascent,
self._string)
def formatConverterFunction(format):
if format == qutepart.syntax.TextFormat():
return None # Do not apply default format. Performance optimization
qtFormat = QTextCharFormat()
qtFormat.setForeground(QBrush(QColor(format.color)))
qtFormat.setBackground(QBrush(QColor(format.background)))
qtFormat.setFontItalic(format.italic)
qtFormat.setFontWeight(QFont.Bold if format.bold else QFont.Normal)
qtFormat.setFontUnderline(format.underline)
qtFormat.setFontStrikeOut(format.strikeOut)
return qtFormat
def initUI(self):
# container = QWidget(self)
# container.resize(200, 100);
# container.setStyleSheet("background-color:black;")
font_size = QLabel('Font Size')
font_size.fillColor = QColor(30, 30, 30, 120)
font_size.penColor = QColor("#333333")
grid = QGridLayout()
grid.setContentsMargins(50, 10, 10, 10)
grid.addWidget(font_size, 0, 0)
self.setLayout(grid)
def get_background(self, obj):
if isinstance(obj, ReviewNode):
if not obj.enabled:
c = QColor('#ff8080') # light red
else:
c = QColor(Qt.cyan)
elif obj.skip_configure:
c = QColor('#D05BFF')
elif not obj.enabled:
c = QColor('#ff8080') # light red
else:
c = super(PipelineTreeNode, self).get_background(obj)
return c
def _paint_linear(self, painter):
# selection background
if self.selected:
painter.setPen(QColor(0xef, 0xbf, 0xba))
painter.setBrush(QColor(0xef, 0xbf, 0xba))
painter.drawRect(self.x, self.y, self.width, self.height)
x = self.x
# address
if self.disasm_view.show_address:
painter.setPen(Qt.black)
painter.drawText(x, self.y + self._config.disasm_font_ascent,
self._addr)
x += self._addr_width + self.LINEAR_INSTRUCTION_OFFSET
# TODO: splitter
#painter.setPen(Qt.black)
#painter.drawLine()
# mnemonic
painter.setPen(QColor(0, 0, 0x80))
painter.drawText(x, self.y + self._config.disasm_font_ascent,
self._mnemonic)
x += self._mnemonic_width + self.GRAPH_MNEMONIC_SPACING
# operands
for i, op in enumerate(self._operands):
op.x = x
op.y = self.y
op.paint(painter)
x += op.width
if i != len(self._operands) - 1:
# draw the comma
painter.drawText(x, self.y + self._config.disasm_font_ascent,
",")
x += self._config.disasm_font_width * 1
x += self.GRAPH_OPERAND_SPACING
# string
if self._string is not None:
x += self.GRAPH_STRING_SPACING
painter.setPen(Qt.gray)
painter.drawText(x, self.y + self._config.disasm_font_ascent,
self._string)
def __init__(self, s, parent=None):
"""
Default class constructor.
:param `s`: TOWRITE
:type `s`: QRubberBand.Shape
:param `parent`: Pointer to a parent widget instance.
:type `parent`: `QWidget`_
"""
super(SelectBox, self).__init__(parent)
# private
self._leftBrushColor = QColor()
self._rightBrushColor = QColor()
self._leftPenColor = QColor()
self._rightPenColor = QColor()
self._alpha = 255 # quint8 #: TODO: what is the initial int?
self._dirBrush = QBrush()
self._leftBrush = QBrush()
self._rightBrush = QBrush()
self._dirPen = QPen()
self._leftPen = QPen()
self._rightPen = QPen()
self._boxDir = False #: TODO: is this initial bool value right?
# Default values
self.setColors(QColor(Qt.darkGreen), QColor(Qt.green),
QColor(Qt.darkBlue), QColor(Qt.blue), 32)
def _draw_edges(self, painter, topleft_point, bottomright_point):
# draw edges
if self._edges:
for edge in self._edges:
edge_coords = edge.coordinates
if edge.sort == EdgeSort.BACK_EDGE:
# it's a back edge
# Honey
color = QColor(0xf9, 0xd5, 0x77)
elif edge.sort == EdgeSort.TRUE_BRANCH:
# True branch
# Aqar
color = QColor(0x79, 0xcc, 0xcd)
elif edge.sort == EdgeSort.FALSE_BRANCH:
# False branch
# Tomato
color = QColor(0xf1, 0x66, 0x64)
else:
# Dark Gray
color = QColor(0x56, 0x5a, 0x5c)
pen = QPen(color)
pen.setWidth(2)
painter.setPen(pen)
for from_, to_ in zip(edge_coords, edge_coords[1:]):
start_point = QPointF(*from_)
end_point = QPointF(*to_)
# optimization: don't draw edges that are outside of the current scope
if (start_point.x() > bottomright_point.x() or start_point.y() > bottomright_point.y()) and \
(end_point.x() > bottomright_point.x() or end_point.y() > bottomright_point.y()):
continue
elif (start_point.x() < topleft_point.x() or start_point.y() < topleft_point.y()) and \
(end_point.x() < topleft_point.x() or end_point.y() < topleft_point.y()):
continue
painter.drawPolyline((start_point, end_point))
# arrow
# end_point = self.mapToScene(*edges[-1])
end_point = (edge_coords[-1][0], edge_coords[-1][1])
arrow = [
QPointF(end_point[0] - 3, end_point[1]),
QPointF(end_point[0] + 3, end_point[1]),
QPointF(end_point[0], end_point[1] + 6)
]
brush = QBrush(color)
painter.setBrush(brush)
painter.drawPolygon(arrow)
def __loadColors(self):
self.colors = {}
for columnLabel in StatusColorsDict.keys():
self.colors[columnLabel] = {}
for txt in StatusColorsDict[columnLabel].keys():
color = StatusColorsDict[columnLabel][txt]
self.colors[columnLabel][txt] = QColor(color)
def init(self, parent):
"""
"""
rad = self.factory.radius
if not rad:
rad = 20
if self.control is None:
self.control = qtLED()
scene = QGraphicsScene()
# self.control.setStyleSheet("qtLED { border-style: none; }");
# self.control.setAutoFillBackground(True)
# system background color
scene.setBackgroundBrush(QBrush(QColor(237, 237, 237)))
self.control.setStyleSheet("border: 0px")
self.control.setMaximumWidth(rad+15)
self.control.setMaximumHeight(rad+15)
x, y = 10, 10
cx = x + rad / 1.75
cy = y + rad / 1.75
brush = self.get_color(self.value.state, cx, cy, rad / 2)
pen = QPen()
pen.setWidth(0)
self.led = scene.addEllipse(x, y, rad, rad,
pen=pen,
brush=brush
)
self.control.setScene(scene)
self.value.on_trait_change(self.update_object, 'state')
def __init__(self, parent=None, ast=None):
ast = ast or ogAST.State()
ast.inputString = getattr(ast, 'via', None) or ast.inputString
# Note: ast coordinates are in scene coordinates
super(State, self).__init__(parent=parent,
text=ast.inputString,
x=ast.pos_x,
y=ast.pos_y,
hyperlink=ast.hyperlink)
self.set_shape(ast.width, ast.height)
self.setBrush(QBrush(QColor(255, 228, 213)))
self.terminal_symbol = True
if parent:
try:
# Map AST scene coordinates to get actual position
self.setPos(self.pos() +
self.mapFromScene(ast.pos_x, ast.pos_y))
except TypeError:
self.update_position()
else:
# Use scene coordinates to position
self.setPos(ast.pos_x, ast.pos_y)
self.parser = ogParser
if ast.comment:
Comment(parent=self, ast=ast.comment)
def hoverEnterEvent(self, event):
super(HooverBar, self).hoverEnterEvent(event)
if self.gi == None:
self.gi = QGraphicsRectItem(0, 0, 100, 100)
self.gi.setBrush(QBrush(QColor(0, 64, 0, 192)))
self.gi.setPen(QPen(Qt.transparent))
self.gi.setPos(event.scenePos().x() + 20,
event.scenePos().y() + 20)
x = y = 10
w = 0
for t in self.description:
description = QGraphicsSimpleTextItem()
description.setFont(self.base_font)
description.setBrush(QBrush(Qt.white))
description.setText(t)
description.setParentItem(self.gi)
description.setPos(x, y)
y += description.boundingRect().height()
w = max(w, description.boundingRect().width())
y += x
w += 2 * x
self.gi.setRect(0, 0, w, y)
self.scene().addItem(self.gi)
def _draw_serie(self, painter, ndx_serie, color):
serie = self.data[ndx_serie]
#mainlog.debug(serie)
fill_color = QColor(color)
fill_color.setAlpha(64)
brush = QBrush(fill_color)
pen = QPen()
pen.setCapStyle(Qt.SquareCap)
pen.setColor(color)
qp = QPainterPath()
painter.setPen(pen)
for i in range(len(serie)):
x, y_top, y_below = self._item_coordinates(i)
h = max(1, float(y_top - y_below - 1))
qp.addRect( x,
float(self.y_base-y_top),
float(self.bar_width),
h)
painter.fillPath(qp,brush)
painter.drawPath(qp)
#mainlog.debug("Drawing peak values, juste before {}".format(self._peak_values))
if self._peak_values:
#mainlog.debug("Drawing peak values")
self._draw_peak_values(painter, self._peak_values )
def _create_metallic_roughness_map(self, metal_map, rough_map):
metal = QImage(metal_map)
rough = QImage(rough_map)
metal_pixel = QColor()
metal = metal.convertToFormat(QImage.Format_RGB32)
rough = rough.convertToFormat(QImage.Format_RGB32)
metal_uchar_ptr = metal.bits()
rough_uchar_ptr = rough.bits()
if (not metal.width() == rough.width()
or not metal.height() == rough.height()):
raise RuntimeError(
"Error processing material: {}. Metallic map and roughness map must have same dimensions."
.format(self.maya_node))
width = metal.width()
height = metal.height()
i = 0
for y in range(height):
for x in range(width):
metal_color = struct.unpack('I', metal_uchar_ptr[i:i + 4])[0]
rough_color = struct.unpack('I', rough_uchar_ptr[i:i + 4])[0]
metal_pixel.setRgb(0, qGreen(rough_color), qBlue(metal_color))
metal_uchar_ptr[i:i + 4] = struct.pack('I', metal_pixel.rgb())
i += 4
output = ExportSettings.out_dir + "/" + self.name + "_metalRough.jpg"
return output, metal
class CustomClearLabel(CustomLabel):
_pen_text = QPen(QColor(180, 200, 180, 250), 2, qc.Qt.SolidLine)
_fontSize = 14
_fontMargin = 4
def __init__(self, *args, **kwargs):
super(CustomClearLabel, self).__init__(*args, **kwargs)
def showContextMenu(self, pos):
"""
Shows a context menu to add a node in the graph widget
"""
gpos = self.graphicsView.mapToGlobal(pos)
menu = QMenu()
actionAddNode = menu.addAction("Add Node")
QAction = menu.exec_(gpos)
if (actionAddNode == QAction):
(text,
ok) = QInputDialog.getText(self.graphicsView, "Insert Node Name",
"Please insert a name for the node")
if ok:
if text not in self.nodesToQNodes:
#User clicked on ok. Otherwise do nothing
self.gv.add_node(text)
node = self.gv.get_node(text)
qnode = self.createQtNode(node, 0, 0,
QColor(204, 255, 255))
self.graphicsView.scene().addItem(qnode)
qnode.setPos(self.graphicsView.mapToScene(gpos))
qnode.setPos(qnode.x(), qnode.y() - 200)
self.nodesToQNodes[node] = qnode
else:
msg = QMessageBox()
msg.setText("The node already exists.")
msg.exec_()
self.searchNode(text)
class CustomShortLabel(CustomLabel):
_pen_text = QPen(QColor(250, 250, 250, 220), 1, qc.Qt.SolidLine)
_fontSize = 12
_fontMargin = 3
def __init__(self, *args, **kwargs):
super(CustomShortLabel, self).__init__(*args, **kwargs)
