def initHeads(self):
self.offHead = QGraphicsTextItem()
self.hexHead = QGraphicsTextItem()
self.asciiHead = QGraphicsTextItem()
#Set Color
self.offHead.setDefaultTextColor(QColor(Qt.red))
self.hexHead.setDefaultTextColor(QColor(Qt.black))
self.asciiHead.setDefaultTextColor(QColor(Qt.darkCyan))
#Create Font
self.font = QFont("Gothic")
self.font.setFixedPitch(1)
self.font.setBold(False)
self.font.setPixelSize(14)
#Set Font
self.offHead.setFont(self.font)
self.hexHead.setFont(self.font)
self.asciiHead.setFont(self.font)
#Set Text
self.offHead.setPlainText("Offset")
self.hexHead.setPlainText(
"0 1 2 3 4 5 6 7 8 9 A B C D E F")
self.asciiHead.setPlainText("Ascii")
#Position
self.offHead.setPos(20, 0)
self.hexHead.setPos(95, 0)
self.asciiHead.setPos(520, 0)
#Add to scene
self.__scene.addItem(self.offHead)
self.__scene.addItem(self.hexHead)
self.__scene.addItem(self.asciiHead)
headLine = QGraphicsLineItem(QLineF(0, 20, 615, 20))
self.__scene.addItem(headLine)
def setOffsetHead(self):
self.offHead = QGraphicsTextItem()
self.offHead.setDefaultTextColor(QColor(Qt.red))
self.offHead.setFont(self.font)
self.offHead.setPlainText("Offset(Kb)")
self.offHead.setPos(5, 0)
self.scene.addItem(self.offHead)
def __init__(self, parent=None, scene=None):
super(EFrameLayout, self).__init__(parent, scene)
self.setFlag(QGraphicsItem.ItemIsMovable, True)
self.setAcceptsHoverEvents(True)
self.__name = QGraphicsTextItem()
self.__name.setPlainText('Frame Layout')
self.__handleWidth = 500
self.__handleHeight = 20
self.__separator = 5
self.__boundExtra = 3 + self.pen().width()
self.__handleRect = QRectF(0.0, 0.0, self.__handleWidth,
self.__handleHeight)
self.__controlsBound = 0.0
self.__controls = []
self.__isDefaultPen = False
self.__isCollapsed = True
self.__pens = {
0: EDraw.EColor.DefaultLeaveHoverPen,
1: EDraw.EColor.DefaultEnterHoverPen
}
self.setPen(self.__pens[self.__isDefaultPen])
def __init__(self,
parent,
name='Untitled',
width=180,
height=40,
blockColor="#A5A2A5",
data=None,
bold=False,
italic=False,
status=True):
"""
Constructor
"""
QGraphicsRectItem.__init__(self)
self.parentWidget = parent
self.internalData = data
self.status = status
color = QColor(0, 0, 0)
color.setNamedColor(blockColor)
self.setPen(QPen(color, 2))
if sys.version_info > (3, ) and isinstance(name, bytes):
name = str(name, "utf8", errors="ignore")
self.label = QGraphicsTextItem(name, self)
self.setFlags(self.ItemIsSelectable)
self.setCursor(QCursor(Qt.PointingHandCursor))
self.changeSize(width, height)
def setBlockHead(self):
self.blockHead = QGraphicsTextItem()
self.blockHead.setDefaultTextColor(QColor(Qt.red))
self.blockHead.setFont(self.font)
self.blockHead.setPlainText("Block")
self.blockHead.setPos(15, 0)
self.scene.addItem(self.blockHead)
def __init__(self, text, parent=None):
QGraphicsWidget.__init__(self, parent)
self.labelItem = QGraphicsTextItem(self)
self.setHtml(text)
self.labelItem.document().documentLayout().documentSizeChanged.connect(
self.onLayoutChanged)
def bgc_name_face(node, *args, **kargs):
"""
This is the item generator. It must receive a node object, and
returns a Qt4 graphics item that can be used as a node face.
"""
# Receive an arbitrary number of arguments, in this case width and
# Height of the faces and the information about the BGC
width = args[0]
height = args[1]
# Add the popup
interactive_face = InteractiveItem("Class : {}\nRelated MIBiG : {}\nCluster family : {}".format(args[2], args[4], args[3]), 0, 0, width, height)
# Keep a link within the item to access node info
interactive_face.node = node
# Remove border around the masterItem
interactive_face.setPen(QPen(QtCore.Qt.NoPen))
# Add ellipse around text
ellipse = QGraphicsEllipseItem(interactive_face.rect())
ellipse.setParentItem(interactive_face)
# Change ellipse color
ellipse.setBrush(QBrush(QColor(args[6])))
# Add node name within the ellipse
text = QGraphicsTextItem(args[5])
text.setTextWidth(50)
text.setParentItem(ellipse)
# Center text according to masterItem size
text_width = text.boundingRect().width()
text_height = text.boundingRect().height()
center = interactive_face.boundingRect().center()
text.setPos(center.x()-text_width/2, center.y()-text_height/2)
return interactive_face
def __init__(self, *args):
QGraphicsObject.__init__(self, *args)
self.setFlag(QGraphicsItem.ItemHasNoContents, True)
self.setAcceptedMouseButtons(Qt.RightButton | Qt.LeftButton)
self.setAcceptHoverEvents(True)
self.setZValue(self.Z_VALUE)
self.sourceItem = None
self.sourceAnchor = None
self.sinkItem = None
self.sinkAnchor = None
self.curveItem = LinkCurveItem(self)
self.sourceIndicator = LinkAnchorIndicator(self)
self.sinkIndicator = LinkAnchorIndicator(self)
self.sourceIndicator.hide()
self.sinkIndicator.hide()
self.linkTextItem = QGraphicsTextItem(self)
self.__sourceName = ""
self.__sinkName = ""
self.__dynamic = False
self.__dynamicEnabled = False
self.hover = False
def __init__(self, parent=None, scene=None):
super(EControlsGroup, self).__init__(parent, scene)
self.setFlag(QGraphicsItem.ItemIsMovable, True)
self.setAcceptsHoverEvents(True)
self.__kId = str(uuid.uuid1())
self.__name = QGraphicsTextItem()
self.__name.setPlainText('EddGroup')
self.__sWidth = 500
self.__sHeight = 20
self.__sExtra = 8
self.__controlsOffset = 5
self.__isDefaultPen = False
self.__pens = {
0: EDraw.EColor.DefaultLeaveHoverPen,
1: EDraw.EColor.DefaultEnterHoverPen
}
self.setPen(self.__pens[self.__isDefaultPen])
self.__shapeRect = QRectF(0, 0, self.__sWidth, self.__sHeight)
self.__controls = []
def showTextLabel(self, x, y, secure=25):
"""
add labels of principle peaks of spectrum or chroma
on the plot, return the labels, that we can show hide
"""
maxis = [] #will contain tuple(rt, intens)
indexes = []
#from core.MetObjects import MSAbstractTypes
from scipy.ndimage import gaussian_filter1d as gauss
z = gauss(y, 1)
#z = MSAbstractTypes.computeBaseLine(z, 92., 0.8)
i = 0
while i < len(z) - 1:
while z[i + 1] >= z[i] and i < len(y) - 2:
i += 1
maxis.append((x[i], y[i]))
indexes.append(i)
while z[i + 1] <= z[i] and i < len(z) - 2:
i += 1
i += 1
labels = []
for t in sorted(maxis, key=lambda x: x[1])[-5:]:
g = QGraphicsTextItem(str(t[0]))
g.setFlag(QGraphicsItem.ItemIgnoresTransformations)
font = QApplication.font()
font.setPointSizeF(6.5)
g.setFont(font)
g.setDefaultTextColor(Qt.black)
g.setPos(t[0], t[1])
labels.append(g)
self.pw.addItem(g)
return labels
def setItems(self, items):
if self._items:
self.clear()
self._items = list(items)
for item in self._items:
item.setParentItem(self)
item.setVisible(True)
fmt = self.TitleFormat.format
font = self.font()
font.setPixelSize(14)
for item in items:
text = GraphicsTextEdit(self)
text.setFont(font)
text.setDefaultTextColor(QColor("#333"))
text.setHtml(fmt(escape(item.text), item.count))
text.adjustSize()
text.editingStarted.connect(self._on_editingStarted)
text.editingFinished.connect(self._on_editingFinished)
text.documentSizeChanged.connect(self._on_itemTextSizeChanged)
self._textitems.append(text)
self._vennareas = [
VennIntersectionArea(parent=self) for i in range(2**len(items))
]
self._subsettextitems = [
QGraphicsTextItem(parent=self) for i in range(2**len(items))
]
self._updateLayout()
def __init__(self, text, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.labelItem = QGraphicsTextItem(self)
self.setHtml(text)
self.labelItem.document().documentLayout().documentSizeChanged.connect(
self.onLayoutChanged
)
def scientific_name_face(node, *args, **kwargs):
scientific_name_text = QGraphicsTextItem()
#underscore = node.name.replace("_", " ")
words = node.name.split("_")
text = []
if len(words) < 2:
# some sort of acronym or bin name, leave it alone
text = words
elif len(words) > 2:
if len(words) >= 5:
text.extend(
['<b>' + words[0] + ' <i> ' + words[1], words[2] + ' </i> '])
text.extend(words[3:] + ['</b>'])
elif len(words) == 3:
text.extend([
' <span style="color:grey"><i> ' + words[0],
words[1] + words[2] + ' </i></span>'
])
else:
# assume that everything after the
# second word is strain name
# which should not get italicized
text.extend([
' <span style="color:grey"><i> ' + words[0],
words[1] + ' </i></span>'
])
text.extend(words[2:])
else:
text.extend([
' <span style="color:grey"><i> ' + words[0],
words[1] + ' </i></span> '
])
scientific_name_text.setHtml(' '.join(text))
# below is a bit of a hack - I've found that the height of the bounding
# box gives a bit too much padding around the name, so I just minus 10
# from the height and recenter it. Don't know whether this is a generally
# applicable number to use
#myFont = QFont()
masterItem = QGraphicsRectItem(
0, 0,
scientific_name_text.boundingRect().width(),
scientific_name_text.boundingRect().height() - 10)
scientific_name_text.setParentItem(masterItem)
center = masterItem.boundingRect().center()
scientific_name_text.setPos(
masterItem.boundingRect().x(),
center.y() - scientific_name_text.boundingRect().height() / 2)
# I don't want a border around the masterItem
masterItem.setPen(QPen(QtCore.Qt.NoPen))
return masterItem
def __init__(self, text, parent):
QGraphicsObject.__init__(self, parent)
self.text_item = QGraphicsTextItem(text + ':', self)
f = self.text_item.font()
f.setBold(True)
self.text_item.setFont(f)
self.rect_item = QGraphicsRectItem(self.text_item.boundingRect(), self)
self.rect_item.setPen(QPen(Qt.NoPen))
self.rect_item.stackBefore(self.text_item)
def __init__(self, parent=None, graphicView=None, graphicScene=None):
QGraphicsItem.__init__(self)
self.set_default_data()
self.className = QGraphicsTextItem(self)
self.functionsItem = FunctionsContainerModel(self)
self.className.setPlainText(self.defaultClassName)
self.setFlag(self.ItemIsMovable)
self.setFlag(self.ItemSendsGeometryChanges)
self.functionsItem.setPos(0, self.__get_title_height())
self.attributesItem = FunctionsContainerModel(self)
self.attributesItem.setPos(0, self.functionsItem.get_height())
def __init__(self, parent=None, textItem=None):
QGraphicsLayoutItem.__init__(self, parent)
if textItem is None:
textItem = QGraphicsTextItem()
self.__textItem = textItem
self.__textItem.setParentItem(self)
self.__textItem.setPos(0, 0)
doc_layout = self.document().documentLayout()
doc_layout.documentSizeChanged.connect(self._onDocumentSizeChanged)
def __init__(self, parent=None, text=""):
super(QGraphicsPathItem, self).__init__(parent)
self.setAcceptHoverEvents(True)
self.setPen(QPen(Qt.NoPen))
self.text = QGraphicsTextItem(self)
layout = self.text.document().documentLayout()
layout.documentSizeChanged.connect(self._onLayoutChanged)
self._text = ""
self._anchor = QPointF()
def __init__(self, parent=None):
super(TakeDragGame, self).__init__(parent)
# This is always the same
self.dot2 = QGraphicsTextItem(':')
self.dot1 = QGraphicsTextItem(':')
self.animations = []
self.digits = []
self.main_layout = QHBoxLayout()
self.setLayout(self.main_layout)
self.scene = QGraphicsScene()
self.scene.setSceneRect(0, 0, 600, 400)
self.view = QGraphicsView()
self.view.setScene(self.scene)
# TODO: Check if its better with opengl or not
# self.view.setViewport(QtOpenGL.QGLWidget())
self.main_layout.addWidget(self.view)
# self.setWindowState(Qt.WindowMaximized)
self.view.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.image_bank = None
self.create_and_add_images()
def __init__(self,
id,
title='',
title_above=False,
title_location=AxisMiddle,
line=None,
arrows=0,
plot=None,
bounds=None):
QGraphicsItem.__init__(self)
self.setFlag(QGraphicsItem.ItemHasNoContents)
self.setZValue(AxisZValue)
self.id = id
self.title = title
self.title_location = title_location
self.data_line = line
self.plot = plot
self.graph_line = None
self.size = None
self.scale = None
self.tick_length = (10, 5, 0)
self.arrows = arrows
self.title_above = title_above
self.line_item = QGraphicsLineItem(self)
self.title_item = QGraphicsTextItem(self)
self.end_arrow_item = None
self.start_arrow_item = None
self.show_title = False
self.scale = None
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
path.moveTo(0, 3.09)
path.lineTo(0, -3.09)
path.lineTo(9.51, 0)
path.closeSubpath()
self.arrow_path = path
self.label_items = []
self.label_bg_items = []
self.tick_items = []
self._ticks = []
self.zoom_transform = QTransform()
self.labels = None
self.values = None
self._bounds = bounds
self.auto_range = None
self.auto_scale = True
self.zoomable = False
self.update_callback = None
self.max_text_width = 50
self.text_margin = 5
self.always_horizontal_text = False
def set_functions_list(self, functionsList, prefix="", sufix=""):
self.funtionsList = functionsList
self.funtionsListItems = []
self.maxHeight = 0
tempHeight = 0
for element in functionsList:
tempElement = QGraphicsTextItem(self)
tempElement.setPlainText(prefix + element + sufix)
tempElement.setPos(0, tempHeight)
tempHeight += tempElement.document().size().height()
if self.maxWidth < tempElement.document().size().width():
self.maxWidth = tempElement.document().size().width()
self.funtionsListItems.append(tempElement)
self.maxHeight = tempHeight
def LoopText(self):
self.textItem = QGraphicsTextItem()
self.textItem.setPlainText('Muodostui silmukka')
self.scene().addItem(self.textItem)
self.textItem.setZValue(2)
self.textItem.setPos(200,0)
fontti = QFont()
fontti.setPointSize(40)
self.textItem.setFont(fontti)
timer = QTimer()
timer.singleShot(3000,self.removeLoopText)
def appendOffsetItems(self, linesToAppend):
count = 0
x = 0
y = 25 + (len(self.offsetItems) * (self.pageh + 2))
# print "Y append offset ", y
while count <= linesToAppend:
item = QGraphicsTextItem()
item.setDefaultTextColor(QColor(Qt.red))
item.setFont(self.font)
item.setPos(x, y)
self.offsetItems.append(item)
self.scene.addItem(item)
y += self.pageh + 2
count += 1
def annotate(self):
text, bool_ = QInputDialog.getText(self.view, "Annotation dialog",
"Annotation:")
g = QGraphicsTextItem(str(text))
g.setFlag(QGraphicsItem.ItemIgnoresTransformations)
g.setFlag(QGraphicsItem.ItemIsMovable)
g.setTextInteractionFlags(Qt.TextEditorInteraction)
font = qApp.instance().font()
font.setPointSizeF(10.)
g.setFont(font)
g.setDefaultTextColor(Qt.blue)
g.setPos(500, 1e4)
self.trashItems.append(g)
self.pw.addItem(g)
def scientific_name_face(node, *args, **kwargs):
scientific_name_text = QGraphicsTextItem()
words = node.visual_label.split()
text = []
if hasattr(node, 'bg_col'):
container_div = '<div style="background-color:{};">'.format(node.bgcolor)
text.append(container_div)
if len(words) < 2:
# some sort of acronym or bin name, leave it alone
text.extend(words)
elif len(words) > 2:
if words[0] == 'Candidatus':
# for candidatus names, only the Candidatus part is italicised
# name shortening it for brevity
text.append('<i>Ca.</i>')
text.extend(words[1:])
elif re.match('^[A-Z]+$', words[0]):
# If the first word is in all caps then it is an abreviation
# so we don't want to italicize that at all
text.extend(words)
else:
# assume that everything after the second word is strain name
# which should not get italicised
text.extend(['<i>'+words[0],words[1]+'</i>'])
text.extend(words[2:])
else:
text.extend(['<i>'+words[0],words[1]+'</i>'])
if hasattr(node, 'bg_col'):
text.append('</div>')
scientific_name_text.setHtml(' '.join(text))
#print(scientific_name_text.boundingRect().width(), scientific_name_text.boundingRect().height())
# below is a bit of a hack - I've found that the height of the bounding
# box gives a bit too much padding around the name, so I just minus 10
# from the height and recenter it. Don't know whether this is a generally
# applicable number to use
masterItem = QGraphicsRectItem(0, 0, scientific_name_text.boundingRect().width(), scientific_name_text.boundingRect().height() - 10)
scientific_name_text.setParentItem(masterItem)
center = masterItem.boundingRect().center()
scientific_name_text.setPos(masterItem.boundingRect().x(), center.y() - scientific_name_text.boundingRect().height()/2)
# I dont want a border around the masterItem
masterItem.setPen(QPen(QtCore.Qt.NoPen))
return masterItem
def initOffsetItems(self):
count = 0
x = 0
y = 25
while count <= self.displayLines:
item = QGraphicsTextItem()
item.setDefaultTextColor(QColor(Qt.red))
item.setFont(self.font)
item.setPos(x, y)
self.offsetItems.append(item)
y += self.pageh + 2
count += 1
#Add Items in scene
for item in self.offsetItems:
self.scene.addItem(item)
def __init__(self, parent, name='Untitled', width=180, height=40):
"""
Constructor
"""
QGraphicsRectItem.__init__(self)
self.parentWidget = parent
if sys.version_info > (3, ):
if isinstance(name, bytes):
name = str(name, "utf8", errors="ignore")
self.label = QGraphicsTextItem(name, self)
self.setColor(blockColor="#FFFFFF")
self.changeSize(width, height)
def __init__(self, palette, values, parent):
QGraphicsObject.__init__(self, parent)
self.parent = parent
self.palette = palette
self.values = values
self.legend = parent
self.label_items = [QGraphicsTextItem(text, self) for text in values]
for i in self.label_items:
i.setTextWidth(50)
self.rect = QRectF()
self.gradient_item = QGraphicsRectItem(self)
self.gradient = QLinearGradient()
self.gradient.setStops([(v * 0.1, self.palette[v * 0.1])
for v in range(11)])
self.orientation = Qt.Horizontal
self.set_orientation(Qt.Vertical)
def setupGraphics(self):
"""
Set up the graphics.
"""
shape_rect = QRectF(-24, -24, 48, 48)
self.shapeItem = NodeBodyItem(self)
self.shapeItem.setShapeRect(shape_rect)
self.shapeItem.setAnimationEnabled(self.__animationEnabled)
# Rect for widget's 'ears'.
anchor_rect = QRectF(-31, -31, 62, 62)
self.inputAnchorItem = SinkAnchorItem(self)
input_path = QPainterPath()
start_angle = 180 - self.ANCHOR_SPAN_ANGLE / 2
input_path.arcMoveTo(anchor_rect, start_angle)
input_path.arcTo(anchor_rect, start_angle, self.ANCHOR_SPAN_ANGLE)
self.inputAnchorItem.setAnchorPath(input_path)
self.outputAnchorItem = SourceAnchorItem(self)
output_path = QPainterPath()
start_angle = self.ANCHOR_SPAN_ANGLE / 2
output_path.arcMoveTo(anchor_rect, start_angle)
output_path.arcTo(anchor_rect, start_angle, -self.ANCHOR_SPAN_ANGLE)
self.outputAnchorItem.setAnchorPath(output_path)
self.inputAnchorItem.hide()
self.outputAnchorItem.hide()
# Title caption item
self.captionTextItem = QGraphicsTextItem(self)
self.captionTextItem.setPlainText("")
self.captionTextItem.setPos(0, 33)
def iconItem(standard_pixmap):
item = GraphicsIconItem(self,
icon=standard_icon(standard_pixmap),
iconSize=QSize(16, 16))
item.hide()
return item
self.errorItem = iconItem(QStyle.SP_MessageBoxCritical)
self.warningItem = iconItem(QStyle.SP_MessageBoxWarning)
self.infoItem = iconItem(QStyle.SP_MessageBoxInformation)
def __init__(self,
text,
x,
y,
align,
bold=0,
color=None,
brushColor=None,
size=None):
orangeqt.PlotItem.__init__(self)
self.setFlag(QGraphicsItem.ItemIgnoresTransformations, True)
self._item = QGraphicsTextItem(text, parent=self)
self._data_point = QPointF(x, y)
f = self._item.font()
f.setBold(bold)
if size:
f.setPointSize(size)
self._item.setFont(f)
self._item.setPos(x, y)
def __init__(self, name, point, parent):
QGraphicsObject.__init__(self, parent)
self.text_item = QGraphicsTextItem(name, self)
if point:
s = point.size()
height = max(2 * s, self.text_item.boundingRect().height())
else:
height = self.text_item.boundingRect().height()
p = 0.5 * height
self.text_item.setPos(height, 0)
self.point_item = point
if point:
self.point_item.setParentItem(self)
self.point_item.setPos(p, p)
self._rect = QRectF(0, 0,
height + self.text_item.boundingRect().width(),
height)
self.rect_item = QGraphicsRectItem(self._rect, self)
self.rect_item.setPen(QPen(Qt.NoPen))
self.rect_item.stackBefore(self.text_item)
if self.point_item:
self.rect_item.stackBefore(self.point_item)
