def paintEvent(self, e):
Part.paintEvent(self, e)
painter = QPainter(self)
color = QColor(self._base.dark(150))
color.setAlpha(150)
painter.setPen(color)
painter.pen().setWidth(2)
painter.drawPolyline(*tuple(self._SYNTH_POINTS))
if not self.songpart is None and self.activeLED.isHidden():
color = QColor('black')
color.setAlpha(200)
painter.setPen(color)
rect = QRect(0, 5, self.width() - 5, self.height() - 5)
painter.drawText(rect,
Qt.AlignRight | Qt.AlignTop,
'[%s]' % self.songpart)
painter.setPen(self._base.light(150))
painter.pen().setWidth(self.margin)
y = self.height() - self.margin
synth = self.data
for start, stop in self.paintNotes:
ratio = 1 - ((stop - synth.localclock.time()) / (stop - start))
if ratio > 0 and ratio <= 1:
width = (self.width() - self.margin * 2) * ratio
painter.drawLine(self.margin, y, width, y)
y -= (self.margin + 3)
painter = None
self.drawText()
def paintEvent(self, e):
Part.paintEvent(self, e)
painter = QPainter(self)
color = QColor(self._base.dark(150))
color.setAlpha(150)
painter.setPen(color)
painter.pen().setWidth(2)
painter.drawPolyline(*tuple(self._SYNTH_POINTS))
painter = None
self.drawText()
def _drawMonthFrame(self):
self.initMonthInfo()
wi = self.month_info
painter = QPainter(self)
pen = painter.pen()
pen.setWidth(Var.line_width)
painter.setPen(pen)
for coord in wi.paint_base_lines:
painter.drawLine(*coord)
# Draw selections
for selection in wi.selections():
painter.fillRect(*selection)
# Draw dates
font = painter.font()
font.setPointSize(wi.cell_height/8)
painter.setFont(font)
for cell_id in range(42):
x, y = wi.getCoordinate(cell_id)
x += wi.cell_width * 74/100
y += wi.cell_height/7
day = wi.getDay(cell_id)
painter.drawText(QPointF(x, y), QString(str(day)))
def paintEvent(self, event):
if not self.tenant:
return
paint = QPainter(self)
for e in self.tenant.edges:
if e == self.selectedEdge:
paint.setPen(self.colors["selected"])
else:
paint.setPen(self.colors["line"])
self.drawArrow(paint, self.vertices[e.e1].x() + self.size / 2, self.vertices[e.e1].y() + self.size / 2,
self.vertices[e.e2].x() + self.size / 2, self.vertices[e.e2].y() + self.size / 2)
for v in self.vertices.keys():
pen = paint.pen()
paint.setPen(Qt.red)
if self.selectedVertex == self.vertices[v]:
paint.drawRect(self.vertices[v])
if isinstance(v, VM):
paint.drawImage(self.vertices[v], self.computericon)
elif isinstance(v, Storage):
paint.drawImage(self.vertices[v], self.storageicon)
elif isinstance(v, NetElement):
if v.router:
paint.drawImage(self.vertices[v], self.routericon)
else:
paint.drawImage(self.vertices[v], self.switchicon)
elif isinstance(v, Vnf):
paint.drawImage(self.vertices[v], self.serviceicon)
elif isinstance(v, Domain):
paint.drawImage(self.vertices[v], self.domainicon)
paint.setPen(self.colors["line"])
if self.edgeDraw:
self.drawArrow(paint, self.curEdge[0].x() + self.size / 2, self.curEdge[0].y() + self.size / 2,
QCursor.pos().x() - self.mapToGlobal(self.geometry().topLeft()).x(),
QCursor.pos().y() - self.mapToGlobal(self.geometry().topLeft()).y())
paint.end()
def draw_centering_guides(image, target_x, target_y, target_w, guide_h):
left_x = target_x - (target_w / 2.0)
right_x = left_x + target_w
top_y = target_y
bottom_y = top_y + guide_h
new_img = image.copy()
if not new_img.format() is QImage.Format_ARGB32_Premultiplied:
new_img = new_img.convertToFormat(QImage.Format_ARGB32_Premultiplied)
painter = QPainter(new_img)
pen = painter.pen()
pen.setColor(QColor(255, 0, 0))
painter.setPen(pen)
painter.drawLine(left_x, top_y, left_x, bottom_y)
painter.drawLine(right_x, top_y, right_x, bottom_y)
painter.end()
return new_img
def paintEvent(self, paint_event):
QFrame.paintEvent(self, paint_event)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
w = self.width()
h = self.height()
if self.horizontal:
self.min_marker = QRectF(w * self.min_value, 4, self.size, self.size)
self.max_marker = QRectF(w * self.max_value - self.size - 1, 4, self.size, self.size)
else:
self.min_marker = QRectF(4, h - h * self.min_value - self.size - 1, self.size, self.size)
self.max_marker = QRectF(4, h - h * self.max_value, self.size, self.size)
pen = painter.pen()
pen.setWidth(0)
pen.setColor(QApplication.palette().background().color().dark())
painter.setPen(pen)
painter.setBrush(self.min_marker_brush)
painter.drawPie(self.min_marker, self.tilt * 16, 180 * 16)
painter.setBrush(self.max_marker_brush)
painter.drawPie(self.max_marker, self.tilt * 16, -180 * 16)
def paintEvent(self, e):
if self.active:
painter = QPainter(self)
pen = painter.pen()
pen.setWidth(self.margin)
pen.setColor(QColor('red').dark(150))
painter.drawRect(0, 0, self.width(), self.height())
def draw_centering_guides(image, target_x, target_y, target_w, guide_h):
left_x = target_x - (target_w / 2.0)
right_x = left_x + target_w
top_y = target_y
bottom_y = top_y + guide_h
new_img = image.copy()
if not new_img.format() is QImage.Format_ARGB32_Premultiplied:
new_img = new_img.convertToFormat(QImage.Format_ARGB32_Premultiplied)
painter = QPainter(new_img)
pen = painter.pen()
pen.setColor(QColor(255, 0, 0))
painter.setPen(pen)
painter.drawLine(left_x, top_y, left_x, bottom_y)
painter.drawLine(right_x, top_y, right_x, bottom_y)
painter.end()
return new_img
def paintEvent(self, paint_event):
QFrame.paintEvent(self, paint_event)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
w = self.width()
h = self.height()
if self.horizontal:
self.min_marker = QRectF(w * self.min_value, 4, self.size,
self.size)
self.max_marker = QRectF(w * self.max_value - self.size - 1, 4,
self.size, self.size)
else:
self.min_marker = QRectF(4, h - h * self.min_value - self.size - 1,
self.size, self.size)
self.max_marker = QRectF(4, h - h * self.max_value, self.size,
self.size)
pen = painter.pen()
pen.setWidth(0)
pen.setColor(QApplication.palette().background().color().dark())
painter.setPen(pen)
painter.setBrush(self.min_marker_brush)
painter.drawPie(self.min_marker, self.tilt * 16, 180 * 16)
painter.setBrush(self.max_marker_brush)
painter.drawPie(self.max_marker, self.tilt * 16, -180 * 16)
def paintEvent(self, e):
painter = QPainter(self)
brush = QBrush(painter.brush())
self.bgcolor.setAlpha(20)
painter.setBrush(self.bgcolor)
painter.drawRect(0, 0, self.width(), self.height())
self.bgcolor.setAlpha(15)
painter.setBrush(self.bgcolor)
painter.drawRect(0, 20, self.width(), self.height()-40)
painter.setBrush(brush)
frame = self.clock.last_beat_frame
x = self.x_for_frametime(frame)
while x < self.width():
x = self.x_for_frametime(frame)
painter.drawLine(x, 0, x, 15)
painter.drawLine(x, self.height(), x, self.height() - 15)
#painter.drawText(QPoint(x+5, 13), str(frame))
frame += self.clock.frames_per_beat()
self.items = [i for i in self.items if i.endtime > self.frametime]
for item in self.items:
x = self.x_for_frametime(item.starttime)
w = self.x_for_frametime(item.endtime) - x
color = QColor(item.color)
color.setAlpha(150)
painter.setPen(color)
pen = painter.pen()
pen.setWidth(3)
painter.setPen(pen)
color.setAlpha(100)
painter.setBrush(color)
painter.drawRect(x, 0, w, self.height())
def paint(self, p: QPainter):
p.setBrush(self.type().color())
p.drawEllipse(self.pos.x(), self.pos.y(), self.size, self.size)
if len(self.lines) > 0:
pen = p.pen()
p.setBrush(self.type().color().darker())
p.setPen(QColor(0, 0, 0, 0))
p.drawEllipse(self.pos.x() + 2, self.pos.y() + 2, self.size - 4, self.size - 4)
p.setPen(pen)
def paintEvent(self, e):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(self.background)
painter.setBrush(self.background)
painter.drawRect(0, 0, self.width(), self.height())
painter.setPen(QColor(255, 255, 255, 200))
self.drawTempo(painter, self.bender.bent)
painter.setPen(self.nominal_base)
painter.setBrush(self.nominal_base.light(200))
painter.pen().setWidth(4)
self.drawTempos(painter, self.nominal)
painter.setPen(self.bent_base)
painter.setBrush(self.bent_base.light(200))
painter.pen().setWidth(2)
self.drawTempos(painter, self.bent)
def paintEvent(self, e):
if self.active:
painter = QPainter(self)
pen = painter.pen()
pen.setWidth(self.margin)
pen.setColor(self.frame_color)
color = QColor(self.frame_color)
color.setAlpha(30)
painter.setBrush(color)
painter.drawRect(0, 0, self.width(), self.height())
def paintEvent(self, e):
""" draw the viewport box. """
WidgetPreview.paintEvent(self, e)
if self.widget:
rect = self.widget.visibleRegion().boundingRect()
x, y, w, h = self._translate(rect)
painter = QPainter(self)
pen = painter.pen()
pen.setWidth(5)
pen.setColor(self.box_color)
painter.setPen(pen)
painter.drawRect(x, y, w, h)
painter.end()
def drawText(self, text=None):
painter = QPainter(self)
color = painter.pen().color()
color.setAlpha(215)
painter.setPen(color)
if text is None:
if self.text:
text = self.text
elif self.data:
text = str(self.data.name)
else:
text = str(self.data)
rect = QRect(5, 0, self.width(), self.height())
painter.drawText(rect, Qt.AlignLeft | Qt.AlignBottom, QString(text))
def paintEvent(self, e):
painter = QPainter(self)
painter.setBrush(self._base)
if self.selected:
painter.pen().setColor(QColor('yellow'))
else:
painter.pen().setColor(self._base.dark(150))
painter.pen().setWidth(self.margin)
painter.drawRect(0, 0, self.width(), self.height())
def gen_font(font_configs, font_type = FONT_TYPES.font01, img_width = 1024, draw_outlines = False):
img_height = HEIGHT_FACTOR
seen_chars = []
game_font = GameFont(width = img_width)
painter = QPainter(game_font.trans)
text_brush = QtGui.QBrush(QColor(255, 255, 255, 255))
painter.setBrush(text_brush)
outline_brush = QtGui.QBrush()
outline_pen = QtGui.QPen(QColor(255, 0, 0, 255), 1, style = Qt.Qt.DotLine, join = Qt.Qt.MiterJoin)
x_pos = 0
y_pos = 0
line_height = LINE_HEIGHT[font_type]
for config in font_configs:
font = QFont(config.family, config.size, config.weight, italic = False)
font.setKerning(False)
metric = QFontMetrics(font)
painter.setFont(font)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.Antialiasing, True)
text_pen = painter.pen()
text_pen.setBrush(QColor(255, 255, 255, 255))
text_pen.setWidthF(config.pen_size)
text_pen.setCapStyle(config.pen_cap)
text_pen.setJoinStyle(config.pen_join)
text_pen.setStyle(Qt.Qt.SolidLine if config.use_pen else Qt.Qt.NoPen)
painter.setPen(text_pen)
for char in sorted(config.chars):
if char in seen_chars:
continue
else:
seen_chars.append(char)
# If we want a character to represent something it's not.
char_to_print = char
if char in config.subs:
char_to_print = config.subs[char]
char_w = metric.width(char_to_print)
if x_pos + char_w > img_width:
x_pos = 0
y_pos += line_height + config.y_margin
if y_pos < 0:
y_pos = 0
if y_pos + line_height > MAX_HEIGHT:
_LOGGER.warning("Ran out of vertical space. Generated font does not include all characters.")
break
game_font.font_data.data.append({'char': char, 'x': x_pos, 'y': y_pos, 'w': char_w, 'h': line_height, 'y_shift': config.y_shift})
path = QPainterPath()
path.addText(x_pos + config.x_offset, y_pos + metric.ascent() + config.y_offset, font, char_to_print)
painter.drawPath(path)
if draw_outlines:
painter.setBrush(outline_brush)
painter.setPen(outline_pen)
painter.setRenderHint(QPainter.Antialiasing, False)
painter.drawRect(x_pos, y_pos, char_w, line_height)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setBrush(text_brush)
painter.setPen(text_pen)
x_pos += char_w + config.x_margin
painter.end()
painter = QPainter(game_font.opaque)
painter.drawImage(game_font.opaque.rect(), game_font.trans, game_font.trans.rect())
painter.end()
# Crop our images so they only take up as much space as they need.
final_height = int(math.ceil(float(y_pos + line_height) / float(HEIGHT_FACTOR)) * HEIGHT_FACTOR)
game_font.trans = game_font.trans.copy(0, 0, img_width, final_height)
game_font.opaque = game_font.opaque.copy(0, 0, img_width, final_height)
return game_font
# if __name__ == '__main__':
# app = QtGui.QApplication(sys.argv)
# chars = load_text(CHAR_LIST)
# We can't have dupes, and why not put them in order while we're at it?
# chars = sorted(make_unique(chars))
# game_font = gen_font(chars)
# game_font.save(SAVE_AS)
### EOF ###
class Meter(QtGui.QWidget):
"""
a PyQt instance of QtMeter from Qt example code
"""
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.value = 0
self.minValue = 0
self.maxValue = 100
self.logo = ""
self.scaleMajor = 10
self.scaleMijor = 10
self.startAngle = 60
self.endAngle = 60
self.crownColor = Qt.blue
self.foreground = Qt.green
self.background = Qt.black
self.timer = QTimer()
self.timer.timeout.connect(self.update)
self.timer.start(200)
self.resize(200, 200)
def updateValue(self):
pass
def paintEvent(self, QPaintEvent):
self.updateValue()
self.side = min(self.width(), self.height())
self.painter = QPainter()
self.painter.begin(self)
#self.painter.setRenderHint(QPainter.Antialiasing)
self.painter.translate(self.width() / 2, self.height() / 2)
self.painter.scale(self.side / 200.0, self.side / 200.0)
self.painter.setPen(Qt.NoPen)
self.drawCrown()
self.drawBackgroud()
self.drawLogo()
self.drawScale()
self.drawScaleNum()
self.drawNumbericValue()
self.drawPointer()
self.painter.end()
def setValue(self, updatefun):
self.value = updatefun()
def setLogo(self, logo):
self.logo = logo
def drawCrown(self):
self.painter.save()
self.painter.setPen(QtGui.QPen(self.crownColor, 3))
self.painter.drawEllipse(-92, -92, 184, 184)
self.painter.restore()
def drawBackgroud(self):
self.painter.save()
self.painter.setBrush(self.background)
self.painter.drawEllipse(-92, -92, 184, 184)
self.painter.restore()
def drawScale(self):
self.painter.save()
self.painter.rotate(self.startAngle)
self.painter.setPen(self.foreground)
steps = self.scaleMajor * self.scaleMijor
angleStep = (360.0 - self.startAngle - self.endAngle) / steps
pen = QtGui.QPen(self.painter.pen())
for i in xrange(steps + 1):
if i % self.scaleMajor == 0:
pen.setWidth(1)
self.painter.setPen(pen)
self.painter.drawLine(0, 62, 0, 72)
else:
pen.setWidth(0)
self.painter.setPen(pen)
self.painter.drawLine(0, 62, 0, 65)
self.painter.rotate(angleStep)
self.painter.restore()
def drawScaleNum(self):
self.painter.save()
self.painter.setPen(self.foreground)
startRad = (360 - self.startAngle - 90) * (3.14 / 180)
deltaRad = (360 - self.startAngle -
self.endAngle) * (3.14 / 180) / self.scaleMajor
fm = QtGui.QFontMetricsF(self.font())
for i in xrange(self.scaleMajor + 1):
sina = sin(startRad - i * deltaRad)
cosa = cos(startRad - i * deltaRad)
tmpVal = 1.0 * i * ((self.maxValue - self.minValue) /
self.scaleMajor) + self.minValue
numstr = QString("%1").arg(tmpVal)
w = fm.size(Qt.TextSingleLine, numstr).width()
h = fm.size(Qt.TextSingleLine, numstr).height()
x = 82 * cosa - w / 2
y = -82 * sina + h / 4
self.painter.drawText(x, y, numstr)
self.painter.restore()
def drawLogo(self):
self.painter.save()
self.painter.setPen(self.foreground)
self.painter.setBrush(self.foreground)
logostr = QString(self.logo)
fm = QtGui.QFontMetricsF(self.font())
w = fm.size(Qt.TextSingleLine, logostr).width()
self.painter.drawText(-w / 2, -30, logostr)
self.painter.restore()
def drawNumbericValue(self):
self.painter.save()
color = QtGui.QColor(150, 150, 200)
pen = self.painter.pen()
pen.setWidth(3)
self.painter.setPen(pen)
self.painter.setPen(color)
self.painter.drawRect(-30, 30, 60, 14)
cpustr = QString("%1").arg(self.value)
fm = QtGui.QFontMetricsF(self.font())
w = fm.size(Qt.TextSingleLine, cpustr).width()
self.painter.setPen(self.foreground)
self.painter.drawText(-w / 2, 42, cpustr)
self.painter.restore()
def drawPointer(self):
self.painter.save()
self.pointerHand = QPolygon([-2, 0, 2, 0, 0, 60])
self.pointerColor = QColor(127, 0, 127)
self.painter.setBrush(self.pointerColor)
self.painter.rotate(self.startAngle)
degRotate = (360.0 - self.startAngle - self.endAngle) / (
self.maxValue - self.minValue) * (self.value - self.minValue)
self.painter.rotate(degRotate)
self.painter.drawConvexPolygon(self.pointerHand)
self.painter.restore()
class Meter(QtGui.QWidget):
"""
a PyQt instance of QtMeter from Qt example code
"""
def __init__(self,parent=None):
QtGui.QWidget.__init__(self,parent)
self.value = 0
self.minValue = 0
self.maxValue = 100
self.logo = ""
self.scaleMajor = 10
self.scaleMijor = 10
self.startAngle = 60
self.endAngle = 60
self.crownColor = Qt.blue
self.foreground = Qt.green
self.background = Qt.black
self.timer = QTimer()
self.timer.timeout.connect(self.update)
self.timer.start(200)
self.resize(200,200)
def updateValue(self):
pass
def paintEvent(self,QPaintEvent):
self.updateValue()
self.side = min(self.width(),self.height())
self.painter = QPainter()
self.painter.begin(self)
#self.painter.setRenderHint(QPainter.Antialiasing)
self.painter.translate(self.width()/2,self.height()/2)
self.painter.scale(self.side / 200.0, self.side / 200.0)
self.painter.setPen(Qt.NoPen)
self.drawCrown()
self.drawBackgroud()
self.drawLogo()
self.drawScale()
self.drawScaleNum()
self.drawNumbericValue()
self.drawPointer()
self.painter.end()
def setValue(self,updatefun):
self.value = updatefun()
def setLogo(self,logo):
self.logo = logo
def drawCrown(self):
self.painter.save()
self.painter.setPen(QtGui.QPen(self.crownColor, 3))
self.painter.drawEllipse(-92, -92, 184, 184)
self.painter.restore()
def drawBackgroud(self):
self.painter.save()
self.painter.setBrush(self.background)
self.painter.drawEllipse(-92, -92, 184, 184)
self.painter.restore()
def drawScale(self):
self.painter.save()
self.painter.rotate(self.startAngle)
self.painter.setPen(self.foreground)
steps = self.scaleMajor * self.scaleMijor
angleStep = (360.0 - self.startAngle - self.endAngle) /steps
pen = QtGui.QPen(self.painter.pen())
for i in xrange(steps+1):
if i % self.scaleMajor == 0:
pen.setWidth(1)
self.painter.setPen(pen)
self.painter.drawLine(0, 62, 0, 72)
else:
pen.setWidth(0)
self.painter.setPen(pen)
self.painter.drawLine(0, 62, 0, 65)
self.painter.rotate(angleStep)
self.painter.restore()
def drawScaleNum(self):
self.painter.save()
self.painter.setPen(self.foreground)
startRad = (360 - self.startAngle - 90) * (3.14 / 180)
deltaRad = (360 - self.startAngle - self.endAngle) * (3.14 / 180) / self.scaleMajor
fm = QtGui.QFontMetricsF(self.font())
for i in xrange(self.scaleMajor+1):
sina = sin(startRad - i * deltaRad)
cosa = cos(startRad - i * deltaRad)
tmpVal = 1.0 * i *((self.maxValue - self.minValue) / self.scaleMajor) + self.minValue
numstr = QString( "%1" ).arg(tmpVal)
w = fm.size(Qt.TextSingleLine,numstr).width()
h = fm.size(Qt.TextSingleLine,numstr).height()
x = 82 * cosa - w / 2
y = -82 * sina + h / 4
self.painter.drawText(x, y, numstr)
self.painter.restore()
def drawLogo(self):
self.painter.save()
self.painter.setPen(self.foreground)
self.painter.setBrush(self.foreground)
logostr = QString(self.logo)
fm = QtGui.QFontMetricsF(self.font())
w = fm.size(Qt.TextSingleLine,logostr).width()
self.painter.drawText(-w / 2, -30, logostr)
self.painter.restore()
def drawNumbericValue(self):
self.painter.save()
color = QtGui.QColor(150, 150, 200)
pen = self.painter.pen()
pen.setWidth(3)
self.painter.setPen(pen)
self.painter.setPen(color)
self.painter.drawRect(-30, 30, 60, 14)
cpustr = QString("%1").arg(self.value)
fm = QtGui.QFontMetricsF(self.font())
w = fm.size(Qt.TextSingleLine,cpustr).width()
self.painter.setPen(self.foreground)
self.painter.drawText(-w / 2, 42, cpustr)
self.painter.restore()
def drawPointer(self):
self.painter.save()
self.pointerHand=QPolygon([-2,0, 2,0, 0,60])
self.pointerColor = QColor(127 , 0, 127)
self.painter.setBrush(self.pointerColor)
self.painter.rotate(self.startAngle)
degRotate = (360.0 - self.startAngle - self.endAngle)/(self.maxValue - self.minValue)*(self.value - self.minValue)
self.painter.rotate(degRotate)
self.painter.drawConvexPolygon(self.pointerHand)
self.painter.restore()
class Timeline(QWidget, Script):
def __init__(self):
Script.__init__(self, 'timeline')
QWidget.__init__(self, None)
self.type = 'timeline'
self.nodeCount = 0
self.timesCount = 0
self.timeMap = {}
self.m = 40 # Padding
self.lineHeight = 4 # Pixel height of line
self.metricOk = False
self.colors = [['blue', Qt.blue], ['red', Qt.red], ['green', Qt.green],
['yellow', Qt.yellow], ['magenta', Qt.magenta],
['cyan', Qt.cyan]]
self.stateinfo = 'Initialized'
self.dateMin = long(0xffffffffffffffff)
self.dateMax = long(0)
self.baseDateMin = self.dateMin
self.baseDateMax = self.dateMax
self.selDateMin = None
self.selDateMax = None
self.maxOcc = 0
self.maxOccZoom = 0
self.xHop = 0
self.xRange = 0
self.dataListsCreated = False
def start(self, args):
self.node = args['file'].value()
def status(self):
return 0
def updateWidget(self):
pass
def g_display(self):
self.name = 'timeline ' + QString(self.node.name())
if not self.node.hasChildren():
self.setStateInfo(self.node.absolute() +
' doesn\'t have any children.')
else:
self.vfs = vfs.vfs()
self.vlayout = QVBoxLayout()
self.vlayout.setMargin(0)
self.vlayout.setSpacing(0)
self.hsplitter = QSplitter()
self.ploter = PaintArea(self)
self.options = OptionsLayout(self)
self.hsplitter.addWidget(self.ploter)
self.hsplitter.addWidget(self.options)
self.vlayout.addWidget(self.hsplitter)
self.setLayout(self.vlayout)
self.draw = Drawer(self)
# CountThread compute node amount
self.countThread = CountThread(self, self.countThreadOver)
self.populateThread = DataThread(self, self.dataThreadOver)
self.maxOccThread = MaxOccThread(self, self.maxOccThreadOver)
self.workerThread = WorkerThread(self)
#comment it to avoid redraw everytime painter is resized
self.connect(self.workerThread, SIGNAL('refresh'), self.reDraw)
def fromUSec(self, usec2):
usec = int(usec2)
days = usec / (86400 * 1000000)
seconds = (usec - days * 86400 * 1000000) / 1000000
misec = usec - days * 86400 * 1000000 - seconds * 1000000
if days >= 1 and datetime.fromordinal(days) >= datetime.fromordinal(1):
return datetime.fromordinal(days) + timedelta(seconds=seconds,
microseconds=misec)
return None
def toUSec(self, dtime):
return dtime.toordinal(
) * 86400 * 1000000 + dtime.hour * 3600 * 1000000 + dtime.minute * 60 * 1000000 + dtime.second * 1000000 + dtime.microsecond
def dumpTimeMap(self):
print self.timeMap
for k in self.timeMap.keys():
print 'module:', k
for attr in self.timeMap[k]:
sAttrPath = '/'
for v in attr[:-1]:
sAttrPath += v + '/'
print ' ', sAttrPath, ':', attr[-1]
def countThreadOver(self):
if not self.nodeCount:
self.setStateInfo('No timestamp found any subset of ' +
self.node.absolute())
# self.disconnect(self.workerThread, SIGNAL('refresh'), self.reDraw)
return
self.setStateInfo(str(self.nodeCount) + ' nodes found')
# self.dumpTimeMap()
# Find/virtual draw maximum size of Y text
painter = QPainter()
nullPixmap = QPixmap(self.ploter.width, self.ploter.height)
painter.begin(nullPixmap)
rect = painter.drawText(self.draw.paddingYText, 10, 0, 0, 0,
str(self.nodeCount) + '.0')
painter.end()
self.draw.yLeftMargin = self.draw.paddingYText * 2 + rect.width()
self.options.newInformations()
self.options.createMetricTools()
self.metricOk = True
# self.createFullTimeLists()
self.workerThread.render()
def createFullTimeLists(self):
self.populateThread = DataThread(self, self.dataThreadOver)
self.populateThread.start()
def dataThreadOver(self):
self.dataListsCreated = True
for family in self.options.configuration:
# family[0] = extended|static|usual
for time in family[1]:
if time[1][5][1]:
dateMin = time[1][6][1][0]
dateMax = time[1][6][1][1]
if dateMin != None and dateMin > 0 and dateMin < 18446744073709551615 and dateMin < self.baseDateMin:
self.baseDateMin = dateMin
if dateMax != None and dateMax > 0 and dateMax < 18446744073709551615 and dateMax > self.baseDateMax:
self.baseDateMax = dateMax
self.options.newInformations()
self.workerThread.render()
def findMaxValue(self):
self.xRange = (self.ploter.width - self.m -
self.draw.yLeftMargin) / self.lineHeight
self.xHop = (self.baseDateMax - self.baseDateMin) / self.xRange
def maxOccThreadOver(self):
self.updatePaintingArea()
def zoomMaxOcc(self):
self.xRange = (self.ploter.width - self.m -
self.draw.yLeftMargin) / self.lineHeight
xHop = (self.selDateMax - self.selDateMin) / self.xRange
newMaxOcc = 0
for family in self.options.configuration:
for time in family[1]:
timeChecked = self.selDateMin
if timeChecked == self.selDateMax:
# Every nodes have the same time, setting maxOcc computing time + 100usec
occ = self.elementsInRange(time[1][5][1], timeChecked,
timeChecked + 100)
if occ > newMaxOcc:
newMaxOcc = occ
while timeChecked <= self.selDateMax:
occ = self.elementsInRange(time[1][5][1], timeChecked,
timeChecked + xHop)
if occ > newMaxOcc:
newMaxOcc = occ
timeChecked += xHop
self.maxOccZoom = newMaxOcc
def reDraw(self, resized=False):
if resized:
self.updatePaintingArea(True)
def updatePaintingArea(self, resized=False):
if not self.maxOcc:
return
self.painter = QPainter()
self.mainPixmap = QPixmap(self.ploter.width, self.ploter.height)
self.mainPixmap.fill(Qt.white)
self.gridPixmap = QPixmap(self.ploter.width, self.ploter.height)
self.gridPixmap.fill(Qt.transparent)
self.painter.begin(self.gridPixmap)
if self.options.zoom and not self.maxOccZoom:
self.zoomMaxOcc()
self.draw.setDynamicValues(self)
self.draw.drawInfos()
self.draw.drawGrid()
self.painter.end()
for family in self.options.configuration:
for time in family[1]:
if resized:
time[1][8][1][0] = True
time[1][7][1][0] = True
if self.options.zoom and time[1][8][1][0]:
# Create zoom pixmaps
time[1][8][1][1] = QPixmap(self.ploter.width,
self.ploter.height)
time[1][8][1][1].fill(Qt.transparent)
penColor = None
for color in self.colors:
if color[0] == time[1][1][1]:
penColor = QColor(color[1])
penColor.setAlpha(163)
break
if penColor:
self.painter.begin(time[1][8][1][1])
pen = self.painter.pen()
pen.setColor(penColor)
pen.setWidth(self.lineHeight)
self.painter.setPen(pen)
self.draw.drawTimeline(self.painter, time[1][5][1])
self.painter.end()
time[1][8][1][0] = False
elif not time[1][7][1][1] or time[1][7][1][0]:
# Create main (original sized) pixmaps
time[1][7][1][1] = QPixmap(self.ploter.width,
self.ploter.height)
time[1][7][1][1].fill(Qt.transparent)
penColor = None
for color in self.colors:
if color[0] == time[1][1][1]:
penColor = QColor(color[1])
penColor.setAlpha(163)
break
if penColor:
self.painter.begin(time[1][7][1][1])
pen = self.painter.pen()
pen.setColor(penColor)
pen.setWidth(self.lineHeight)
self.painter.setPen(pen)
self.draw.drawTimeline(self.painter, time[1][5][1])
self.painter.end()
time[1][7][1][0] = False
self.painter.begin(self.mainPixmap)
# Draw grid
self.painter.drawImage(
QPointF(0, 0), self.gridPixmap.toImage(),
QRectF(0, 0, self.ploter.width, self.ploter.height))
for family in self.options.configuration:
for time in family[1]:
# Draw each time pixmap
if not self.options.zoom:
# Draw global view, if zoom not enabled
if time[1][7][1][1] and time[1][0][1]:
self.painter.drawImage(
QPointF(0, 0), time[1][7][1][1].toImage(),
QRectF(0, 0, self.ploter.width,
self.ploter.height))
else:
# Draw zoom pixmaps
if time[1][8][1][1] and time[1][0][1]:
self.painter.drawImage(
QPointF(0, 0), time[1][8][1][1].toImage(),
QRectF(0, 0, self.ploter.width,
self.ploter.height))
self.painter.end()
self.ploter.scene.clear()
self.ploter.scene.addPixmap(self.mainPixmap)
self.ploter.setEnabled(True)
self.update()
def setStateInfo(self, sinfo):
self.stateinfo = str(sinfo)
def stateInfo(self):
if self.nodeCount:
return self.stateinfo + ' - ' + str(self.nodeCount) + ' nodes'
else:
return self.stateinfo
def nodesInRange(self, x1, x2):
if not self.selDateMin:
timeCheck = self.baseDateMin
timeMax = self.baseDateMax
else:
timeCheck = self.selDateMin
timeMax = self.selDateMax
count = 0
while timeCheck < timeMax:
for family in self.options.configuration:
for time in family[1]:
occ = self.elementsInRange(time[1][5][1], timeCheck,
timeCheck + self.xHop)
if occ:
if self.lineMatched(timeCheck, occ, x1,
x2) and time[1][0][1]:
count += occ
timeCheck += self.xHop
if count:
self.options.zoomButton.setEnabled(True)
self.options.exportButton.setEnabled(True)
if count > 1:
self.options.selectedNodes.setText(
str(count) + ' time values selected')
else:
self.options.selectedNodes.setText('One time value selected')
else:
self.options.zoomButton.setEnabled(False)
self.options.exportButton.setEnabled(False)
self.options.selectedNodes.setText('Nothing selected')
def lineMatched(self, usec, occ, x1, x2):
if not self.selDateMin:
dateMin = self.baseDateMin
dateMax = self.baseDateMax
else:
dateMin = self.selDateMin
dateMax = self.selDateMax
if (dateMax - dateMin) > 0:
x = ((usec - dateMin) *
(self.ploter.width - self.m - self.draw.yLeftMargin)) / (
dateMax - dateMin) + self.draw.yLeftMargin
if x <= self.draw.yLeftMargin:
x += 3
x_min = x - 2
x_max = x + 2
if x_min >= x1 and x_max <= x2:
return True
return False
def elementsInRange(self, root, tMin, tMax):
''' Returns amount of node in a date range, given as long
Dichotomic search, but this can be improved because we only search for
smaller timestamp and decrease index if greather.
'''
if not tMin or not tMax:
return 0
nodesCount = 0
if root['dates'] == None:
return 0
iMin, iMax = 0, len(root['dates']) - 1
iCurrent = iMax / 2
# Sync cursor in dates list on tMin ; should be improved
while iMin != iMax or not iMax:
if tMin >= root['dates'][iCurrent] or not iCurrent:
while iCurrent and tMin >= root['dates'][iCurrent]:
# Should be improved
iCurrent -= 1
break
elif tMin < root['dates'][iCurrent]:
iMax = iCurrent
iCurrent = iMin + ((iCurrent - iMin) / 2)
# Count amount of nodes between tMin and tMax
endOfList = len(root['dates'])
while iCurrent < endOfList and tMax >= root['dates'][iCurrent]:
if tMin <= root['dates'][iCurrent]:
nodesCount += len(root['nodes'][iCurrent])
iCurrent += 1
return nodesCount
def elementsInRangeToNodeList(self, root, tMin, tMax):
''' Returns a list of nodes pointer, made of nodes in given date range.
Dichotomic search, but this can be improved because we only search for
smaller timestamp and decrease index if greather.
'''
if not tMin or not tMax:
return 0
nodesList = []
iMin, iMax = 0, len(root['dates']) - 1
iCurrent = iMax / 2
# Sync cursor in dates list on tMin ; should be improved
while iMin != iMax or not iMax:
if tMin >= root['dates'][iCurrent] or not iCurrent:
while iCurrent and tMin >= root['dates'][iCurrent]:
# Should be improved
iCurrent -= 1
break
elif tMin < root['dates'][iCurrent]:
iMax = iCurrent
iCurrent = iMin + ((iCurrent - iMin) / 2)
# Count amount of nodes between tMin and tMax
endOfList = len(root['dates'])
while iCurrent < endOfList and tMax >= root['dates'][iCurrent]:
if tMin <= root['dates'][iCurrent]:
nodesList.append(root['nodes'][iCurrent])
iCurrent += 1
return nodesList
def paintEvent(self, event):
# Initialize QPainter properties
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
if self.height() <= self.width() / self.ref_aspect_ratio:
v_scale = self.height()
h_scale = v_scale * self.ref_aspect_ratio
else:
h_scale = self.width()
v_scale = h_scale / self.ref_aspect_ratio
# Scale all objects proportionate to window size
painter.scale(h_scale / self.width_ref, v_scale / self.height_ref)
painter.setClipPath(self.dial) # Don't allow objects or text to extend outside of main dial shape
painter.save()
# First draw main gauge background
pen = QPen(painter.pen())
pen.setWidth(1)
pen.setColor(Qt.black)
painter.setPen(pen)
painter.setBrush(QColor(100, 100, 100, 255)) # self.dial_bg)
painter.drawPath(self.dial)
# Add Minor and Major Alarm limit bars
pen.setWidth(16)
pen.setCapStyle(Qt.FlatCap)
pen.setJoinStyle(Qt.BevelJoin)
pen.setColor(Qt.yellow)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
painter.drawPath(self.low_arc)
painter.drawPath(self.high_arc)
pen.setColor(Qt.red)
painter.setPen(pen)
painter.drawPath(self.lolo_arc)
painter.drawPath(self.hihi_arc)
painter.restore()
# Display PV current value
painter.save()
font = QFont()
font.setPixelSize(45)
painter.setFont(font)
sevr = self.channel.sevr.lower()
if sevr == 'major':
color = Qt.red
elif sevr == 'minor':
color = Qt.yellow
elif sevr == 'invalid':
color = Qt.magenta
else:
color = Qt.green
pen.setColor(color)
painter.setPen(pen)
font_metric = QFontMetrics(font)
painter.translate(self.dial_width / 2, self.dial_height / 2)
label = self.format_label(self.channel_value)
painter.drawText(QPointF(0.0 - font_metric.width(label) / 2.0, font_metric.height() / 2.0),
label)
# Display PV name
painter.setFont(self.pv_label_font)
pen.setColor(Qt.black) # Qt.darkCyan)
pen.setWidth(1)
painter.setPen(pen)
# brush = QBrush(Qt.darkCyan)
# painter.setBrush(brush)
font_metric = QFontMetrics(self.pv_label_font)
pv_label = self.channel.egu # self.channel.name + ' (' + self.channel.egu + ')'
painter.drawText(QPointF(0.0 - font_metric.width(pv_label) / 2.0,
(self.dial_height / 2.0) + (font_metric.height() * 1.5)),
pv_label)
# painter.drawPath(self.pv_label_path)
painter.restore()
# Next add division markers
painter.save()
painter.translate(self.dial_width / 2, self.dial_height * 0.98)
pen.setColor(Qt.black) # Qt.cyan)
pen.setWidth(2)
painter.setPen(pen)
for i in range(0, 31):
if (i % 5) != 0:
painter.drawLine(-self.dial_width / 2.1, 0.0, -self.dial_width / 2.2, 0.0)
else:
painter.drawLine(-self.dial_width / 2.1, 0.0, -self.dial_width / 2.3, 0.0)
painter.rotate(6.0)
painter.restore()
# Layout division text labels
painter.save()
painter.translate(self.dial_width / 2, self.dial_height * 0.98)
pen.setColor(Qt.black) # Qt.cyan)
painter.setPen(pen)
font = QFont()
font.setPixelSize(18)
painter.setFont(font)
font_metric = QFontMetrics(font)
labels = linspace(self.lim_low, self.lim_hi, 7)
painter.rotate(-90)
for i in range(0, 7):
label = self.format_label(labels[i])
painter.drawText(QPointF(0.0 - font_metric.width(label) / 2.0, -self.dial_height * 0.75), label)
painter.rotate(30)
painter.restore()
# Draw needle at appropriate angle for data
painter.save()
painter.translate(self.dial_width / 2, self.dial_height * 0.98)
painter.rotate(-180 * (1.0 - self.percentage))
pen.setColor(QColor(self.needle_color).darker(200))
pen.setWidth(1)
painter.setPen(pen)
painter.setBrush(self.needle_color)
painter.drawPolygon(self.needle)
painter.restore()
# if self.percentage <= 0.5:
# shadow = max(490 * self.percentage, 127)
# needle_left_color = QColor(0, shadow, shadow) # Qt.darkCyan # QColor(80,80,80,255)
# needle_right_color = Qt.cyan # QColor(230,230,230,255)
# else:
# shadow = max(125 / self.percentage, 127)
# needle_left_color = Qt.cyan # QColor(230,230,230,255)
# needle_right_color = QColor(0, shadow, shadow) # Qt.darkCyan # QColor(80,80,80,255)
#
# # Draw Highlight side of needle
# pen.setWidth(1)
# pen.setColor(Qt.gray) # needle_left_color)
# painter.setPen(pen)
# painter.setBrush(Qt.gray) # needle_left_color)
# painter.drawPolygon(self.needle_left)
#
# # Draw shadow side of needle
# pen.setColor(Qt.gray) # needle_right_color)
# painter.setPen(pen)
# painter.setBrush(Qt.gray) # needle_right_color)
# painter.drawPolygon(self.needle_right)
# painter.restore()
# Draw needle axel pin
painter.save()
pen.setWidth(1)
pen.setColor(Qt.black)
painter.setPen(pen)
painter.setBrush(QColor(50, 50, 50, 255)) # self.pin_bg)
painter.translate(self.dial_width / 2, self.dial_height * 0.98)
painter.drawEllipse(self.pin_rect)
painter.restore()
# Draw glass reflection and shadow effects
# painter.save()
# painter.translate(self.dial_width / 2.0, self.dial_height / 2.0)
# painter.setPen(Qt.NoPen)
# painter.setBrush(QColor(0, 0, 0, 20))
# painter.drawEllipse(self.shadow_rect)
# painter.setBrush(self.gloss_gradient)
# painter.drawEllipse(self.gloss_rect)
# painter.restore()
painter.end()
def gen_font(font_configs,
font_type=FONT_TYPES.font01,
img_width=1024,
draw_outlines=False):
img_height = HEIGHT_FACTOR
seen_chars = []
game_font = GameFont(width=img_width)
painter = QPainter(game_font.trans)
text_brush = QtGui.QBrush(QColor(255, 255, 255, 255))
painter.setBrush(text_brush)
outline_brush = QtGui.QBrush()
outline_pen = QtGui.QPen(QColor(255, 0, 0, 255),
1,
style=Qt.Qt.DotLine,
join=Qt.Qt.MiterJoin)
x_pos = 0
y_pos = 0
line_height = LINE_HEIGHT[font_type]
for config in font_configs:
font = QFont(config.family, config.size, config.weight, italic=False)
font.setKerning(False)
metric = QFontMetrics(font)
painter.setFont(font)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.Antialiasing, True)
text_pen = painter.pen()
text_pen.setBrush(QColor(255, 255, 255, 255))
text_pen.setWidthF(config.pen_size)
text_pen.setCapStyle(config.pen_cap)
text_pen.setJoinStyle(config.pen_join)
text_pen.setStyle(Qt.Qt.SolidLine if config.use_pen else Qt.Qt.NoPen)
painter.setPen(text_pen)
for char in sorted(config.chars):
if char in seen_chars:
continue
else:
seen_chars.append(char)
# If we want a character to represent something it's not.
char_to_print = char
if char in config.subs:
char_to_print = config.subs[char]
char_w = metric.width(char_to_print)
if x_pos + char_w > img_width:
x_pos = 0
y_pos += line_height + config.y_margin
if y_pos < 0:
y_pos = 0
if y_pos + line_height > MAX_HEIGHT:
_LOGGER.warning(
"Ran out of vertical space. Generated font does not include all characters."
)
break
game_font.font_data.data.append({
'char': char,
'x': x_pos,
'y': y_pos,
'w': char_w,
'h': line_height,
'y_shift': config.y_shift
})
path = QPainterPath()
path.addText(x_pos + config.x_offset,
y_pos + metric.ascent() + config.y_offset, font,
char_to_print)
painter.drawPath(path)
if draw_outlines:
painter.setBrush(outline_brush)
painter.setPen(outline_pen)
painter.setRenderHint(QPainter.Antialiasing, False)
painter.drawRect(x_pos, y_pos, char_w, line_height)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setBrush(text_brush)
painter.setPen(text_pen)
x_pos += char_w + config.x_margin
painter.end()
painter = QPainter(game_font.opaque)
painter.drawImage(game_font.opaque.rect(), game_font.trans,
game_font.trans.rect())
painter.end()
# Crop our images so they only take up as much space as they need.
final_height = int(
math.ceil(float(y_pos + line_height) / float(HEIGHT_FACTOR)) *
HEIGHT_FACTOR)
game_font.trans = game_font.trans.copy(0, 0, img_width, final_height)
game_font.opaque = game_font.opaque.copy(0, 0, img_width, final_height)
return game_font
# if __name__ == '__main__':
# app = QtGui.QApplication(sys.argv)
# chars = load_text(CHAR_LIST)
# We can't have dupes, and why not put them in order while we're at it?
# chars = sorted(make_unique(chars))
# game_font = gen_font(chars)
# game_font.save(SAVE_AS)
### EOF ###
def paintEvent(self, event):
if not self.resources:
return
paint = QPainter(self)
font = QFont()
font.setPointSize(7)
paint.setFont(font)
for e in self.resources.edges:
if e == self.selectedEdge:
paint.setPen(self.settings["selected"])
elif self.demandEdges.count(e):
paint.setPen(self.settings["selected_demand"])
else:
paint.setPen(self.settings["line"])
x1 = self.vertices[e.e1].x() + self.size / 2
y1 = self.vertices[e.e1].y() + self.size / 2
x2 = self.vertices[e.e2].x() + self.size / 2
y2 = self.vertices[e.e2].y() + self.size / 2
self.drawArrow(paint, x1, y1, x2, y2)
for v in self.vertices.keys():
if self.demandVertices.count(v) != 0:
paint.fillRect(self.vertices[v],
self.settings["selected_demand"])
if isinstance(v, Computer):
if self.selectedVertex != self.vertices[v]:
paint.drawImage(self.vertices[v], self.computericon)
else:
paint.drawImage(self.vertices[v],
self.computerselectedicon)
n = v.getUsedSpeedPercent(self.time)
pen = paint.pen()
if n > 90:
paint.setPen(Qt.red)
elif n > 65:
paint.setPen(Qt.yellow)
elif n > 0.5:
paint.setPen(Qt.green)
else:
paint.setPen(Qt.blue)
paint.drawRect(self.vertices[v])
paint.setPen(pen)
if self.settings["computer"]:
paint.setPen(self.settings["text"])
paint.drawText(
self.vertices[v].x(),
self.vertices[v].y() + self.size / 2,
str(int(v.getUsedSpeedPercent(self.time))) + "%")
paint.drawText(
self.vertices[v].x(),
self.vertices[v].y() + self.size / 2 + 10,
str(int(v.getUsedRamPercent(self.time))) + "%")
elif isinstance(v, Storage):
if self.selectedVertex != self.vertices[v]:
paint.drawImage(self.vertices[v], self.storageicon)
else:
paint.drawImage(self.vertices[v], self.storageselectedicon)
n = v.getUsedVolumePercent(self.time)
pen = paint.pen()
if n > 90:
paint.setPen(Qt.red)
elif n > 65:
paint.setPen(Qt.yellow)
elif n > 0.5:
paint.setPen(Qt.green)
else:
paint.setPen(Qt.blue)
paint.drawRect(self.vertices[v])
paint.setPen(pen)
if self.settings["storage"]:
paint.setPen(self.settings["text"])
paint.drawText(
self.vertices[v].x(),
self.vertices[v].y() + self.size / 2,
str(int(v.getUsedVolumePercent(self.time))) + "%")
elif isinstance(v, Router):
if self.selectedVertex != self.vertices[v]:
paint.drawImage(self.vertices[v], self.routericon)
else:
paint.drawImage(self.vertices[v], self.routerselectedicon)
if self.settings["router"]:
paint.setPen(self.settings["text"])
paint.drawText(
self.vertices[v].x(),
self.vertices[v].y() + self.size / 2,
str(int(v.getUsedCapacityPercent(self.time))) + "%")
paint.setPen(self.settings["line"])
if self.edgeDraw:
self.drawArrow(
paint, self.curEdge[0].x() + self.size / 2,
self.curEdge[0].y() + self.size / 2,
QCursor.pos().x() -
self.mapToGlobal(self.geometry().topLeft()).x(),
QCursor.pos().y() -
self.mapToGlobal(self.geometry().topLeft()).y())
if self.settings["channel"]:
for e in self.resources.edges:
x1 = self.vertices[e.e1].x() + self.size / 2
y1 = self.vertices[e.e1].y() + self.size / 2
x2 = self.vertices[e.e2].x() + self.size / 2
y2 = self.vertices[e.e2].y() + self.size / 2
paint.setPen(self.settings["text"])
paint.drawText(
(x1 + x2) / 2, (y1 + y2) / 2,
str(int(e.getUsedCapacityPercent(self.time))) + "%")
paint.end()
def paintEvent(self, event):
if not self.resources:
return
paint = QPainter(self)
font = QFont()
font.setPointSize(7)
paint.setFont(font)
for e in self.resources.edges:
if e == self.selectedEdge:
paint.setPen(self.settings["selected"])
elif self.demandEdges.count(e):
paint.setPen(self.settings["selected_demand"])
else:
paint.setPen(self.settings["line"])
x1 = self.vertices[e.e1].x() + self.size / 2
y1 = self.vertices[e.e1].y() + self.size / 2
x2 = self.vertices[e.e2].x() + self.size / 2
y2 = self.vertices[e.e2].y() + self.size / 2
self.drawArrow(paint, x1, y1, x2, y2)
for v in self.vertices.keys():
if self.demandVertices.count(v) != 0:
paint.fillRect(self.vertices[v],self.settings["selected_demand"])
if isinstance(v,Computer):
if self.selectedVertex != self.vertices[v]:
paint.drawImage(self.vertices[v], self.computericon)
else:
paint.drawImage(self.vertices[v], self.computerselectedicon)
n = v.getUsedSpeedPercent(self.time)
pen = paint.pen()
if n > 90:
paint.setPen(Qt.red)
elif n > 65:
paint.setPen(Qt.yellow)
elif n > 0.5:
paint.setPen(Qt.green)
else:
paint.setPen(Qt.blue)
paint.drawRect(self.vertices[v])
paint.setPen(pen)
if self.settings["computer"]:
paint.setPen(self.settings["text"])
paint.drawText(self.vertices[v].x(), self.vertices[v].y()+self.size/2, str(int(v.getUsedSpeedPercent(self.time)))+"%")
paint.drawText(self.vertices[v].x(), self.vertices[v].y()+self.size/2+10, str(int(v.getUsedRamPercent(self.time)))+"%")
elif isinstance(v,Storage):
if self.selectedVertex != self.vertices[v]:
paint.drawImage(self.vertices[v], self.storageicon)
else:
paint.drawImage(self.vertices[v], self.storageselectedicon)
n = v.getUsedVolumePercent(self.time)
pen = paint.pen()
if n > 90:
paint.setPen(Qt.red)
elif n > 65:
paint.setPen(Qt.yellow)
elif n > 0.5:
paint.setPen(Qt.green)
else:
paint.setPen(Qt.blue)
paint.drawRect(self.vertices[v])
paint.setPen(pen)
if self.settings["storage"]:
paint.setPen(self.settings["text"])
paint.drawText(self.vertices[v].x(), self.vertices[v].y() + self.size/2, str(int(v.getUsedVolumePercent(self.time)))+"%")
elif isinstance(v,Router):
if self.selectedVertex != self.vertices[v]:
paint.drawImage(self.vertices[v], self.routericon)
else:
paint.drawImage(self.vertices[v], self.routerselectedicon)
if self.settings["router"]:
paint.setPen(self.settings["text"])
paint.drawText(self.vertices[v].x(), self.vertices[v].y() + self.size/2, str(int(v.getUsedCapacityPercent(self.time)))+"%")
paint.setPen(self.settings["line"])
if self.edgeDraw:
self.drawArrow(paint, self.curEdge[0].x() + self.size / 2, self.curEdge[0].y() + self.size / 2,
QCursor.pos().x() - self.mapToGlobal(self.geometry().topLeft()).x(),
QCursor.pos().y() - self.mapToGlobal(self.geometry().topLeft()).y())
if self.settings["channel"]:
for e in self.resources.edges:
x1 = self.vertices[e.e1].x() + self.size / 2
y1 = self.vertices[e.e1].y() + self.size / 2
x2 = self.vertices[e.e2].x() + self.size / 2
y2 = self.vertices[e.e2].y() + self.size / 2
paint.setPen(self.settings["text"])
paint.drawText((x1+x2)/2, (y1+y2)/2, str(int(e.getUsedCapacityPercent(self.time)))+"%")
paint.end()
class Timeline(QWidget, Script):
def __init__(self):
Script.__init__(self, 'timeline')
QWidget.__init__(self, None)
self.type = 'timeline'
self.nodeCount = 0
self.timesCount = 0
self.timeMap = {}
self.m = 40 # Padding
self.lineHeight = 4 # Pixel height of line
self.metricOk = False
self.colors = [['blue', Qt.blue], ['red', Qt.red],
['green', Qt.green], ['yellow', Qt.yellow],
['magenta', Qt.magenta], ['cyan', Qt.cyan]]
self.stateinfo = 'Initialized'
self.dateMin = long(0xffffffffffffffff)
self.dateMax = long(0)
self.baseDateMin = self.dateMin
self.baseDateMax = self.dateMax
self.selDateMin = None
self.selDateMax = None
self.maxOcc = 0
self.maxOccZoom = 0
self.xHop = 0
self.xRange = 0
self.dataListsCreated = False
def start(self, args):
self.node = args['file'].value()
def status(self):
return 0
def updateWidget(self):
pass
def g_display(self):
self.name = 'timeline ' + QString(self.node.name())
if not self.node.hasChildren():
self.setStateInfo(self.node.absolute() + ' doesn\'t have any children.')
else:
self.vfs = vfs.vfs()
self.vlayout = QVBoxLayout()
self.vlayout.setMargin(0)
self.vlayout.setSpacing(0)
self.hsplitter = QSplitter()
self.ploter = PaintArea(self)
self.options = OptionsLayout(self)
self.hsplitter.addWidget(self.ploter)
self.hsplitter.addWidget(self.options)
self.vlayout.addWidget(self.hsplitter)
self.setLayout(self.vlayout)
self.draw = Drawer(self)
# CountThread compute node amount
self.countThread = CountThread(self, self.countThreadOver)
self.populateThread = DataThread(self, self.dataThreadOver)
self.maxOccThread = MaxOccThread(self, self.maxOccThreadOver)
self.workerThread = WorkerThread(self)
#comment it to avoid redraw everytime painter is resized
self.connect(self.workerThread, SIGNAL('refresh'), self.reDraw)
def fromUSec(self, usec2):
usec = int(usec2)
days = usec / (86400 * 1000000)
seconds = (usec - days * 86400 * 1000000) / 1000000
misec = usec - days * 86400 * 1000000 - seconds * 1000000
if days >= 1 and datetime.fromordinal(days) >= datetime.fromordinal(1):
return datetime.fromordinal(days) + timedelta(seconds = seconds, microseconds = misec)
return None
def toUSec(self, dtime):
return dtime.toordinal() * 86400 * 1000000 + dtime.hour * 3600 * 1000000 + dtime.minute * 60 * 1000000 + dtime.second * 1000000 + dtime.microsecond
def dumpTimeMap(self):
print self.timeMap
for k in self.timeMap.keys():
print 'module:', k
for attr in self.timeMap[k]:
sAttrPath = '/'
for v in attr[:-1]:
sAttrPath += v + '/'
print ' ', sAttrPath, ':', attr[-1]
def countThreadOver(self):
if not self.nodeCount:
self.setStateInfo('No timestamp found any subset of ' + self.node.absolute())
# self.disconnect(self.workerThread, SIGNAL('refresh'), self.reDraw)
return
self.setStateInfo(str(self.nodeCount) + ' nodes found')
# self.dumpTimeMap()
# Find/virtual draw maximum size of Y text
painter = QPainter()
nullPixmap = QPixmap(self.ploter.width, self.ploter.height)
painter.begin(nullPixmap)
rect = painter.drawText(self.draw.paddingYText, 10, 0, 0, 0, str(self.nodeCount) + '.0')
painter.end()
self.draw.yLeftMargin = self.draw.paddingYText * 2 + rect.width()
self.options.newInformations()
self.options.createMetricTools()
self.metricOk = True
# self.createFullTimeLists()
self.workerThread.render()
def createFullTimeLists(self):
self.populateThread = DataThread(self, self.dataThreadOver)
self.populateThread.start()
def dataThreadOver(self):
self.dataListsCreated = True
for family in self.options.configuration:
# family[0] = extended|static|usual
for time in family[1]:
if time[1][5][1]:
dateMin = time[1][6][1][0]
dateMax = time[1][6][1][1]
if dateMin < self.baseDateMin:
self.baseDateMin = dateMin
if dateMax > self.baseDateMax:
self.baseDateMax = dateMax
self.options.newInformations()
self.workerThread.render()
def findMaxValue(self):
self.xRange = (self.ploter.width - self.m - self.draw.yLeftMargin) / self.lineHeight
self.xHop = (self.baseDateMax - self.baseDateMin) / self.xRange
def maxOccThreadOver(self):
self.updatePaintingArea()
def zoomMaxOcc(self):
self.xRange = (self.ploter.width - self.m - self.draw.yLeftMargin) / self.lineHeight
xHop = (self.selDateMax - self.selDateMin) / self.xRange
newMaxOcc = 0
for family in self.options.configuration:
for time in family[1]:
timeChecked = self.selDateMin
if timeChecked == self.selDateMax:
# Every nodes have the same time, setting maxOcc computing time + 100usec
occ = self.elementsInRange(time[1][5][1], timeChecked, timeChecked + 100)
if occ > newMaxOcc:
newMaxOcc = occ
while timeChecked <= self.selDateMax:
occ = self.elementsInRange(time[1][5][1], timeChecked, timeChecked + xHop)
if occ > newMaxOcc:
newMaxOcc = occ
timeChecked += xHop
self.maxOccZoom = newMaxOcc
def reDraw(self, resized = False):
if resized:
self.updatePaintingArea(True)
def updatePaintingArea(self, resized = False):
if not self.maxOcc:
return
self.painter = QPainter()
self.mainPixmap = QPixmap(self.ploter.width, self.ploter.height)
self.mainPixmap.fill(Qt.white)
self.gridPixmap = QPixmap(self.ploter.width, self.ploter.height)
self.gridPixmap.fill(Qt.transparent)
self.painter.begin(self.gridPixmap)
if self.options.zoom and not self.maxOccZoom:
self.zoomMaxOcc()
self.draw.setDynamicValues(self)
self.draw.drawInfos()
self.draw.drawGrid()
self.painter.end()
for family in self.options.configuration:
for time in family[1]:
if resized:
time[1][8][1][0] = True
time[1][7][1][0] = True
if self.options.zoom and time[1][8][1][0]:
# Create zoom pixmaps
time[1][8][1][1] = QPixmap(self.ploter.width, self.ploter.height)
time[1][8][1][1].fill(Qt.transparent)
penColor = None
for color in self.colors:
if color[0] == time[1][1][1]:
penColor = QColor(color[1])
penColor.setAlpha(163)
break
if penColor:
self.painter.begin(time[1][8][1][1])
pen = self.painter.pen()
pen.setColor(penColor)
pen.setWidth(self.lineHeight)
self.painter.setPen(pen)
self.draw.drawTimeline(self.painter, time[1][5][1])
self.painter.end()
time[1][8][1][0] = False
elif not time[1][7][1][1] or time[1][7][1][0]:
# Create main (original sized) pixmaps
time[1][7][1][1] = QPixmap(self.ploter.width, self.ploter.height)
time[1][7][1][1].fill(Qt.transparent)
penColor = None
for color in self.colors:
if color[0] == time[1][1][1]:
penColor = QColor(color[1])
penColor.setAlpha(163)
break
if penColor:
self.painter.begin(time[1][7][1][1])
pen = self.painter.pen()
pen.setColor(penColor)
pen.setWidth(self.lineHeight)
self.painter.setPen(pen)
self.draw.drawTimeline(self.painter, time[1][5][1])
self.painter.end()
time[1][7][1][0] = False
self.painter.begin(self.mainPixmap)
# Draw grid
self.painter.drawImage(QPointF(0, 0), self.gridPixmap.toImage(), QRectF(0, 0, self.ploter.width, self.ploter.height))
for family in self.options.configuration:
for time in family[1]:
# Draw each time pixmap
if not self.options.zoom:
# Draw global view, if zoom not enabled
if time[1][7][1][1] and time[1][0][1]:
self.painter.drawImage(QPointF(0, 0), time[1][7][1][1].toImage(), QRectF(0, 0, self.ploter.width, self.ploter.height))
else:
# Draw zoom pixmaps
if time[1][8][1][1] and time[1][0][1]:
self.painter.drawImage(QPointF(0, 0), time[1][8][1][1].toImage(), QRectF(0, 0, self.ploter.width, self.ploter.height))
self.painter.end()
self.ploter.scene.clear()
self.ploter.scene.addPixmap(self.mainPixmap)
self.ploter.setEnabled(True)
self.update()
def setStateInfo(self, sinfo):
self.stateinfo = str(sinfo)
def stateInfo(self):
if self.nodeCount:
return self.stateinfo + ' - ' + str(self.nodeCount) + ' nodes'
else:
return self.stateinfo
def nodesInRange(self, x1, x2):
if not self.selDateMin:
timeCheck = self.baseDateMin
timeMax = self.baseDateMax
else:
timeCheck = self.selDateMin
timeMax = self.selDateMax
count = 0
while timeCheck < timeMax:
for family in self.options.configuration:
for time in family[1]:
occ = self.elementsInRange(time[1][5][1], timeCheck, timeCheck + self.xHop)
if occ:
if self.lineMatched(timeCheck, occ, x1, x2) and time[1][0][1]:
count += occ
timeCheck += self.xHop
if count:
self.options.zoomButton.setEnabled(True)
self.options.exportButton.setEnabled(True)
if count > 1:
self.options.selectedNodes.setText(str(count) + ' time values selected')
else:
self.options.selectedNodes.setText('One time value selected')
else:
self.options.zoomButton.setEnabled(False)
self.options.exportButton.setEnabled(False)
self.options.selectedNodes.setText('Nothing selected')
def lineMatched(self, usec, occ, x1, x2):
if not self.selDateMin:
dateMin = self.baseDateMin
dateMax = self.baseDateMax
else:
dateMin = self.selDateMin
dateMax = self.selDateMax
if (dateMax - dateMin) > 0:
x = ((usec - dateMin) * (self.ploter.width - self.m - self.draw.yLeftMargin)) / (dateMax - dateMin) + self.draw.yLeftMargin
if x <= self.draw.yLeftMargin:
x += 3
x_min = x - 2
x_max = x + 2
if x_min >= x1 and x_max <= x2:
return True
return False
def elementsInRange(self, root, tMin, tMax):
''' Returns amount of node in a date range, given as long
Dichotomic search, but this can be improved because we only search for
smaller timestamp and decrease index if greather.
'''
if not tMin or not tMax:
return 0
nodesCount = 0
iMin, iMax = 0, len(root['dates']) - 1
iCurrent = iMax / 2
# Sync cursor in dates list on tMin ; should be improved
while iMin != iMax or not iMax:
if tMin >= root['dates'][iCurrent] or not iCurrent:
while iCurrent and tMin >= root['dates'][iCurrent]:
# Should be improved
iCurrent -= 1
break
elif tMin < root['dates'][iCurrent]:
iMax = iCurrent
iCurrent = iMin + ((iCurrent - iMin) / 2)
# Count amount of nodes between tMin and tMax
endOfList = len(root['dates'])
while iCurrent < endOfList and tMax >= root['dates'][iCurrent]:
if tMin <= root['dates'][iCurrent]:
nodesCount += len(root['nodes'][iCurrent])
iCurrent += 1
return nodesCount
def elementsInRangeToNodeList(self, root, tMin, tMax):
''' Returns a list of nodes pointer, made of nodes in given date range.
Dichotomic search, but this can be improved because we only search for
smaller timestamp and decrease index if greather.
'''
if not tMin or not tMax:
return 0
nodesList = []
iMin, iMax = 0, len(root['dates']) - 1
iCurrent = iMax / 2
# Sync cursor in dates list on tMin ; should be improved
while iMin != iMax or not iMax:
if tMin >= root['dates'][iCurrent] or not iCurrent:
while iCurrent and tMin >= root['dates'][iCurrent]:
# Should be improved
iCurrent -= 1
break
elif tMin < root['dates'][iCurrent]:
iMax = iCurrent
iCurrent = iMin + ((iCurrent - iMin) / 2)
# Count amount of nodes between tMin and tMax
endOfList = len(root['dates'])
while iCurrent < endOfList and tMax >= root['dates'][iCurrent]:
if tMin <= root['dates'][iCurrent]:
nodesList.append(root['nodes'][iCurrent])
iCurrent += 1
return nodesList
def paintEvent(self, e):
""" """
PKWidget.paintEvent(self, e)
painter = QPainter(self)
orig_pen = QPen(painter.pen())
orig_brush = QBrush(painter.brush())
orig_font = QFont(painter.font())
metrics = painter.fontMetrics()
f_height = metrics.ascent()
text_flags = Qt.AlignHCenter | Qt.AlignVCenter
region = e.region()
for item in self._shown:
font_y = item.y + item.height / 2 + f_height / 2
item_rect = QRect(0, item.y, self.width(), item.height)
if not region.contains(item_rect):
continue
painter.setFont(orig_font)
# background
pen = item.color().dark(110)
pen.setAlpha(100)
painter.setBrush(QBrush(item.color()))
painter.setPen(QPen(pen))
w = self.width() * (item.progress * .01)
rect = QRect(0, item.y, w, item.height)
painter.drawRect(rect)
# queue pos
pen = pen.dark(140)
pen.setAlpha(255)
painter.setPen(QPen(pen))
queue_rect = QRect(self.padding, item.y + self.padding,
item.height - self.padding * 2,
item.height - self.padding * 2)
painter.drawRoundRect(queue_rect, 35, 35)
# num
if not item.num is None:
painter.setPen(orig_pen)
painter.setBrush(orig_brush)
painter.drawText(queue_rect, text_flags, str(item.num))
# text
painter.setPen(orig_pen)
painter.setBrush(orig_brush)
font = QFont('Utopia, Italic', 14, -1, True)
painter.setFont(font)
rect = QRect(item_rect)
rect.setX(item.height + self.padding * 2)
rect.setWidth(rect.width() - rect.x())
painter.drawText(rect, Qt.AlignVCenter | Qt.AlignLeft, item.text)
# state
if item.state:
font = QFont('7th Service Expanded Italic, Italic')
font.setPointSize(18)
pen = QColor(orig_pen.color())
pen.setAlpha(50)
painter.setPen(QPen(pen))
painter.setFont(font)
x = item.x
y = item.y
w = self.width()
h = item.height
rect = QRect(x, y, w, h)
flags = Qt.AlignVCenter | Qt.AlignRight
painter.drawText(rect, flags, item.state+' ')
