class UIBaseColors(ConstantGroup):
RED = QtGui.QBrush(QtGui.QColor(230, 132, 131))
LIGHT_SKY_BLUE = QtGui.QBrush(QtGui.QColor(135, 206, 250))
DARK_YELLOW = QtGui.QBrush(QtGui.QColor(222, 158, 46))
class UIPrimTypeColors(ConstantGroup):
HAS_ARCS = UIBaseColors.DARK_YELLOW
NORMAL = QtGui.QBrush(QtGui.QColor(227, 227, 227))
INSTANCE = UIBaseColors.LIGHT_SKY_BLUE
MASTER = QtGui.QBrush(QtGui.QColor(118, 136, 217))
def cropColor(self, color):
self._cropColor = QtGui.QColor(*color)
self.cropPen = QtGui.QPen(self._cropColor, 3, QtCore.Qt.DotLine)
import uuid
import logging
import pprint
from functools import partial
from slither import api
from slither.core import executor
from qt import QtGui, QtWidgets
from vortex.ui.graphics import graphicsdatamodel
from vortex.ui import application
import attributewidgets
logger = logging.getLogger(__name__)
ATTRIBUTETYPEMAP = {
'Quaternion': {
"color": QtGui.QColor(126.999945, 24.999944999999997,
24.999944999999997),
"widget": None
},
'color': {
"color": QtGui.QColor(22.999980000000015, 255, 255)
},
'matrix4': {
"color":
QtGui.QColor(174.99987000000002, 130.00001999999998,
114.99990000000001)
},
'multi': {
"color": QtGui.QColor(255, 255, 255)
},
'vector2D': {
"color": QtGui.QColor(147.000105, 102.0, 156.000075)
class Panel(QtWidgets.QGraphicsWidget):
color = QtGui.QColor(0.0, 0.0, 0.0, 125)
def __init__(self,
objectModel,
ioType,
acceptsContextMenu=False,
parent=None):
super(Panel, self).__init__(parent=parent)
self.model = objectModel
self.ioType = ioType
layout = QtWidgets.QGraphicsLinearLayout(parent=self)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(1)
layout.setOrientation(QtCore.Qt.Vertical)
self.attributeContainer = graphicitems.ItemContainer(parent=self)
layout.addItem(self.attributeContainer)
self.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding))
self.acceptsContextMenu = acceptsContextMenu
self.setLayout(layout)
self.setFlags(self.flags() & QtCore.Qt.ItemIsSelectable)
self.setZValue(100)
self.refresh()
def refresh(self):
currentModel = self.model
if currentModel is None:
return
self.attributeContainer.clear()
for attr in currentModel.attributes(self.ioType == "Input",
self.ioType == "Output", 3):
self.addAttribute(attr)
def mousePressEvent(self, event):
if event.button() == QtCore.Qt.RightButton and self.acceptsContextMenu:
self._contextMenu(QtGui.QCursor.pos())
return
super(Panel, self).mousePressEvent(event)
def addAttribute(self, attribute):
plug = plugwidget.PlugContainer(attribute,
parent=self.attributeContainer)
layout = plug.layout()
if attribute.isInput() and self.ioType == "Input":
if attribute.isArray() or attribute.isCompound():
plug.inCrossItem.show()
plug.inCircle.show()
plug.outCircle.hide()
# # insert the inCircle to the far right
layout.insertItem(3, plug.inCircle)
layout.insertItem(2, plug.inCrossItem)
# we switch this around for panels because the model input would be connected to another input
# making it difficult to which is the start point and end point of a connection
plug.inCircle.ioType = "Output"
layout.insertStretch(2, 1)
else:
if attribute.isArray() or attribute.isCompound():
plug.outCrossItem.show()
plug.outCircle.show()
plug.inCircle.hide()
# # insert the outCircle to the far left
layout.insertItem(0, plug.outCircle)
layout.insertItem(1, plug.outCrossItem)
layout.itemAt(layout.count() - 1)
plug.inCircle.ioType = "Input"
plug.setTextAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
# swap the layout alignment
plug.setInputAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
plug.layout().setAlignment(
plug.inCrossItem, QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
plug.layout().setAlignment(
plug.outCrossItem, QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
plug.setOutputAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
self.attributeContainer.addItem(plug)
def attributeItem(self, attributeModel):
for attr in iter(self.attributeContainer.items()):
if attr.model == attributeModel:
return attr
def paint(self, painter, option, widget):
rect = self.windowFrameRect()
painter.fillRect(rect, self.color)
painter.setPen(QtGui.QPen(self.color, 3))
super(Panel, self).paint(painter, option, widget)
def _contextMenu(self, pos):
app = self.scene().uiApplication
menu = app.createContextMenu(app.currentModel)
if menu:
menu.exec_(pos)
self.refresh()
def handleConnectionDrop(self, model):
if not model.objectModel.canCreateAttributes():
return
print "drop", self.ioType, model
class ConnectionEdge(QtWidgets.QGraphicsPathItem):
"""Class to deal with the Connection path between two plugs
You set the style of the path with setLineStyle(QtCore.Qt.Style)
"""
contextMenuRequested = QtCore.Signal(object)
defaultColor = QtGui.QColor(138, 200, 0)
selectedColor = QtGui.QColor(255, 255, 255)
hoverColor = QtGui.QColor(255, 255, 255)
CUBIC = 0
LINEAR = 1
def __init__(self,
source,
destination=None,
curveType=CUBIC,
color=defaultColor):
super(ConnectionEdge, self).__init__()
self.curveType = curveType
self._sourcePlug = source
self._destinationPlug = destination
self._sourcePoint = source.center()
self._destinationPoint = destination.center(
) if destination is not None else None
self.defaultPen = QtGui.QPen(color, 1.25, style=QtCore.Qt.DashLine)
self.defaultPen.setDashPattern([1, 2, 2, 1])
self.selectedPen = QtGui.QPen(self.selectedColor,
1.7,
style=QtCore.Qt.DashLine)
self.selectedPen.setDashPattern([1, 2, 2, 1])
self.hoverPen = QtGui.QPen(self.hoverColor,
1.7,
style=QtCore.Qt.DashLine)
self.selectedPen.setDashPattern([1, 2, 2, 1])
self.hovering = False
self.setPen(self.defaultPen)
self.setZValue(-1)
self.setFlags(self.ItemIsFocusable | self.ItemIsSelectable
| self.ItemIsMovable)
self.setCurveType(curveType)
self.update()
def setWidth(self, width):
lineWidth = width * 1.25
self.defaultPen.setWidth(width)
self.selectedPen.setWidth(lineWidth)
self.hoverPen.setWidth(lineWidth)
def setCurveType(self, cType):
if cType == "Linear":
self.setAsLinearPath()
elif cType == "Cubic":
self.setAsCubicPath()
def setLineStyle(self, qStyle):
self.defaultPen.setStyle(qStyle)
self.selectedPen.setStyle(qStyle)
self.hoverPen.setStyle(qStyle)
def setAsLinearPath(self):
path = QtGui.QPainterPath()
path.moveTo(self._sourcePoint)
path.lineTo(self._destinationPoint)
self.curveType = ConnectionEdge.LINEAR
self.setPath(path)
def setAsCubicPath(self):
path = QtGui.QPainterPath()
path.moveTo(self._sourcePoint)
dx = self._destinationPoint.x() - self._sourcePoint.x()
dy = self._destinationPoint.y() - self._sourcePoint.y()
ctrl1 = QtCore.QPointF(self._sourcePoint.x() + dx * 0.50,
self._sourcePoint.y() + dy * 0.1)
ctrl2 = QtCore.QPointF(self._sourcePoint.x() + dx * 0.50,
self._sourcePoint.y() + dy * 0.9)
path.cubicTo(ctrl1, ctrl2, self._destinationPoint)
self.curveType = ConnectionEdge.CUBIC
self.setPath(path)
def hoverLeaveEvent(self, event):
super(ConnectionEdge, self).hoverEnterEvent(event)
self.hovering = False
self.update()
def hoverEnterEvent(self, event):
super(ConnectionEdge, self).hoverEnterEvent(event)
self.hovering = True
self.update()
def paint(self, painter, option, widget):
if self.isSelected():
painter.setPen(self.selectedPen)
elif self.hovering:
painter.setPen(self.hoverPen)
else:
painter.setPen(self.defaultPen)
painter.drawPath(self.path())
def updatePosition(self):
"""Update the position of the start and end of the edge
"""
self._destinationPoint = self.destinationPlug.center()
self._sourcePoint = self.sourcePlug.center()
self.updatePath()
def updatePath(self):
if self.curveType == ConnectionEdge.CUBIC:
self.setAsCubicPath()
else:
self.setAsLinearPath()
def connect(self, src, dest):
"""Create a connection between the src plug and the destination plug
:param src: Plug
:param dest: Plug
:return: None
"""
if not src and dest:
return
self._sourcePlug = src
self._destinationPlug = dest
src.addConnection(self)
dest.addConnection(self)
def disconnect(self):
"""Remove the connection between the source and destination plug
"""
self._sourcePlug.removeConnection(self)
self._destinationPlug.removeConnection(self)
self._sourcePlug = None
self._destinationPlug = None
@property
def sourcePoint(self):
"""Return the source point
:return: QtCore.QPointF()
"""
return self._sourcePoint
@sourcePoint.setter
def sourcePoint(self, point):
"""Sets the source point and updates the path
:param point: QtCore.QPointF
"""
self._sourcePoint = point
self.updatePath()
@property
def destinationPoint(self):
"""return the destination point
:return: QtCore.QPointF
"""
return self._destinationPoint
@destinationPoint.setter
def destinationPoint(self, point):
"""Sets the destination point and updates the path
:param point: QtCore.QPointF
"""
self._destinationPoint = point
self.updatePath()
@property
def sourcePlug(self):
"""Return the source plug
:return: Plug
"""
return self._sourcePlug
@sourcePlug.setter
def sourcePlug(self, plug):
"""Sets the source plug and update the path
:param plug: Plug
"""
self._sourcePlug = plug
self._sourcePoint = plug.center()
self._sourcePlug.parentObject().connections.add(plug)
self.updatePath()
@property
def destinationPlug(self):
"""Returns the destination plug
:return: Plug
"""
return self._destinationPlug
@destinationPlug.setter
def destinationPlug(self, plug):
self._destinationPlug = plug
self._destinationPoint = plug.center()
self._destinationPlug.parentObject().connections.add(self)
self.updatePath()
def close(self):
"""
"""
if self.scene() is not None:
self.scene().removeItem(self)
def mousePressEvent(self, event):
if event.button() == QtCore.Qt.LeftButton:
event.accept()
if self.isSelected():
self.setSelected(False)
else:
self.setSelected(True)
self.update()
self._destinationPoint = event.pos()
def mouseMoveEvent(self, event):
self._destinationPoint = self.mapToScene(event.pos())
def contextMenuEvent(self, event):
menu = QtWidgets.QMenu(self)
self.contextMenuRequested.emit(menu)
menu.exec_(event.scenePos())
event.setAccepted(True)
def _stroke(self, painter, x, y, width, height):
rect = QtCore.QRect(x, y, width, height)
painter.setPen(self._defaultPen)
painter.setBrush(QtGui.QBrush(QtGui.QColor(0.0, 0.0, 0.0, 0.0)))
painter.drawRect(rect)
class UIPropertyValueSourceColors(ConstantGroup):
FALLBACK = UIBaseColors.DARK_YELLOW
TIME_SAMPLE = QtGui.QBrush(QtGui.QColor(177, 207, 153))
DEFAULT = UIBaseColors.LIGHT_SKY_BLUE
NONE = QtGui.QBrush(QtGui.QColor(140, 140, 140))
VALUE_CLIPS = QtGui.QBrush(QtGui.QColor(230, 150, 230))
class GraphicsText(QtWidgets.QGraphicsWidget):
_font = QtGui.QFont("Roboto-Bold.ttf", 8)
_font.setLetterSpacing(QtGui.QFont.PercentageSpacing, 110)
_fontMetrics = QtGui.QFontMetrics(_font)
textChanged = QtCore.Signal(str)
_color = QtGui.QColor(200, 200, 200)
def __init__(self, text, parent=None):
super(GraphicsText, self).__init__(parent=parent)
self._previousText = text
self._item = QtWidgets.QGraphicsTextItem(text, parent=self)
self._item.setDefaultTextColor(self._color)
self._item.setFont(self._font)
self._item.document().contentsChanged.connect(self.onTextChanged)
self.setPreferredSize(self.size)
self.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed,
QtWidgets.QSizePolicy.Fixed))
self._item.setFlags(QtWidgets.QGraphicsItem.ItemIsSelectable
| QtWidgets.QGraphicsItem.ItemIsFocusable
| QtWidgets.QGraphicsItem.ItemIsMovable)
self._item.setTextInteractionFlags(QtCore.Qt.TextEditorInteraction)
option = self._item.document().defaultTextOption()
option.setWrapMode(QtGui.QTextOption.NoWrap)
self._item.document().setDefaultTextOption(option)
self.allowHoverHighlight = False
self.setAcceptHoverEvents(True)
self.adjustSize()
def onTextChanged(self):
newText = self._item.document().toPlainText()
if newText != self._previousText:
self._previousText = newText
self.textChanged.emit(newText)
def setTextFlags(self, flags):
self._item.setFlags(flags)
@property
def font(self):
return self._item.font()
@font.setter
def font(self, value):
return self._item.setFont(value)
@property
def text(self):
return self._item
@text.setter
def text(self, text):
self._item.setPlainText(text)
self._item.update()
self.setPreferredSize(
QtCore.QSizeF(self._item.textWidth(),
self._font.pointSizeF() + 10))
def onResize(self, width):
fmWidth = self._fontMetrics.width(self.item.toPlainText())
newWidth = min(fmWidth, width)
if width > fmWidth:
newWidth = width
self._item.setTextWidth(newWidth)
self.setPreferredSize(newWidth, self.textHeight())
@property
def size(self):
return QtCore.QSizeF(self._item.textWidth(), self.height)
@property
def height(self):
return self._item.document().documentLayout().documentSize().height(
) + 2
@property
def color(self):
return self._item.defaultTextColor()
@color.setter
def color(self, color):
self._item.setDefaultTextColor(color)
self.update()
def highlight(self):
highlightColor = self.color.lighter(150)
self.color = highlightColor
def unhighlight(self):
self.color = self._color
def hoverEnterEvent(self, event):
if self.allowHoverHighlight:
self.highlight()
super(GraphicsText, self).hoverEnterEvent(event)
def hoverLeaveEvent(self, event):
if self.allowHoverHighlight:
self.unhighlight()
super(GraphicsText, self).hoverLeaveEvent(event)
def iconColorizedLayered(cls,
iconNames,
size=16,
colors=None,
iconScaling=None,
tintColor=None):
""" Layers multiple icons with various colours into one qicon. Maybe can replace icon colorized
:param iconNames: the icon name from the library. Allow string or list for convenience
:type iconNames: list or basestring
:param size: the uniform icon size
:type size: int
:param colors: 3 tuple for the icon color
:type colors: list of tuple
:return: the colorized icon
:param overlayName: The name of the icon that will be overlayed on top of the original icon
:param overlayColor: The colour of the overlay
:rtype: QtGui.QIcon
"""
defaultSize = 1
if isinstance(iconNames, basestring):
iconNames = [iconNames]
elif isinstance(iconNames, list):
iconNames = list(iconNames) # copy
if isinstance(iconScaling, list):
iconScaling = list(iconScaling) # copy
if not isinstance(colors, list):
colors = [colors]
else:
colors = list(colors) # copy
if iconNames is []:
print "WARNING: iconNames cannot be none for iconColorizedLayered"
p = QtGui.QPixmap(16, 16)
p.fill(QtGui.QColor(255, 255, 255))
# Fill out the colours to match the length of iconNames
if colors is None or (len(iconNames) > len(colors)):
colors = colors or []
colors += [None] * (len(iconNames) - len(colors))
# Fill out the sizes to match the length of iconNames
if iconScaling is None or len(iconNames) > len(iconScaling):
iconScaling = iconScaling or []
iconScaling += [defaultSize] * (len(iconNames) - len(iconScaling))
iconLargest = cls.icon(iconNames.pop(0), -1)
if not iconLargest:
return iconLargest
origSize = iconLargest.availableSizes()[0]
col = colors.pop(0)
scale = iconScaling.pop(0)
if col is not None:
pixmap = cls.colorPixmap(iconLargest.pixmap(origSize * scale), col)
else:
pixmap = iconLargest.pixmap(origSize * scale)
# Layer the additional icons
for i, name in enumerate(iconNames):
if name is None:
continue
overlayIcon = cls.icon(name, -1)
overlayPixmap = overlayIcon.pixmap(origSize * iconScaling[i])
cls.addOverlay(pixmap, overlayPixmap, colors[i])
# Tint
if tintColor is not None:
cls.tint(pixmap, tintColor)
pixmap = pixmap.scaled(QtCore.QSize(size,
size), QtCore.Qt.KeepAspectRatio,
QtCore.Qt.SmoothTransformation)
return QtGui.QIcon(pixmap)
class UIPrimTreeColors(ConstantGroup):
SELECTED = QtGui.QBrush(QtGui.QColor(189, 155, 84))
SELECTED_HOVER = QtGui.QBrush(QtGui.QColor(227, 186, 101))
ANCESTOR_OF_SELECTED = QtGui.QBrush(QtGui.QColor(189, 155, 84, 50))
ANCESTOR_OF_SELECTED_HOVER = QtGui.QBrush(QtGui.QColor(189, 155, 84, 100))
UNSELECTED_HOVER = QtGui.QBrush(QtGui.QColor(70, 70, 70))
def insertRow(self, rowdata):
r = self.rowCount()
super(TableWidget, self).insertRow(r)
self.definerow(r)
self.fillrow(r, rowdata)
def setColor(self, row, column):
color = qg.QColorDialog.getColor(qc.Qt.green, self)
if color.isValid():
print(color, row, column)
self.fillfunction[column](row, column, color)
if __name__ == '__main__':
import sys
app = qg.QApplication(sys.argv)
data = [['Row 1', 0, 0, qg.QColor(0, 0, 255)],
['Row 2', 0, 0, qg.QColor(0, 255, 0)],
['Row 3', 0, 0, qg.QColor(255, 0, 0)],
['Row 4', 0, 0, qg.QColor(127, 127, 0)]]
# data= numpy.array(data)
w = TableWidget(['Name', 'V', 'E', 'Color'])
#
w.insertrows(data)
# for ii,rowdata in enumerate(data):
# w.insertRow(rowdata)
# for ii,rowdata in enumerate(data):
# w.fillrow(ii,rowdata)
#
w.show()
sys.exit(app.exec_())
class LogRecordModel(QtCore.QAbstractTableModel):
foreground_map = {
logging.ERROR: QtGui.QColor(255, 0, 0),
logging.CRITICAL: QtGui.QColor(255, 255, 255),
}
background_map = {
logging.DEBUG: QtGui.QColor(192, 255, 255),
logging.WARNING: QtGui.QColor(255, 255, 192),
#logging.ERROR: QtGui.QColor(255, 192, 192),
logging.CRITICAL: QtGui.QColor(255, 0, 0),
}
style_map = {
logging.ERROR: 'bold',
logging.CRITICAL: 'bold',
}
def __init__(self, parent, records, columns, capacity=0):
super(LogRecordModel, self).__init__(parent)
self._records = records
self._columns = columns
self.font = parent.font()
self._capacity = capacity
def columnCount(self, index):
if index.isValid():
result = 0
else:
visible = [col for col in self._columns if col.visible]
result = len(visible)
return result
def rowCount(self, index):
if self._records is None or index.isValid():
result = 0
else:
result = len(self._records)
return result
def data(self, index, role=Qt.DisplayRole):
result = None
if index.isValid():
record = self._records[index.row()]
if role == Qt.DisplayRole:
try:
viscols = [c for c in self._columns if c.visible]
col = viscols[index.column()]
v = getattr(record, col.name)
result = v
except Exception:
logger.exception('Error')
elif role == Qt.BackgroundColorRole:
result = self.background_map.get(record.levelno)
elif role == Qt.TextColorRole:
result = self.foreground_map.get(record.levelno)
elif role == Qt.FontRole:
QFont = QtGui.QFont
result = None
style = self.style_map.get(record.levelno)
if style:
result = QFont(self.font)
if 'bold' in style:
result.setWeight(QFont.Bold)
if 'italic' in style:
result.setStyle(QFont.StyleItalic)
elif role == MessageRole: # special role used for searching
result = record.message
return result
def headerData(self, section, orientation, role):
result = None
if orientation == Qt.Horizontal and role == Qt.DisplayRole:
try:
visible = [col.title for col in self._columns if col.visible]
result = visible[section]
except IndexError:
pass
return result
def add_record(self, record):
pos = len(self._records)
if self._capacity and pos >= self._capacity:
self.beginRemoveRows(invindex, 0, 0)
self._records.popleft()
self.endRemoveRows()
pos -= 1
self.beginInsertRows(invindex, pos, pos)
self._records.append(record)
self.endInsertRows()
def clear(self):
if hasattr(self._records, 'clear'):
self._records.clear()
else:
del self._records[:]
self.reset()
def get_record(self, pos):
return self._records[pos]
class NavigationGraphicsView(QtGui.QGraphicsView):
'''Graphics view for dataset navigation.
The view usually displays an auto-scalled low resolution overview
of the scene with a red box indicating the area currently displayed
in the high resolution view.
:SIGNALS:
* :attr:`mousePressed`
* :attr:`mouseMoved`
'''
BOXCOLOR = QtGui.QColor(QtCore.Qt.red)
#: SIGNAL: it is emitted when a mouse button is presses on the view
#:
#: :param point:
#: the scene position
#: :param mousebutton:
#: the ID of the pressed button
#: :param dragmode:
#: current darg mode
#:
#: :C++ signature: `void mousePressed(QPointF, Qt::MouseButtons,
#: QGraphicsView::DragMode)`
mousePressed = QtCore.Signal(QtCore.QPointF, QtCore.Qt.MouseButtons,
QtGui.QGraphicsView.DragMode)
#: SIGNAL: it is emitted when the mouse is moved on the view
#:
#: :param point:
#: the scene position
#: :param mousebutton:
#: the ID of the pressed button
#: :param dragmode:
#: current darg mode
#:
#: :C++ signature: `void mouseMoved(QPointF, Qt::MouseButtons,
#: QGraphicsView::DragMode)`
mouseMoved = QtCore.Signal(QtCore.QPointF, QtCore.Qt.MouseButtons,
QtGui.QGraphicsView.DragMode)
def __init__(self, parent=None, **kwargs):
super(NavigationGraphicsView, self).__init__(parent, **kwargs)
self._viewbox = None
self._autoscale = True
self.setMouseTracking(True)
def getbox(self):
return self._viewbox
def setbox(self, box):
assert isinstance(box, (QtCore.QRect, QtCore.QRectF))
self._viewbox = box
if self.isVisible():
# @WARNING: calling "update" on the scene causes a repaint of
# *all* attached views and for each view the entire
# exposedRect is updated.
# Using QGraphicsView.invalidateScene with the
# QtGui.QGraphicsScene.ForegroundLayer parameter
# should be faster and repaint only one layer of the
# current view.
# @TODO: check
#self.invalidateScene(self.sceneRect(),
# QtGui.QGraphicsScene.ForegroundLayer)
self.scene().update()
viewbox = property(getbox, setbox, doc='viewport box in scene coordinates')
def drawForeground(self, painter, rect):
if not self.viewbox:
return
pen = painter.pen()
try:
box = self.viewbox.intersected(self.sceneRect())
painter.setPen(self.BOXCOLOR)
painter.drawRect(box)
#painter.drawConvexPolygon(self.viewbox) #@TODO: check
finally:
painter.setPen(pen)
def fitInView(self, rect=None, aspectRatioMode=QtCore.Qt.KeepAspectRatio):
if not rect:
scene = self.scene()
if scene:
rect = scene.sceneRect()
else:
return
QtGui.QGraphicsView.fitInView(self, rect, aspectRatioMode)
def _getAutoscale(self):
return self._autoscale
def _setAutoscale(self, flag):
self._autoscale = bool(flag)
if self._autoscale:
self.fitInView()
else:
self.setMatrix(QtGui.QMatrix())
self.update()
autoscale = property(_getAutoscale, _setAutoscale)
def resizeEvent(self, event):
if self.autoscale:
self.fitInView()
return QtGui.QGraphicsView.resizeEvent(self, event)
# @TODO: use event filters
def mousePressEvent(self, event):
pos = self.mapToScene(event.pos())
self.mousePressed.emit(pos, event.buttons(), self.dragMode())
return QtGui.QGraphicsView.mousePressEvent(self, event)
def mouseMoveEvent(self, event):
pos = self.mapToScene(event.pos())
self.mouseMoved.emit(pos, event.buttons(), self.dragMode())
return QtGui.QGraphicsView.mouseMoveEvent(self, event)
class BaseDataSource(QtCore.QObject):
enabledColor = QtGui.QColor(200, 200, 220)
disabledColor = enabledColor.darker(200)
def __init__(self, headerText=None, model=None, parent=None):
super(BaseDataSource, self).__init__()
self._parent = parent
self.children = []
self.model = model
self._headerText = headerText or ""
def width(self):
return 0
def userObject(self, index):
if index in xrange(self.rowCount()):
return self.children[index]
def userObjects(self):
return self.children
def setUserObjects(self, objects):
pass
def isRoot(self):
"""Determines if this item is the root of the tree
:return:
:rtype:
"""
return True if not self.parent else False
def rowCount(self):
"""Returns the total row count for the dataSource defaults to the len of the dataSource children
:rtype: int
"""
return len(self.children)
def columnCount(self):
return 1
def parentSource(self):
"""Returns the parent of this node
:rtype: Node
"""
return self._parent
def index(self):
if self._parent is not None and self._parent.children:
return self._parent.children.index(self)
return 0
def child(self, index):
"""
:param index: the column index
:type index: int
"""
if index in xrange(self.rowCount()):
return self.children[index]
def insertChild(self, index, child):
if child not in self.children:
self.children.insert(index, child)
child.parent = self
def append(self, child):
if child not in self.children:
self.children.append(child)
def setData(self, index, value):
"""Sets the text value of this node at the specified column
:param index: The column index
:type index: int
:return: the new text value for this nodes column index
:rtype: str
"""
pass
def data(self, index):
"""The text for this node or column. index parameter with a value of 0 is
the first column.
:param index: The column index for the item
:type index: int
:return: the column text
:rtype: str
"""
return ""
def toolTip(self, index):
"""The tooltip for the index.
:param index: The column index for the item
:type index: int
:rtype: str
"""
model = self.model
if model is None:
return ""
columns = list(model.columnDataSources)
msg = self.headerText(index) + ":" + str(self.data(index)) + "\n"
for i in columns:
msg += i.headerText(index) + ":" + str(i.data(self, index)) + "\n"
return msg
def icon(self, index):
"""The icon for the index.
:param index: The column index for the item
:type index: int
:rtype: QtGui.QIcon
"""
pass
def headerIcon(self):
"""Returns the column header icon
:rtype: QtGui.QIcon
"""
return QtGui.QIcon()
def headerText(self, index):
"""Returns the column header text
:return: the header value
:rtype: str
"""
return self._headerText
def headerVerticalText(self, index):
"""The Vertical header text, if the return type is None then no text is displayed, an empty string will
produce a gap in the header.
:param index: The column index for the item
:type index: int
:rtype: str or None
"""
return None
def headerVerticalIcon(self, index):
"""The Vertical header icon
:param index: The column index for the item
:type index: int
:rtype: QtGui.QIcon()
"""
return QtGui.QIcon()
def isEditable(self, index):
"""Determines if this node can be editable e.g set text. Defaults to False
:param index: The column index for the item
:type index: int
:return: whether or not this node is editable, defaults to False
:rtype: bool
"""
return True
def isEnabled(self, index):
"""Determines if this node is enabled
:param index: The column index for the item
:type index: int
:return: whether or not this node is enabled, defaults to True
:rtype: bool
"""
return True
def supportsDrag(self, index):
"""
:param index: the column index
:type index: int
"""
return False
def supportsDrop(self, index):
"""
:param index: the column index
:type index: int
"""
return False
def mimeTypes(self):
pass
def mimeData(self, indices):
return QtCore.QMimeData()
def dropMimeData(self, index):
"""
:param index: the column index
:type index: int
"""
return False
def mimeText(self, index):
"""
:param index: the column index
:type index: int
"""
return
def isSelectable(self, index):
"""
:param index: the column index
:type index: int
"""
return True
def foregroundColor(self, index):
"""
:param index: the column index
:type index: int
"""
if self.isEnabled(index):
return self.enabledColor
return self.disabledColor
def backgroundColor(self, index):
"""
:param index: the column index
:type index: int
"""
return None
def displayChangedColor(self, index):
"""
:param index: the column index
:type index: int
"""
return None
def alignment(self, index):
"""
:param index: the column index
:type index: int
"""
return QtCore.Qt.AlignVCenter
def font(self, index):
"""
:param index: the column index
:type index: int
"""
return
def isCheckable(self, index):
"""
:param index: the column index
:type index: int
"""
return False
def insertColumnDataSources(self, index, count):
"""
:param index: the column index
:type index: int
"""
return False
def removeColumnDataSources(self, index, count):
"""
:param index: the column index
:type index: int
"""
return False
def removeRowDataSource(self, index):
"""
:param index: the column index
:type index: int
"""
return False
def removeRowDataSources(self, index, count):
"""
:param index: the column index
:type index: int
"""
return False
def insertRowDataSources(self, index, count):
"""
:param index: the column index
:type index: int
"""
return None
def insertRowDataSource(self, index):
"""
:param index: the column index
:type index: int
"""
return False
def onVerticalHeaderSelection(self, index):
"""Triggered by the table view(if this source is attached to one) when the vertical header is clicked
:param index: the row index
:type index: int
"""
pass
def contextMenu(self, menu):
pass
def sort(self, index=0, order=QtCore.Qt.DescendingOrder):
"""This sort function purpose is for sorting the data by column.
:param index: the column index to sort
:type index: int
:param order: The Qt order
:type order: int
"""
def element(key):
return key[1]
toSort = [(obj, self.data(i))
for i, obj in enumerate(self.userObjects())]
if order == QtCore.Qt.DescendingOrder:
results = [i[0] for i in sorted(toSort, key=element, reverse=True)]
else:
results = [i[0] for i in sorted(toSort, key=element)]
self.setUserObjects(results)
