def setRequired(self, required):
self.required = required
brush = QBrush()
if required:
brush.setColor(QColor(255, 0, 0))
else:
brush.setColor(QColor(0, 0, 0))
self.setForeground(0, brush)
def paint(self, painter, option, widget=None):
brush = self.brush()
if self.__hover:
brush = QBrush(brush.color().darker(110))
painter.setBrush(brush)
painter.setPen(self.pen())
painter.drawEllipse(self.rect())
def addLog(self, log):
self.log.append(log)
self.logbtn.show()
palette = QPalette()
brush = QBrush(QColor(240, 100, 100))
brush.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Normal, QPalette.Background, brush)
self.label.setPalette(palette)
self.label.setAutoFillBackground(True)
def brush_darker(brush, factor):
"""Return a copy of the brush darkened by factor.
"""
grad = brush.gradient()
if grad:
return QBrush(gradient_darker(grad, factor))
else:
brush = QBrush(brush)
brush.setColor(brush.color().darker(factor))
return brush
def paint(self, painter, option, widget=0):
# TODO: For a given zoom level and rotation and cell contents,
# cache tile rendering in a bitmap. Since many tiles are often identical
# this should provide a substatial speedup.
# TODO: Strategy: Using the given painter's transformation,
# extract size and orientation, then reset the transform and
# either blit from cache or manually scale and rotate painting into
# a QPixMap, and then blit it.
# TODO: Extend the above technique so that in the same way, alpha-masked
# pixmaps of the various component drawing operations are cached.
lod = option.levelOfDetailFromTransform(painter.worldTransform())
if lod != GraphicsTileItem._oldLOD:
GraphicsTileItem._oldLOD = lod
print "GraphicsTileItem level of detail = {0}".format(lod)
#painter.resetTransform() # restore to device coordinates, 1 = 1 pixel
#key = (self._renderSpec, lod, orientation)
#if key in self._renderCache:
# bitBlt
#else:
# pixm = QPixMap(svgr.defaultSize())
# painter = QPainter(pixm)
if lod >= 23:
painter.setClipPath(self.hexagon_qpainterpath)
painter.setPen(QtCore.Qt.NoPen)
for (renderObj, arg) in self._renderSpec:
if renderObj == simulation.RenderObjects.BG:
painter.setBrush(QBrush(QtGui.QColor.fromHsv(*Texture2HSV(arg, self._cell.Pos()))))
if self.isSelected():
painter.setPen(self.selectionPen)
elif lod >= 23:
painter.setPen(self.pen())
painter.drawConvexPolygon(self.polygon())
painter.setPen(QtCore.Qt.NoPen)
elif renderObj == simulation.RenderObjects.TARGETING:
brush = QBrush(QtGui.QColor(255,127,0), QtCore.Qt.Dense4Pattern)
brush.setTransform(QtGui.QTransform.fromScale(.1,.1))
painter.setBrush(brush)
painter.drawConvexPolygon(self.polygon())
elif renderObj == simulation.RenderObjects.NPC or renderObj == simulation.RenderObjects.PLAYER:
painter.setBrush(QtGui.QColor.fromHsv(*arg))
r = simulation.CELL_APOTHEM*3/4.0
painter.drawEllipse(QPointF(0,0), r, r)
if False:
# paint some debugging text
painter.setPen(QtCore.Qt.white)
painter.setBrush(self.brush())
#painter.setFont(QtGui.QFont("Helvetica", 8))
scale = .02
painter.scale(scale,scale)
r = QtCore.QRectF(-.5/scale,-.5/scale,1/scale,1/scale)
#txt = "{0},{1},{2}".format(self._cell.Pos().x, self._cell.Pos().y, self._cell.Pos().z)
txt = "{0}".format( vexor5.uniform3coloring(self._cell.Pos()) )
#txt = str(self._cell._region)
painter.drawText(r, QtCore.Qt.AlignCenter, txt)
def drawPoints(self):
img = qrcode.make('TestCode 001',image_factory=qrcode.image.svg.SvgImage )
type(img)
gitem = QGraphicsScene()
self.graphicsView.setScene(gitem)
#gitem.addLine(0, 0, 2, 2)
qbrush = QBrush()
qbrush.setStyle(Qt.SolidPattern)
qbrush.setColor(Qt.black)
gitem.addRect(0, 0, 2, 2, brush=qbrush )
self.graphicsView.show()
def _setup(self):
self.rod = QGraphicsLineItem(QLineF(0, 0, 0, 100))
p = QPen(QColor(100, 100, 100))
p.setWidth(5)
self.rod.setPen(p)
self.rod.setToolTip('This is the rod of the pendulum')
self.ball = QGraphicsEllipseItem(QRectF(-20, 80, 40, 40))
b = QBrush(Qt.SolidPattern)
b.setColor(QColor(0, 255, 0))
self.ball.setBrush(b)
self.ball.setToolTip('This is the ball of the pendulum where the mass is concentrated')
self.addToGroup(self.rod)
self.addToGroup(self.ball)
self.setFlags(QGraphicsItem.ItemIsSelectable)
def __init__(self,
font_loader,
canvas,
logger,
opts,
ruby_tags,
link_activated,
width=0,
height=0):
if hasattr(canvas, 'canvaswidth'):
width, height = canvas.canvaswidth, canvas.canvasheight
_Canvas.__init__(self,
font_loader,
logger,
opts,
width=width,
height=height)
self.block_id = canvas.id
self.ruby_tags = ruby_tags
self.link_activated = link_activated
self.text_width = width
fg = canvas.framecolor
bg = canvas.bgcolor
if not opts.visual_debug and canvas.framemode != 'none':
self.setPen(Pen(fg, canvas.framewidth))
self.setBrush(QBrush(Color(bg)))
self.items = []
for po in canvas:
obj = po.object
item = object_factory(self, obj, respect_max_y=True)
if item:
self.items.append((item, po.x1, po.y1))
def __updatePen(self):
self.prepareGeometryChange()
self.__boundingRect = None
if self.__dynamic:
if self.__dynamicEnabled:
color = QColor(0, 150, 0, 150)
else:
color = QColor(150, 0, 0, 150)
normal = QPen(QBrush(color), 2.0)
hover = QPen(QBrush(color.darker(120)), 2.1)
else:
normal = QPen(QBrush(QColor("#9CACB4")), 2.0)
hover = QPen(QBrush(QColor("#7D7D7D")), 2.1)
self.curveItem.setCurvePenSet(normal, hover)
def moveTo(self, pos):
#data coordinates
oldX, oldY = self.pos.x(), self.pos.y()
x, y = pos.x(), pos.y()
line = QGraphicsLineItem(oldX, oldY, x, y)
line.setPen(
QPen(QBrush(Qt.white), self.brushSize, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin))
self.scene.addItem(line)
self._hasMoved = True
#update bounding Box
if not self.bb.isValid():
self.bb = QRect(QPoint(oldX, oldY), QSize(1, 1))
#grow bounding box
self.bb.setLeft(min(self.bb.left(), max(0,
x - self.brushSize / 2 - 1)))
self.bb.setRight(
max(self.bb.right(),
min(self.sliceRect[0] - 1, x + self.brushSize / 2 + 1)))
self.bb.setTop(min(self.bb.top(), max(0, y - self.brushSize / 2 - 1)))
self.bb.setBottom(
max(self.bb.bottom(),
min(self.sliceRect[1] - 1, y + self.brushSize / 2 + 1)))
#update/move position
self.pos = pos
def __init__(self, parent, _name, path):
QTreeWidgetItem.__init__(self, parent)
self._parent = parent
self.setText(0, _name)
self.path = path
self.isFolder = True
self.setForeground(0, QBrush(QColor(255, 165, 0)))
project = json_manager.read_ninja_project(path)
self.name = project.get('name', '')
if self.name == '':
self.name = _name
self.setText(0, self.name)
self.projectType = project.get('project-type', '')
self.description = project.get('description', '')
self.url = project.get('url', '')
self.license = project.get('license', '')
self.mainFile = project.get('mainFile', '')
self.preExecScript = project.get('preExecScript', '')
self.postExecScript = project.get('postExecScript', '')
self.indentation = project.get('indentation', settings.INDENT)
self.useTabs = project.get('use-tabs', settings.USE_TABS)
self.extensions = project.get('supported-extensions',
settings.SUPPORTED_EXTENSIONS)
self.pythonPath = project.get('pythonPath', settings.PYTHON_PATH)
self.PYTHONPATH = project.get('PYTHONPATH', '')
self.additional_builtins = project.get('additional_builtins', [])
self.programParams = project.get('programParams', '')
self.venv = project.get('venv', '')
self.related_projects = project.get('relatedProjects', [])
self.update_paths()
self.addedToConsole = False
def __init__(self, parent, _name, path):
QTreeWidgetItem.__init__(self, parent)
self._parent = parent
self.setText(0, _name)
self.path = path
self.isFolder = True
self.setForeground(0, QBrush(Qt.darkGray))
project = json_manager.read_ninja_project(path)
self.name = project.get('name', '')
if self.name == '':
self.name = _name
self.setText(0, self.name)
self.projectType = project.get('project-type', '')
self.description = project.get('description', '')
self.url = project.get('url', '')
self.license = project.get('license', '')
self.mainFile = project.get('mainFile', '')
self.preExecScript = project.get('preExecScript', '')
self.postExecScript = project.get('postExecScript', '')
self.extensions = project.get('supported-extensions',
settings.SUPPORTED_EXTENSIONS)
self.pythonPath = project.get('pythonPath', settings.PYTHON_PATH)
self.programParams = project.get('programParams', '')
self.venv = project.get('venv', '')
self.addedToConsole = False
def _cat_desc_to_std_item(self, desc):
"""
Create a QStandardItem for the category description.
"""
item = QStandardItem()
item.setText(desc.name)
if desc.icon:
icon = desc.icon
else:
icon = "icons/default-category.svg"
icon = icon_loader.from_description(desc).get(icon)
item.setIcon(icon)
if desc.background:
background = desc.background
else:
background = DEFAULT_COLOR
background = NAMED_COLORS.get(background, background)
brush = QBrush(QColor(background))
item.setData(brush, self.BACKGROUND_ROLE)
tooltip = desc.description if desc.description else desc.name
item.setToolTip(tooltip)
item.setFlags(Qt.ItemIsEnabled)
item.setData(desc, self.CATEGORY_DESC_ROLE)
return item
def paint(self, painter, option, widget):
painter.save()
dirtyColor = QColor(255,0,0)
painter.setOpacity(0.5)
painter.setBrush(QBrush(dirtyColor, Qt.SolidPattern))
painter.setPen(dirtyColor)
intersected = self._tiling.intersected(option.exposedRect)
#print "pies are painting at ", option.exposedRect
progress = 0.0
for i in intersected:
progress += self._indicate[i]
if not(self._indicate[i] < 1.0): # only paint for less than 100% progress
continue
# Don't show unless a delay time has passed since the tile progress was reset.
delta = datetime.datetime.now() - self._zeroProgressTimestamp[i]
if delta < self.delay:
t = QTimer.singleShot(int(delta.total_seconds()*1000.0), self.update)
continue
p = self._tiling.tileRectFs[i]
w,h = p.width(), p.height()
r = min(w,h)
rectangle = QRectF(p.center()-QPointF(r/4,r/4), QSizeF(r/2, r/2));
startAngle = 0 * 16
spanAngle = min(360*16, int((1.0-self._indicate[i])*360.0) * 16)
painter.drawPie(rectangle, startAngle, spanAngle)
painter.restore()
def __init__(self, mapCanvas, feature, layer):
super(FeatureHighlightItem, self).__init__(mapCanvas)
self._mapCanvas = None # QgsMapCanvas
self._brush = QBrush()
self._pen = QPen()
self._feature = None # QgsFeature()
self._layer = None # QgsMapLayer()
self._buffer = 0.0
self._minWidth = 0.0
self._mapCanvas = mapCanvas
if (not layer
or not feature
or not isinstance(feature, QgsFeature)
or not feature.geometry()
or feature.geometry().isEmpty()
or not feature.geometry().isGeosValid()):
return
self._feature = QgsFeature(feature) # Force deep copy
self._layer = layer
self.setLineColor(Application.highlightLineColor())
self.setFillColor(Application.highlightFillColor())
self._minWidth = Application.highlightMinimumWidth()
self._buffer = Application.highlightBuffer()
if self._mapCanvas.mapSettings().hasCrsTransformEnabled():
ct = self._mapCanvas.mapSettings().layerTransform(self._layer)
if ct:
self._feature.geometry().transform(ct)
self.updateRect()
self.update()
def getSampleModel(spl, flags='peak', **kw):
from gui.MetBaseGui import MSStandardItem
if flags not in ('peak', 'cluster', 'id'):
return
model = QStandardItemModel()
if flags == 'peak':
from utils.misc import Hot
areas = [peak.area for peak in spl.rawPeaks.ipeaks()]
mxInt = max(areas)
model.setHorizontalHeaderLabels(MSSample.peakModelLabel)
for i, peak in enumerate(spl.rawPeaks.ipeaks()):
model.setItem(i, 0, MSStandardItem(str(peak.mass())))
model.item(i, 0).setBackground(
QBrush(Hot._get_color(areas[i] / mxInt, True, alpha=0.5)))
model.setItem(i, 1, MSStandardItem(str(peak.rt)))
model.item(i, 1).setBackground(
QBrush(Hot._get_color(areas[i] / mxInt, True, alpha=0.5)))
model.setItem(i, 2, MSStandardItem(str(peak.area)))
model.item(i, 2).setBackground(
QBrush(Hot._get_color(areas[i] / mxInt, True, alpha=0.5)))
model.setItem(i, 3, MSStandardItem(str(peak.sn)))
model.item(i, 3).setBackground(
QBrush(Hot._get_color(areas[i] / mxInt, True, alpha=0.5)))
model.setItem(i, 4, MSStandardItem(str(peak.r_coef)))
model.item(i, 4).setBackground(
QBrush(Hot._get_color(areas[i] / mxInt, True, alpha=0.5)))
elif flags == 'cluster':
model.setHorizontalHeaderLabels(MSSample.clusterModelLabel)
for i, peak in enumerate(spl.mappedPeaks.ipeaks()):
model.setItem(i, 0, MSStandardItem(str(peak.mass())))
model.setItem(i, 1, MSStandardItem(str(peak.rt)))
model.setItem(i, 2, MSStandardItem(str(peak.area)))
info_iso = ""
info_frag = ""
for iso in peak.isoCluster:
info_iso += '%s/%s\t' % (str(iso.mass()), str(iso.rt))
for add in peak.fragCluster:
info_frag += '%s/%s\t' % (str(add.mass()), str(add.rt))
model.setItem(i, 3, MSStandardItem(info_iso))
model.setItem(i, 4, MSStandardItem(info_frag))
return model
def __init__(self, *args):
QWidget.__init__(self, *args)
self._messages = []
self._defaultTimeout = 0
self._defaultPixmap = QPixmap(":/enkiicons/infos.png")
self._defaultBackground = QBrush(QColor(250, 230, 147))
self._defaultForeground = QBrush(QColor(0, 0, 0))
# pixmap
self.lPixmap = QLabel(self)
self.lPixmap.setAlignment(Qt.AlignCenter)
self.lPixmap.setSizePolicy(
QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Preferred))
# message
self.lMessage = QLabel(self)
self.lMessage.setAlignment(Qt.AlignVCenter | Qt.AlignLeft)
self.lMessage.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred))
self.lMessage.setWordWrap(True)
self.lMessage.setOpenExternalLinks(True)
self.lMessage.setTextInteractionFlags(Qt.TextBrowserInteraction)
# button
self.dbbButtons = QDialogButtonBox(self)
# if false - buttons don't have neither text nor icons
self.dbbButtons.setStyleSheet(
"dialogbuttonbox-buttons-have-icons: true;")
self.dbbButtons.setSizePolicy(
QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Preferred))
self.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum))
# layout
self.hbl = QHBoxLayout(self)
self.hbl.setMargin(0)
self.hbl.addWidget(self.lPixmap, 0, Qt.AlignCenter)
self.hbl.addWidget(self.lMessage)
self.hbl.addWidget(self.dbbButtons, 0, Qt.AlignCenter)
# connections
self.lMessage.linkActivated.connect(self.linkActivated)
self.lMessage.linkHovered.connect(self.linkHovered)
self.dbbButtons.clicked.connect(self.buttonClicked)
def _paint_screen(self, painter):
# Speed hacks: local name lookups are faster
vars().update(QColor=QColor, QBrush=QBrush, QPen=QPen, QRect=QRect)
background_color_map = self.background_color_map
foreground_color_map = self.foreground_color_map
char_width = self._char_width
char_height = self._char_height
painter_drawText = painter.drawText
painter_fillRect = painter.fillRect
painter_setPen = painter.setPen
align = Qt.AlignTop | Qt.AlignLeft
# set defaults
background_color = background_color_map[14]
foreground_color = foreground_color_map[15]
brush = QBrush(QColor(background_color))
painter_fillRect(self.rect(), brush)
pen = QPen(QColor(foreground_color))
painter_setPen(pen)
y = 0
text = []
text_append = text.append
for row, line in enumerate(self._screen):
col = 0
text_line = ""
for item in line:
if isinstance(item, str):
x = col * char_width
length = len(item)
rect = QRect(x, y, x + char_width * length,
y + char_height)
painter_fillRect(rect, brush)
painter_drawText(rect, align, item)
col += length
text_line += item
else:
foreground_color_idx, background_color_idx, underline_flag = item
foreground_color = foreground_color_map[
foreground_color_idx]
background_color = background_color_map[
background_color_idx]
pen = QPen(QColor(foreground_color))
brush = QBrush(QColor(background_color))
painter_setPen(pen)
# painter.setBrush(brush)
y += char_height
text_append(text_line)
self._text = text
def paint(self, painter, option, widget=None):
rect = QRectF(-(ModelerGraphicItem.BOX_WIDTH + 2) / 2.0,
-(ModelerGraphicItem.BOX_HEIGHT + 2) / 2.0,
ModelerGraphicItem.BOX_WIDTH + 2,
ModelerGraphicItem.BOX_HEIGHT + 2)
painter.setPen(QPen(Qt.gray, 1))
color = QColor(125, 232, 232)
if isinstance(self.element, ModelerParameter):
color = QColor(179, 179, 255)
elif isinstance(self.element, Algorithm):
color = Qt.white
painter.setBrush(QBrush(color, Qt.SolidPattern))
painter.drawRect(rect)
font = QFont('Verdana', 8)
painter.setFont(font)
painter.setPen(QPen(Qt.black))
text = self.getAdjustedText(self.text)
if isinstance(self.element, Algorithm) and not self.element.active:
painter.setPen(QPen(Qt.gray))
text = text + "\n(deactivated)"
elif self.isSelected():
painter.setPen(QPen(Qt.blue))
fm = QFontMetricsF(font)
text = self.getAdjustedText(self.text)
h = fm.height()
pt = QPointF(-ModelerGraphicItem.BOX_WIDTH / 2 + 25, h / 2.0)
painter.drawText(pt, text)
painter.setPen(QPen(Qt.black))
if isinstance(self.element, Algorithm):
h = -(fm.height() * 1.2)
h = h - ModelerGraphicItem.BOX_HEIGHT / 2.0 + 5
pt = QPointF(-ModelerGraphicItem.BOX_WIDTH / 2 + 25, h)
painter.drawText(pt, 'In')
i = 1
if not self.element.paramsFolded:
for param in self.element.algorithm.parameters:
if not param.hidden:
text = self.getAdjustedText(param.description)
h = -(fm.height() * 1.2) * (i + 1)
h = h - ModelerGraphicItem.BOX_HEIGHT / 2.0 + 5
pt = QPointF(-ModelerGraphicItem.BOX_WIDTH / 2
+ 33, h)
painter.drawText(pt, text)
i += 1
h = fm.height() * 1.2
h = h + ModelerGraphicItem.BOX_HEIGHT / 2.0
pt = QPointF(-ModelerGraphicItem.BOX_WIDTH / 2 + 25, h)
painter.drawText(pt, 'Out')
if not self.element.outputsFolded:
for i, out in enumerate(self.element.algorithm.outputs):
text = self.getAdjustedText(out.description)
h = fm.height() * 1.2 * (i + 2)
h = h + ModelerGraphicItem.BOX_HEIGHT / 2.0
pt = QPointF(-ModelerGraphicItem.BOX_WIDTH / 2
+ 33, h)
painter.drawText(pt, text)
if self.pixmap:
painter.drawPixmap(-(ModelerGraphicItem.BOX_WIDTH / 2.0) + 3, -8,
self.pixmap)
def View3(self):
#Nueva vista 3
palette = QPalette()
palette.setBrush(
QPalette.Background,
QBrush(QPixmap(self.VIEW_3).scaled(self.size_x, self.size_y)))
self.ui.setPalette(palette)
#Acción Envía Vista 3
self.ui.setCurrentWidget(self.ui.View3)
if self.flag_Key == 3:
#Vista 3
self.ui.title_v3.move(int(self.size_x / 2 - self.t3x / 2),
int(self.size_y / 9))
self.ui.photo_ranger.move(int(self.size_x / 2 - self.fx / 2),
int(self.size_y / 6))
self.ui.name_v3.move(int(self.size_x / 2 - self.name_x / 2),
int(self.size_y / 2 + 2 * self.name_y))
self.ui.continue_btn_V3.move(int(self.size_x / 2 - self.c3x / 2),
int(self.y_init_btn))
#Vista 6
self.ui.the_gif_validate.move(self.size_x + 1, self.size_y + 1)
self.ui.title_V6.move(self.size_x + 1, self.size_y + 1)
self.ui.acepto.move(self.size_x + 1, self.size_y + 1)
self.ui.acepto_btn.move(self.size_x + 1, self.size_y + 1)
self.ui.cancelar.move(self.size_x + 1, self.size_y + 1)
for i in range(len(self.IsChecked)):
if self.IsChecked[i][1] == True:
face_ranger = QPixmap(self.URL_FACES[i])
self.ui.photo_ranger.setPixmap(face_ranger)
break
elif self.flag_Key == 5:
#Vista 6
#----------------------
#Aqui se pone el gif :)
self.ui.the_gif_validate.setMovie(self.movie)
self.movie.start()
#----------------------
self.ui.the_gif_validate.move(
int(self.size_x / 2 - self.gif2_x / 2), int(self.altura_gif2))
self.ui.title_V6.move(int(self.size_x / 2 - self.mail_x / 2),
int(self.altura_mail))
self.ui.acepto.move(int(self.size_x / 2 - self.acepto_x / 2),
int(self.altura_acepto))
self.ui.acepto_btn.move(int(0.26 * self.size_x),
int(self.altura_acepto + 5))
self.ui.continue_btn_V3.move(int(self.size_x / 2),
int(self.y_init_btn))
self.ui.cancelar.move(int(self.size_x / 25), int(self.y_init_btn))
#Vista 3
self.ui.title_v3.move(self.size_x + 1, self.size_y + 1)
self.ui.photo_ranger.move(self.size_x + 1, self.size_y + 1)
self.ui.name_v3.move(self.size_x + 1, self.size_y + 1)
def paint( self, painter, option, widget ):
color = self.__settings.lineColor
if self.color:
color = self.color
self.setBrush( QBrush( color ) )
QGraphicsSimpleTextItem.paint( self, painter, option, widget )
return
def brash(self, color):
if color in self._brash:
return self._brash[color]
_color = self.background_color_map.get(color, color)
brash = QBrush(QColor(_color))
self._brash[color] = brash
return brash
def setBrush(self, brush):
"""
Sets the main background brush used for this widget to the inputed
brush.
:param brush | <QBrush> || <QColor>
"""
self._brush = QBrush(brush)
def addExploitSuccess(self, exploit):
if exploit not in self.__exploitsSuccess:
self.__exploitsSuccess.append(exploit)
root = self.treeWidget.invisibleRootItem()
for i in range(root.childCount()):
item = root.child(i)
if item.text(0) == exploit.name:
item.setForeground(0, QBrush(QColor(Qt.green)))
def shape(self):
if self.__shape is None:
path = self.path()
pen = QPen(QBrush(Qt.black),
max(self.pen().widthF(), 20),
Qt.SolidLine)
self.__shape = stroke_path(path, pen)
return self.__shape
def setCut(self):
""" Called to indicate this instance is cut.
@return None
"""
self.cutSource = True
self.copySource = False
self.setForeground(QBrush(QColor(Qt.red)))
def paint(self, painter, option, index):
painter.save()
# set background color and text color
if option.state & QStyle.State_Selected:
painter.setBrush(QBrush(QColor("#FF9999")))
else:
painter.setBrush(QBrush(Qt.white))
painter.drawRect(option.rect)
painter.setPen(QPen(Qt.black))
painter.setFont(self.font)
text = index.data(Qt.DisplayRole)
try:
painter.drawText(option.rect, Qt.AlignLeft, text.toString())
except:
painter.drawText(option.rect, Qt.AlignLeft, text)
painter.restore()
def paintEvent(self, event):
qp = QPainter(self)
qp.setBrush(QBrush(self.color))
qp.setPen(self.color)
qp.drawRect(0, 0, 25, 25)
qp.setBrush(Qt.NoBrush)
qp.setPen(Qt.black)
qp.drawRect(1, 1, 24, 24)
def __init__(self, x, y):
node.__init__(self)
self.setRect(QRectF(int(x), int(y), 18, 18))
self.moveBy(1, 1)
self.setBrush(QBrush(eval(settings.player)))
self.setPen(QPen(Qt.NoPen))
self.setFlag(QGraphicsItem.ItemIsFocusable)
self.steroidTaken = 0
def paint(self, painter, option, widget=None):
# pylint: disable=missing-docstring
dist_sum = sum(self.dist)
start_angle = 0
colors = self.scene().colors
for i in range(len(self.dist)):
angle = self.dist[i] * 16 * 360. / dist_sum
if angle == 0:
continue
painter.setBrush(QBrush(colors[i]))
painter.setPen(QPen(colors[i]))
painter.drawPie(-self.r, -self.r, 2 * self.r, 2 * self.r,
int(start_angle), int(angle))
start_angle += angle
painter.setPen(QPen(Qt.black))
painter.setBrush(QBrush())
painter.drawEllipse(-self.r, -self.r, 2 * self.r, 2 * self.r)
def __init__(self, canvas):
self._yaw = 0
self._angle = 0
self.size = 8
self.halfsize = self.size / 2.0
super(PostionMarker, self).__init__(canvas)
self.canvas = canvas
colorvalue = "#019633"
colour = QColor(colorvalue)
colour.setAlpha(50)
self.conebrush = QBrush(colour)
pencolour = QColor(colorvalue)
self.pointpen = QPen(pencolour, 1)
self.solidbrush = QBrush(pencolour)
self.map_pos = QgsPoint()
self.tracking = False
def __init__(self, parent=None, **kwargs):
QGraphicsObject.__init__(self, parent, **kwargs)
self.setFlag(QGraphicsObject.ItemSendsGeometryChanges)
self.__path = QPainterPath()
self.__brush = QBrush(Qt.NoBrush)
self.__pen = QPen()
self.__boundingRect = None
def basefinished(self):
if self.basereply.error() != QNetworkReply.NoError:
return
self.basepixmap = QPixmap()
self.basepixmap.loadFromData(self.basereply.readAll())
if self.basepixmap.size() != self.rect.size():
self.basepixmap = self.basepixmap.scaled(self.rect.size(),
Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.setPixmap(self.basepixmap)
# make marker pixmap
self.mkpixmap = QPixmap(self.basepixmap.size())
self.mkpixmap.fill(Qt.transparent)
br = QBrush(QColor(Config.dimcolor))
painter = QPainter()
painter.begin(self.mkpixmap)
painter.fillRect(0, 0, self.mkpixmap.width(), self.mkpixmap.height(),
br)
for marker in self.radar['markers']:
pt = getPoint(marker["location"], self.point, self.zoom,
self.rect.width(), self.rect.height())
mk2 = QImage()
mkfile = 'teardrop'
if 'image' in marker:
mkfile = marker['image']
if os.path.dirname(mkfile) == '':
mkfile = os.path.join('markers', mkfile)
if os.path.splitext(mkfile)[1] == '':
mkfile += '.png'
mk2.load(mkfile)
if mk2.format != QImage.Format_ARGB32:
mk2 = mk2.convertToFormat(QImage.Format_ARGB32)
mkh = 80 # self.rect.height() / 5
if 'size' in marker:
if marker['size'] == 'small':
mkh = 64
if marker['size'] == 'mid':
mkh = 70
if marker['size'] == 'tiny':
mkh = 40
if 'color' in marker:
c = QColor(marker['color'])
(cr, cg, cb, ca) = c.getRgbF()
for x in range(0, mk2.width()):
for y in range(0, mk2.height()):
(r, g, b, a) = QColor.fromRgba(mk2.pixel(x,
y)).getRgbF()
r = r * cr
g = g * cg
b = b * cb
mk2.setPixel(x, y, QColor.fromRgbF(r, g, b, a).rgba())
mk2 = mk2.scaledToHeight(mkh, 1)
painter.drawImage(pt.x - mkh / 2, pt.y - mkh / 2, mk2)
painter.end()
self.wmk.setPixmap(self.mkpixmap)
def _makePixmap(self, width, height):
pixmap = QPixmap(width, height)
style = self.brushComboBox.itemData(
self.brushComboBox.currentIndex()).toInt()[0]
brush = QBrush(self.color, Qt.BrushStyle(style))
painter = QPainter(pixmap)
painter.fillRect(pixmap.rect(), Qt.white)
painter.fillRect(pixmap.rect(), brush)
return pixmap
def color_for_label(self, ind, light=100):
color = Qt.lightGray
if isinstance(self.variable, ContinuousVariable):
color = self.label_colors[ind].lighter(light)
elif isinstance(self.variable, DiscreteVariable):
value = self.values[ind]
if not isnan(value):
color = QColor(*self.variable.colors[value])
return QBrush(color)
def paintCell(self,
painter,
rect,
date,
_HIGHLIGHTED_BRUSH=QBrush(QColor(0xFF, 0xFF, 0, 0xAA),
Qt.DiagCrossPattern)):
super().paintCell(painter, rect, date)
if self.minimumDate() <= date <= self.maximumDate():
painter.fillRect(rect, _HIGHLIGHTED_BRUSH)
def data(self, index, role=Qt.DisplayRole):
"""获取index位置的数据"""
if not index.isValid():
return QVariant()
if role == Qt.TextColorRole:
node = self.node_from_index(index)
string = node.text()
if OrderTreeModel.order_reg.match(string): # 订单结点
profit_child = node.child(6) # 第6个孩子结点是收益结点
if '-' in profit_child.text(): # 收益为负，订单结点绿色，否则红色
return QBrush(QColor(0, 180, 0))
else:
return QBrush(QColor(255, 0, 0))
elif role == Qt.DisplayRole:
node = self.node_from_index(index)
return QVariant(node.text())
else:
return QVariant()
def setColor(self, blockColor):
"""
Set color
"""
color = QColor(0, 0, 0)
color.setNamedColor(blockColor)
self.setPen(QPen(color, 1))
self.setBrush(QBrush(color))
def data(self, index, role):
if not index.isValid():
return None
item = index.internalPointer()
node = item.node()
attributes = []
attributeMap = node.attributes()
if role == Qt.DisplayRole:
if index.column() == 0:
return attributeMap.namedItem("subject").nodeValue()
elif index.column() == 1:
return attributeMap.namedItem(
"percentageComplete").nodeValue().toInt()[0]
return None
elif role == Qt.CheckStateRole:
if index.column() == 0:
if attributeMap.namedItem(
"percentageComplete").nodeValue() == "100":
return Qt.Checked
else:
return Qt.Unchecked
elif role == Qt.FontRole:
if index.column() == 0:
font = QFont()
if attributeMap.namedItem(
"percentageComplete").nodeValue() == "100":
font.setStrikeOut(True)
else:
font.setStrikeOut(False)
return font
elif role == Qt.ForegroundRole:
if index.column() == 0:
if attributeMap.namedItem(
"percentageComplete").nodeValue() == "100":
brush = QBrush()
brush.setColor(QColor("grey"))
return brush
return None
def occu_color(self):
for r in range(0, self.rowCount()):
val = int(self.item(r, 2).text())
if val == 0:
color = QBrush(QColor(217, 214, 219))
color.setStyle(Qt.SolidPattern)
self.item(r, 2).setBackground(color)
elif val == 1:
color = QBrush(QColor(122, 125, 128))
color.setStyle(Qt.SolidPattern)
self.item(r, 2).setBackground(color)
elif val == 2:
color = QBrush(QColor(79, 74, 79))
color.setStyle(Qt.SolidPattern)
self.item(r, 2).setBackground(color)
def data(self, index, role=Qt.DisplayRole):
column = index.column()
if role == Qt.DisplayRole:
field = self._mapping[index.row()]
column_def = self.columns[column]
value = field[column_def['name']]
fieldType = column_def['type']
if fieldType == QVariant.Type:
if value == QVariant.Invalid:
return ''
return self.fieldTypes[value]
return value
if role == Qt.EditRole:
field = self._mapping[index.row()]
column_def = self.columns[column]
value = field[column_def['name']]
return value
if role == Qt.TextAlignmentRole:
fieldType = self.columns[column]['type']
if fieldType in [QVariant.Int]:
hAlign = Qt.AlignRight
else:
hAlign = Qt.AlignLeft
return hAlign + Qt.AlignVCenter
if role == Qt.ForegroundRole:
column_def = self.columns[column]
if column_def['name'] == 'expression':
brush = QBrush()
if self._errors[index.row()]:
brush.setColor(Qt.red)
else:
brush.setColor(Qt.black)
return brush
if role == Qt.ToolTipRole:
column_def = self.columns[column]
if column_def['name'] == 'expression':
return self._errors[index.row()]
def __init__(self, parent=None):
super(ColorPanel, self).__init__(parent)
self.rect = QRectF(0, 0, 20, 20)
self.setFlag(QGraphicsItem.ItemIgnoresTransformations)
self.colordialog = QColorDialog()
self.colordialog.setOption(QColorDialog.DontUseNativeDialog)
self._colorIndex = 0
self._color = self._colors[0]
self._brush = QBrush(self._color)
self.hide()
def data(self, idx, role=Qt.DisplayRole):
d = self.data_list[idx.row()]
if role == Qt.DisplayRole:
if idx.column() == 1:
return d.device_type()
elif idx.column() == 0:
dname = QString(d.device_name())
if d.is_hide():
dname = QString("%1 (%2)").arg(dname).arg(self.tr("disable notification"))
return dname
elif role == Qt.DecorationRole:
if d.device_type() == "net":
return self.wifi_icon
else:
return self.hard_icon
elif role == Qt.TextColorRole:
if len(d.selected_driver()) != 0:
blue_brush = QBrush()
blue_brush.setColor(Qt.darkBlue)
return blue_brush
return QtCore.QVariant()
class ColorPanel(QGraphicsItem):
"""docstring for ColorPanel"""
_colors = styles.stapleColors
_pen = Qt.NoPen # QPen(styles.bluestroke, 2)
def __init__(self, parent=None):
super(ColorPanel, self).__init__(parent)
self.rect = QRectF(0, 0, 20, 20)
self.setFlag(QGraphicsItem.ItemIgnoresTransformations)
self.colordialog = QColorDialog()
self.colordialog.setOption(QColorDialog.DontUseNativeDialog)
self._colorIndex = 0
self._color = self._colors[0]
self._brush = QBrush(self._color)
self.hide()
def boundingRect(self):
return self.rect
def paint(self, painter, option, widget=None):
painter.setBrush(self._brush)
painter.setPen(self._pen)
painter.drawRect(self.boundingRect())
def nextColor(self):
"""docstring for nextColor"""
self._colorIndex += 1
if self._colorIndex == len(self._colors):
self._colorIndex = 0
self._color = self._colors[self._colorIndex]
self._brush.setColor(self._color)
def colorName(self):
"""docstring for color"""
return self._color.name()
def mousePressEvent(self, event):
self._color = self.colordialog.getColor(self._color)
self._brush = QBrush(self._color)
def paint(self, painter, option, widget=None):
painter.save()
path = self.path()
brush = QBrush(self.brush())
pen = QPen(self.pen())
if option.state & QStyle.State_Selected:
pen.setColor(Qt.red)
brush.setStyle(Qt.DiagCrossPattern)
brush.setColor(QColor(40, 40, 40, 100))
elif option.state & QStyle.State_MouseOver:
pen.setColor(Qt.blue)
if option.state & QStyle.State_MouseOver:
brush.setColor(QColor(100, 100, 100, 100))
if brush.style() == Qt.NoBrush:
# Make sure the highlight is actually visible.
brush.setStyle(Qt.SolidPattern)
painter.setPen(pen)
painter.setBrush(brush)
painter.drawPath(path)
painter.restore()
def __init__(self):
super(Dial, self).__init__()
self.angle = 0
# Colors
self.color = QColor(120, 120, 120, 255)
self.notchColor = QColor(115, 115, 115, 255)
self.normalBorderColor = QColor( 255, 255, 255, 30 )
self.selectedBorderColor = QColor( 255, 191, 0, 102 )
self.textColor = QColor( 30, 30, 30, 255 )
self.shadowColor = QColor(0, 0, 0, 75)
self.selectedShadowColor = QColor( 100, 100, 100, 255 )
# Settings
self.width, self.height = 75, 75
# Drop Shadow
self.shadowBlurRadius = 8
self.shadow = QGraphicsDropShadowEffect()
self.shadow.setBlurRadius(self.shadowBlurRadius)
self.shadow.setOffset(0, 0.5)
self.shadow.setColor(self.shadowColor)
self.setGraphicsEffect(self.shadow)
# Painter Definitions
self.pen = QPen()
gradient = QRadialGradient(self.boundingRect().center() + QPointF(0, -20), 80)
gradient.setColorAt(0, self.color.lighter(117))
gradient.setColorAt(1, self.color)
self.brush = QBrush(gradient)
self.font = QFont()
self.pen.setWidth(1)
self.pen.setColor(self.normalBorderColor)
self.brush.setColor(self.color)
self.font.setPointSize(10)
# Nodegraph Definitions
self.dragPoint = None
self.dragAngle = 0
self.dragFactor = 0
# Notch Specifications
self.notch = DialNotch()
self.notch.setParentItem(self)
self.updateNotch()
def __init__(self, mapCanvas, geometry, layer):
super(GeometryHighlightItem, self).__init__(mapCanvas)
self._mapCanvas = None # QgsMapCanvas
self._geometry = None # QgsGeometry()
self._brush = QBrush()
self._pen = QPen()
self._mapCanvas = mapCanvas
if not geometry or not isinstance(geometry, QgsGeometry) or geometry.isEmpty() or not geometry.isGeosValid():
return
self._geometry = QgsGeometry(geometry) # Force deep copy
self.setLineColor(Application.highlightLineColor())
self.setFillColor(Application.highlightFillColor())
if (layer and self._mapCanvas.mapSettings().hasCrsTransformEnabled()):
ct = self._mapCanvas.mapSettings().layerTransform(layer)
if ct:
self._geometry.transform(ct)
self.updateRect()
self.update()
def __init__(self, channelname='masarService', parent=None):
super(masarUI, self).__init__(parent)
self.setupUi(self)
self.__setDateTime()
self.tabWindowDict = {'comment': self.commentTab}
self.e2cDict = {} # event to config dictionary
self.pv4cDict = {} # pv name list for each selected configuration
self.data4eid = {}
self.arrayData = {} # store all array data
self.__service = 'masar'
self.mc = masarClient.client(channelname)
self.__initSystemBomboBox()
self.currentConfigFilter = str(self.configFilterLineEdit.text())
self.eventConfigFilter = str(self.eventFilterLineEdit.text())
self.authorText = str(self.authorTextEdit.text())
self.UTC_OFFSET_TIMEDELTA = datetime.datetime.utcnow() - datetime.datetime.now()
self.time_format = "%Y-%m-%d %H:%M:%S"
self.previewId = None
self.previewConfName = None
self.isPreviewSaved = True
# set bad pv row to grey
self.brushbadpv = QBrush(QColor(128, 128, 128))
self.brushbadpv.setStyle(Qt.SolidPattern)
# DBR_TYPE definition
#define DBF_STRING 0
#define DBF_INT 1
#define DBF_SHORT 1
#define DBF_FLOAT 2
#define DBF_ENUM 3
#define DBF_CHAR 4
#define DBF_LONG 5
#define DBF_DOUBLE 6
self.epicsLong = [1, 4, 5]
self.epicsString = [0, 3]
self.epicsDouble = [2, 6]
self.epicsNoAccess = [7]
# QT
from PyQt4.QtCore import *
from PyQt4.QtGui import QTableWidget, QTableWidgetItem, QBrush, QColor
# Python <2.7 suport
try:
from collections import OrderedDict
except:
from lib.ordered_dictionary import OrderedDict
# COLORS
red = QBrush(QColor(255, 0, 0))
red.setStyle(Qt.SolidPattern)
white = QBrush(QColor(255, 255, 255))
white.setStyle(Qt.SolidPattern)
blue = QBrush(QColor(51, 153, 255))
blue.setStyle(Qt.SolidPattern)
color = {"red": red, "white": white, "blue": blue}
# Tooltips
dic_orbital_space = OrderedDict([('btn_frozen', 'Frozen orbital'),
('btn_active', 'Active orbital'),
('btn_inactive', 'Useless orbital')])
class OrbitalTable(QTableWidget):
status = []
def __init__(self, *args):
QTableWidget.__init__(self, *args)
self.setHorizontalHeaderLabels(['Energy', 'Occu', 'Orbital'])
class GeometryHighlightItem(QgsMapCanvasItem):
# Code ported from QGIS QgsHighlight
def __init__(self, mapCanvas, geometry, layer):
super(GeometryHighlightItem, self).__init__(mapCanvas)
self._mapCanvas = None # QgsMapCanvas
self._geometry = None # QgsGeometry()
self._brush = QBrush()
self._pen = QPen()
self._mapCanvas = mapCanvas
if not geometry or not isinstance(geometry, QgsGeometry) or geometry.isEmpty() or not geometry.isGeosValid():
return
self._geometry = QgsGeometry(geometry) # Force deep copy
self.setLineColor(Application.highlightLineColor())
self.setFillColor(Application.highlightFillColor())
if (layer and self._mapCanvas.mapSettings().hasCrsTransformEnabled()):
ct = self._mapCanvas.mapSettings().layerTransform(layer)
if ct:
self._geometry.transform(ct)
self.updateRect()
self.update()
def remove(self):
self._mapCanvas.scene().removeItem(self)
def setLineWidth(self, width):
self._pen.setWidth(width)
def setLineColor(self, color):
lineColor = QColor(color)
lineColor.setAlpha(255)
self._pen.setColor(lineColor)
def setFillColor(self, fillColor):
self._brush.setColor(fillColor)
self._brush.setStyle(Qt.SolidPattern)
def updatePosition(self):
pass
# protected:
def paint(self, painter, option=None, widget=None): # Override
if not self._geometry:
return
painter.setPen(self._pen)
painter.setBrush(self._brush)
wkbType = self._geometry.wkbType()
if wkbType == QGis.WKBPoint or wkbType == QGis.WKBPoint25D:
self._paintPoint(painter, self._geometry.geometry())
elif wkbType == QGis.WKBMultiPoint or wkbType == QGis.WKBMultiPoint25D:
for point in self._geometry.geometry():
self._paintPoint(painter, point)
elif wkbType == QGis.WKBLineString or wkbType == QGis.WKBLineString25D:
self._paintLine(painter, self._geometry.geometry())
elif wkbType == QGis.WKBMultiLineString or wkbType == QGis.WKBMultiLineString25D:
for line in self._geometry.geometry():
self._paintLine(painter, line)
elif wkbType == QGis.WKBPolygon or wkbType == QGis.WKBPolygon25D:
self._paintPolygon(painter, self._geometry.geometry())
elif wkbType == QGis.WKBMultiPolygon or wkbType == QGis.WKBMultiPolygon25D:
for polygon in self._geometry.geometry():
self._paintPolygon(painter, polygon)
def updateRect(self):
if self._geometry:
r = self._geometry.boundingBox()
if r.isEmpty():
d = self._mapCanvas.extent().width() * 0.005
r.setXMinimum(r.xMinimum() - d)
r.setYMinimum(r.yMinimum() - d)
r.setXMaximum(r.xMaximum() + d)
r.setYMaximum(r.yMaximum() + d)
self.setRect(r)
self.setVisible(True)
else:
self.setRect(QgsRectangle())
# private:
def _paintPoint(self, painter, point):
painter.drawEllipse(self.toCanvasCoordinates(point) - self.pos(), 2, 2)
def _paintLine(self, painter, line):
polyline = QPolygonF()
for point in line:
polyline.append(self.toCanvasCoordinates(point) - self.pos())
painter.drawPolyline(polyline)
def _paintPolygon(self, painter, polygon):
path = QPainterPath()
for line in polygon:
ring = QPolygonF()
for point in line:
cur = self.toCanvasCoordinates(point) - self.pos()
ring.append(cur)
ring.append(ring[0])
path.addPolygon(ring)
painter.drawPath(path)
def __init__(self):
super(NodeViewScene, self).__init__()
backgroundBrush = QBrush(QColor(0, 0, 0, 20))
backgroundBrush.setStyle(QtCore.Qt.CrossPattern)
self.setBackgroundBrush(backgroundBrush)
class FeatureHighlightItem(QgsMapCanvasItem):
# Code ported from QGIS QgsHighlight
def __init__(self, mapCanvas, feature, layer):
super(FeatureHighlightItem, self).__init__(mapCanvas)
self._mapCanvas = None # QgsMapCanvas
self._brush = QBrush()
self._pen = QPen()
self._feature = None # QgsFeature()
self._layer = None # QgsMapLayer()
self._buffer = 0.0
self._minWidth = 0.0
self._mapCanvas = mapCanvas
if (not layer
or not feature
or not isinstance(feature, QgsFeature)
or not feature.geometry()
or feature.geometry().isEmpty()
or not feature.geometry().isGeosValid()):
return
self._feature = QgsFeature(feature) # Force deep copy
self._layer = layer
self.setLineColor(Application.highlightLineColor())
self.setFillColor(Application.highlightFillColor())
self._minWidth = Application.highlightMinimumWidth()
self._buffer = Application.highlightBuffer()
if self._mapCanvas.mapSettings().hasCrsTransformEnabled():
ct = self._mapCanvas.mapSettings().layerTransform(self._layer)
if ct:
self._feature.geometry().transform(ct)
self.updateRect()
self.update()
def remove(self):
self._mapCanvas.scene().removeItem(self)
def setLineWidth(self, width):
self._pen.setWidth(width)
def setLineColor(self, color):
self._pen.setColor(color)
def setFillColor(self, fillColor):
self._brush.setColor(fillColor)
self._brush.setStyle(Qt.SolidPattern)
def setBuffer(self, buff):
self._buffer = buff
def setMinWidth(self, width):
self._minWidth = width
def layer(self):
return self._layer
def updatePosition(self):
pass
# protected:
def paint(self, painter, option=None, widget=None): # Override
if not self._feature:
return
mapSettings = self._mapCanvas.mapSettings()
context = QgsRenderContext.fromMapSettings(mapSettings)
renderer = self._getRenderer(context, self._pen.color(), self._brush.color())
if renderer:
context.setPainter(painter)
renderer.startRender(context, self._layer.fields())
renderer.renderFeature(self._feature, context)
renderer.stopRender(context)
def updateRect(self):
if self._feature and self._feature.constGeometry():
m2p = self._mapCanvas.mapSettings().mapToPixel()
topLeft = m2p.toMapPoint(0, 0)
res = m2p.mapUnitsPerPixel()
imageSize = self._mapCanvas.mapSettings().outputSize()
rect = QgsRectangle(topLeft.x(), topLeft.y(), topLeft.x() + imageSize.width()
* res, topLeft.y() - imageSize.height() * res)
self.setRect(rect)
self.setVisible(True)
else:
self.setRect(QgsRectangle())
# private:
def _setSymbol(self, symbol, context, color, fillColor):
if not symbol:
return
for symbolLayer in reversed(symbol.symbolLayers()):
if symbolLayer:
if symbolLayer.subSymbol():
self._setSymbol(symbolLayer.subSymbol(), context, color, fillColor)
else:
symbolLayer.setColor(color)
symbolLayer.setOutlineColor(color)
symbolLayer.setFillColor(fillColor)
if isinstance(symbolLayer, QgsSimpleMarkerSymbolLayerV2):
symbolLayer.setOutlineWidth(
self._getSymbolWidth(context, symbolLayer.outlineWidth(), symbolLayer.outlineWidthUnit()))
if symbolLayer.type() == QgsSymbolV2.Line:
symbolLayer.setWidth(
self._getSymbolWidth(context, symbolLayer.width(), symbolLayer.widthUnit()))
if symbolLayer.type() == QgsSymbolV2.Fill:
symbolLayer.setBorderWidth(
self._getSymbolWidth(context, symbolLayer.borderWidth(), symbolLayer.outputUnit()))
symbolLayer.removeDataDefinedProperty('color')
symbolLayer.removeDataDefinedProperty('color_border')
def _getSymbolWidth(self, context, width, unit):
scale = 1.0
if unit == QgsSymbolV2.MapUnit:
scale = QgsSymbolLayerV2Utils.lineWidthScaleFactor(
context, QgsSymbolV2.MM) / QgsSymbolLayerV2Utils.lineWidthScaleFactor(context, QgsSymbolV2.MapUnit)
width = max(width + 2 * self._buffer * scale, self._minWidth * scale)
return width
def _getRenderer(self, context, color, fillColor):
renderer = None
if self._layer and self._layer.rendererV2():
renderer = self._layer.rendererV2().clone()
if renderer:
for symbol in renderer.symbols2(context):
self._setSymbol(symbol, context, color, fillColor)
return renderer
def setupUi(self, showprogress):
showprogress.setObjectName("showprogress")
showprogress.resize(335, 310)
self.verticalLayout = QVBoxLayout(showprogress)
self.verticalLayout.setObjectName("verticalLayout")
self.barProgress = QProgressBar(showprogress)
self.barProgress.setProperty("value", QVariant(0))
self.barProgress.setObjectName("barProgress")
self.verticalLayout.addWidget(self.barProgress)
self.infoText = QTextEdit(showprogress)
palette = QPalette()
brush = QBrush(QColor(255, 255, 255))
brush.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Active, QPalette.Text, brush)
brush = QBrush(QColor(0, 0, 0))
brush.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Active, QPalette.Base, brush)
brush = QBrush(QColor(255, 255, 255))
brush.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Inactive, QPalette.Text, brush)
brush = QBrush(QColor(0, 0, 0))
brush.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Inactive, QPalette.Base, brush)
brush = QBrush(QColor(126, 125, 124))
brush.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Disabled, QPalette.Text, brush)
brush = QBrush(QColor(255, 255, 255))
brush.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Disabled, QPalette.Base, brush)
self.infoText.setPalette(palette)
self.infoText.setObjectName("infoText")
self.verticalLayout.addWidget(self.infoText)
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
spacerItem = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem)
self.fermer = QPushButton(showprogress)
self.fermer.setObjectName("fermer")
self.horizontalLayout.addWidget(self.fermer)
self.verticalLayout.addLayout(self.horizontalLayout)
self.retranslateUi(showprogress)
QMetaObject.connectSlotsByName(showprogress)
def setupUi(self):
self.setObjectName("SCJ")
self.setFixedSize(600,260)
#self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setObjectName("verticalLayout")
#self.infoText = QTextEdit(self)
self.infoText = QLabel(self)
palette = QPalette()
brush = QBrush(QColor(245, 245, 245))
brush.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Normal, QPalette.Background, brush)
self.infoText.setPalette(palette)
self.infoText.setAutoFillBackground(True)
self.infoText.setFixedHeight(200)
self.infoText.setObjectName("infoText")
#self.infoText.setReadOnly(True)
self.infoText.setWordWrap(True)
self.verticalLayout.addWidget(self.infoText)
# Manage Actions buttons
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
spacerItem = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem)
## Format de sortie
self.outlabel = QLabel(self.trUtf8("Choix du format de destination"))
self.horizontalLayout.addWidget(self.outlabel)
self.output = QComboBox()
self.output.addItems(self.modes)
self.output.setCurrentIndex(self.output.findText(self.mode))
self.horizontalLayout.addWidget(self.output)
# Buttons
self.fermer = QPushButton(self)
self.fermer.setObjectName("fermer")
self.horizontalLayout.addWidget(self.fermer)
self.convertDir = QPushButton(self)
self.convertDir.setObjectName("convertDir")
self.horizontalLayout.addWidget(self.convertDir)
self.convertFile = QPushButton(self)
self.convertFile.setObjectName("convertFile")
self.horizontalLayout.addWidget(self.convertFile)
self.verticalLayout.addLayout(self.horizontalLayout)
# Layout for allButtons
self.allLayout = QHBoxLayout()
# Add startAll bouton
self.startallbtn = QPushButton(self)
self.allLayout.addWidget(self.startallbtn)
self.startallbtn.hide()
self.verticalLayout.addLayout(self.allLayout)
# Add delAll bouton
self.delallbtn = QPushButton(self)
self.allLayout.addWidget(self.delallbtn)
self.delallbtn.hide()
# Mode avec scroll
self.frame = QFrame()
self.frame.setMinimumSize(520,250)
self.frame.setMaximumWidth(520)
self.scroll = QScrollArea()
self.scroll.setMinimumHeight(180)
self.jobsLayout = QVBoxLayout(self.frame)
self.jobsLayout.setSizeConstraint(QLayout.SetMinAndMaxSize)
#self.jobsLayout.setSizeConstraint(QLayout.SetMinimumSize)
#self.jobsLayout.setSizeConstraint(QLayout.SetMaximumSize)
self.scroll.setWidget(self.frame)
self.scroll.setWidgetResizable(False)
self.verticalLayout.addWidget(self.scroll)
self.scroll.hide()
# Mode sans scroll
#self.jobsLayout = QVBoxLayout()
#self.verticalLayout.addLayout(self.jobsLayout)
# Add a strech to the bottom of the window
self.verticalLayout.insertStretch(-1)
class masarUI(QMainWindow, ui_masar.Ui_masar):
severityDict= {0: 'NO_ALARM',
1: 'MINOR_ALARM',
2: 'MAJOR_ALARM',
3: 'INVALID_ALARM',
4: 'ALARM_NSEV'
}
alarmDict = { 0: 'NO_ALARM',
1: 'READ_ALARM',
2: 'WRITE_ALARM',
3: 'HIHI_ALARM',
4: 'HIGH_ALARM',
5: 'LOLO_ALARM',
6: 'LOW_ALARM',
7: 'STATE_ALARM',
8: 'COS_ALARM',
9: 'COMM_ALARM',
10: 'TIMEOUT_ALARM',
11: 'HW_LIMIT_ALARM',
12: 'CALC_ALARM',
13: 'SCAN_ALARM',
14: 'LINK_ALARM',
15: 'SOFT_ALARM',
16: 'BAD_SUB_ALARM',
17: 'UDF_ALARM',
18: 'DISABLE_ALARM',
19: 'SIMM_ALARM',
20: 'READ_ACCESS_ALARM',
21: 'WRITE_ACCESS_ALARM',
22: 'ALARM_NSTATUS'
}
def __init__(self, channelname='masarService', parent=None):
super(masarUI, self).__init__(parent)
self.setupUi(self)
self.__setDateTime()
self.tabWindowDict = {'comment': self.commentTab}
self.e2cDict = {} # event to config dictionary
self.pv4cDict = {} # pv name list for each selected configuration
self.data4eid = {}
self.arrayData = {} # store all array data
self.__service = 'masar'
self.mc = masarClient.client(channelname)
self.__initSystemBomboBox()
self.currentConfigFilter = str(self.configFilterLineEdit.text())
self.eventConfigFilter = str(self.eventFilterLineEdit.text())
self.authorText = str(self.authorTextEdit.text())
self.UTC_OFFSET_TIMEDELTA = datetime.datetime.utcnow() - datetime.datetime.now()
self.time_format = "%Y-%m-%d %H:%M:%S"
self.previewId = None
self.previewConfName = None
self.isPreviewSaved = True
# set bad pv row to grey
self.brushbadpv = QBrush(QColor(128, 128, 128))
self.brushbadpv.setStyle(Qt.SolidPattern)
# DBR_TYPE definition
#define DBF_STRING 0
#define DBF_INT 1
#define DBF_SHORT 1
#define DBF_FLOAT 2
#define DBF_ENUM 3
#define DBF_CHAR 4
#define DBF_LONG 5
#define DBF_DOUBLE 6
self.epicsLong = [1, 4, 5]
self.epicsString = [0, 3]
self.epicsDouble = [2, 6]
self.epicsNoAccess = [7]
def __initSystemBomboBox(self):
self.systemCombox.addItem(_fromUtf8(""))
self.systemCombox.setItemText(0, "all")
results = self.getSystemList()
if results:
for i in range(len(results)):
self.systemCombox.addItem(_fromUtf8(""))
self.systemCombox.setItemText(i+1, results[i])
self.system = str(self.systemCombox.currentText())
def __setDateTime(self):
self.eventStartDateTime.setDateTime(QDateTime.currentDateTime())
self.eventEndDateTime.setDateTime(QDateTime.currentDateTime())
def systemComboxChanged(self, qstring):
self.system = str(qstring)
def configFilterChanged(self):
self.currentConfigFilter = str(self.configFilterLineEdit.text())
def eventFilterChanged(self):
self.eventConfigFilter = str(self.eventFilterLineEdit.text())
def fetchConfigAction(self):
self.setConfigTable()
self.configTableWidget.resizeColumnsToContents()
def authorTextChanged(self):
self.authorText = str(self.authorTextEdit.text())
def __getComment(self):
cdlg = commentdlg.CommentDlg()
cdlg.exec_()
if cdlg.isAccepted:
return (cdlg.result())
else:
return None
def saveMachinePreviewAction(self):
if self.isPreviewSaved:
QMessageBox.warning(self,
"Warning",
"Preview (id: %s) for config (%s) has been save already." %(self.previewId, self.previewConfName))
return
elif self.previewId == None or self.previewConfName == None:
QMessageBox.warning(self,
"Warning",
"No preview to save.")
reply = QMessageBox.question(self, 'Message',
"Do you want to flag this preview as a good snapshot?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
comment = self.__getComment()
else:
return
# comment result always returns a tuple
# it return like (user, comment note)
if comment and isinstance(comment, tuple):
if comment[0] and comment[1]:
self.saveMachinePreviewData(self.previewId, self.previewConfName, comment)
else:
QMessageBox.warning(self,
"Warning",
"Either user name or comment is empty.")
return
else:
QMessageBox.warning(self,
"Warning",
"Comment is cancelled.")
return
self.isPreviewSaved = True
def getMachinePreviewAction(self):
selectedConfig = self.configTableWidget.selectionModel().selectedRows()
lc = len(selectedConfig)
if lc != 1:
QMessageBox.warning(self,
"Warning",
"Please select one configuration, and one only.")
return
self.previewId = None
self.previewConfName = None
cname = str(self.configTableWidget.item(selectedConfig[0].row(), 0).text())
result = self.getMachinePreviewData(cname)
if result:
eid = result[0]
data = result[1]
self.pv4cDict[str(eid)] = data['PV Name']
self.data4eid[str(eid)] = data
try:
tabWidget = self.tabWindowDict['preview']
index = self.snapshotTabWidget.indexOf(tabWidget)
except:
tabWidget = QTableWidget()
index = self.snapshotTabWidget.count()
self.tabWindowDict['preview'] = tabWidget
QObject.connect(tabWidget, SIGNAL(_fromUtf8("cellDoubleClicked (int,int)")), self.__showArrayData)
self.setSnapshotTable(data, tabWidget, eid)
tabWidget.resizeColumnsToContents()
label = QString.fromUtf8((cname+': Preview'))
self.snapshotTabWidget.addTab(tabWidget, label)
self.snapshotTabWidget.setTabText(index, label)
self.snapshotTabWidget.setCurrentIndex(index)
self.previewId = eid
self.previewConfName = cname
self.isPreviewSaved = False
def __find_key(self, dic, val):
"""return the key of dictionary dic given the value"""
return [k for k, v in dic.iteritems() if v == val][0]
def restoreSnapshotAction(self):
curWidget = self.snapshotTabWidget.currentWidget()
if not isinstance(curWidget, QTableWidget):
QMessageBox.warning(self, 'Warning', 'No snapshot is selected yet.')
return
eid = self.__find_key(self.tabWindowDict, curWidget)
if eid == 'comment' or eid == 'preview':
QMessageBox.warning(self, 'Warning', 'No restore, preview is selected.')
return
selectedNoRestorePv = {}
# get table rows
rowCount = curWidget.rowCount()
#Qt.Unchecked 0 The item is unchecked.
#Qt.PartiallyChecked 1 The item is partially checked.
# Items in hierarchical models may be partially checked if some,
# but not all, of their children are checked.
#Qt.Checked 2 The item is checked.
for row in range(rowCount):
selectedNoRestorePv[str(curWidget.item(row, 0).text())] = bool(curWidget.item(row, 8).checkState())
pvlist = list(self.pv4cDict[str(eid)])
data = self.data4eid[str(eid)]
s_val = data['S_value']
d_val = data['D_value']
i_val = data['I_value']
dbrtype = data['DBR']
is_array = data['isArray']
# is_connected = data['isConnected']
# data['PV Name']
array_value = data['arrayValue']
r_pvlist = [] # restore all pv value in this list
r_data = [] # value to be restored.
no_restorepvs = [] # no restore from those pvs
ignoreall = False # Ignore all pv those do not have any value.
for index in range(len(pvlist)):
try:
# pv is unchecked, which means restore this pv
if not selectedNoRestorePv[pvlist[index]]:
r_pvlist.append(pvlist[index])
if is_array[index]:
r_data.append(array_value[index])
elif dbrtype[index] in self.epicsDouble:
r_data.append(d_val[index])
elif dbrtype[index] in self.epicsLong:
r_data.append(i_val[index])
elif dbrtype[index] in self.epicsString:
r_data.append(s_val[index])
elif dbrtype[index] in self.epicsNoAccess:
if not ignoreall:
reply = QMessageBox.warning(self, 'Warning', 'Cannot restore pv: %s\nValue is invalid. \nDo you want to ignore it and continue?'%(pvlist[index]),
QMessageBox.Yes | QMessageBox.YesToAll | QMessageBox.Cancel, QMessageBox.Cancel)
if reply == QMessageBox.Yes:
no_restorepvs.append(pvlist[index])
elif reply == QMessageBox.YesToAll:
no_restorepvs.append(pvlist[index])
ignoreall = True
elif reply == QMessageBox.Cancel:
return
else:
no_restorepvs.append(pvlist[index])
else:
no_restorepvs.append(pvlist[index])
except:
print (type(pvlist[index]), pvlist[index])
QMessageBox.warning(self, 'Warning', 'PV name (%s) is invalid.'%(pvlist[index]))
return
if len(no_restorepvs) == rowCount:
QMessageBox.warning(self, 'Warning', 'All pvs are checked, and not restoring.')
return
#cagetres = cav3.caget(r_pvlist, throw=False)
#problempvlist=[]
#for rtmp in cagetres:
# if not rtmp.ok:
# problempvlist.append(rtmp)
#ignoreallconnection = False
#forceall = False
#if len(problempvlist) > 0:
# for problempv in problempvlist:
# if not ignoreall and not forceall:
# reply = QMessageBox.warning(self, 'Warning', 'There are a problem to connect pv %s. \nDo you want to ignore it and continue?'%(problempv),
# QMessageBox.Yes | QMessageBox.YesToAll | QMessageBox.No | QMessageBox.NoToAll | QMessageBox.Cancel, QMessageBox.Cancel)
# if reply == QMessageBox.Yes:
# # ignore this pv only
# no_restorepvs.append(problempv.name)
# elif reply == QMessageBox.No:
# # not ignore this pv
# pass
# elif reply == QMessageBox.YesToAll:
# # ignore all pvs that there might have potential connection problem
# # this does not overwrite all previous decisions
# no_restorepvs.append(problempv.name)
# ignoreallconnection = True
# elif reply == QMessageBox.NoToAll:
# # force restore pvs althouth there might have potential connection problem
# # this does not overwrites all previous decisions
# forceall = True
# elif reply == QMessageBox.Cancel:
# # cancel this operation
# return
# elif ignoreallconnection:
# no_restorepvs.append(problempv.name)
#if ignoreall or ignoreallconnection:
if ignoreall:
str_no_restore = "\n"
for no_restorepv in no_restorepvs:
str_no_restore += ' - %s' %no_restorepv + '\n'
print("No restore for the following pvs:\n"+str_no_restore+"\n========list end (not to restore pv)========")
elif len(no_restorepvs) > 0:
str_no_restore = "\n"
for no_restorepv in no_restorepvs:
str_no_restore += ' - %s' %no_restorepv + '\n'
reply = QMessageBox.question(self, 'Message',
"Partial pv will not be restored. Do you want to continue?\n(Please check terminal for a full list.)",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.No:
return
print("No restore for the following pvs:\n"+str_no_restore+"\n========list end (not to restore pv)========")
bad_pvs = []
try:
final_restorepv = []
final_restorepvval = []
for i in range(len(r_pvlist)):
if r_pvlist[i] not in no_restorepvs:
final_restorepv.append(r_pvlist[i])
final_restorepvval.append(r_data[i])
if len(final_restorepv) > 0:
results = cav3.caput(final_restorepv, final_restorepvval, wait=True, throw=False)
for i in range(len(results)):
res = results[i]
if not res.ok:
# try 3 times again to set value to each pv
# first try wait 1 second, second try wait 2 seconds, and last try wait 3 seconds.
for j in range(1, 4):
ressub = cav3.caput(final_restorepv[i], final_restorepvval[i], wait=True, throw=False, timeout=j)
if ressub.ok:
break
if not ressub.ok:
# record as a bad pv if it still fails
bad_pvs.append(res)
except:
QMessageBox.warning(self, 'Warning', 'Error during restoring snapshot to live machine.')
return
if len(bad_pvs) > 0:
message = "Failed to restore some pvs. PLease check the terminal for a full list."
QMessageBox.warning(self, 'Warning', message)
output = ""
for bad_pv in bad_pvs:
output += "\n "+bad_pv.name + ": "+cav3.cadef.ca_message(bad_pv.errorcode)
print ("Failed to restore the following pvs which is caused by:"+output+"\n========list end (failed to restore pv)========")
else:
QMessageBox.information(self, "Success", "Successfully restore machine with selected snapshot.")
def __arrayTextFormat(self, arrayvalue):
"""
display max 8 characters in a table cell
"""
array_text = str(arrayvalue)
if len(str(array_text)) > 8:
array_text = str(array_text)[:8]+' ..., ...)'
return array_text
def getLiveMachineAction(self):
curWidget = self.snapshotTabWidget.currentWidget()
if isinstance(curWidget, QTableWidget):
# get event id
eid = self.__find_key(self.tabWindowDict, curWidget)
# 2 special case:
if eid == 'preview':
eid = self.previewId # get event id for preview snapshot
elif eid == 'comment':
return # nothing should do here
pvlist = self.pv4cDict[str(eid)]
data = self.getLiveMachineData(pvlist)
if data:
channelName = data[0]
s_value = data[1]
d_value = data[2]
i_value = data[3]
dbrtype = data[4]
# isConnected = data[5]
is_array = data[6]
array_value = data[7]
dd = {}
noMatchedPv = []
# put channel name and its order into a dictionary
for i in range(len(channelName)):
dd[str(channelName[i])] = i
# get table rows
rowCount = curWidget.rowCount()
for i in range(rowCount):
try:
index = dd[str(curWidget.item(i, 0).text())]
if is_array[index]:
self.__setTableItem(curWidget, i, 6, self.__arrayTextFormat(array_value[index]))
self.arrayData[channelName[index]+"_"+str(eid)+'_live'] = array_value[index]
else:
if dbrtype[index] in self.epicsDouble:
self.__setTableItem(curWidget, i, 6, str(d_value[index]))
try:
saved_val = float(str(curWidget.item(i, 5).text()))
if d_value[index] != None:
delta = d_value[index] - saved_val
if abs(delta) < 1.0e-6:
delta = 0
else:
delta = None
except:
delta='N/A'
self.__setTableItem(curWidget, i, 7, str(delta))
elif dbrtype[index] in self.epicsLong:
self.__setTableItem(curWidget, i, 6, str(i_value[index]))
if dbrtype[index] in self.epicsNoAccess:
pass
else:
try:
saved_val = int(float(str(curWidget.item(i, 5).text())))
if i_value[index] != None:
delta = i_value[index] - saved_val
else:
delta = None
except:
delta='N/A'
self.__setTableItem(curWidget, i, 7, str(delta))
elif dbrtype[index] in self.epicsString:
self.__setTableItem(curWidget, i, 6, str(s_value[index]))
except:
noMatchedPv.append(str(curWidget.item(i, 0).text()))
if len(noMatchedPv) > 0:
print ("Can not find the following pv for this snapshot: \n", noMatchedPv)
else:
QMessageBox.warning(self, "Warning", "Not a snapshot.")
return
def useTimeRange(self, state):
if state == Qt.Checked:
self.eventStartDateTime.setEnabled(True)
self.eventEndDateTime.setEnabled(True)
else:
self.eventStartDateTime.setEnabled(False)
self.eventEndDateTime.setEnabled(False)
def fetchEventAction(self):
selectedConfigs = self.configTableWidget.selectionModel().selectedRows()
configIds=[]
configNames = []
for idx in selectedConfigs:
configIds.append(str(self.configTableWidget.item(idx.row(), 4).text()))
configNames.append(str(self.configTableWidget.item(idx.row(), 0).text()))
data = self.retrieveEventData(configids=configIds, confignames=configNames)
if data:
self.setEventTable(data)
self.eventTableWidget.resizeColumnsToContents()
def retrieveSnapshot(self):
selectedItems = self.eventTableWidget.selectionModel().selectedRows()
if len(selectedItems) <= 0:
QMessageBox.warning(self,
"Warning",
"Please select at least one event.")
return
eventTs=[]
eventNames=[]
eventIds = []
for idx in selectedItems:
eventNames.append(str(self.eventTableWidget.item(idx.row(), 0).text()))
eventTs.append(str(self.eventTableWidget.item(idx.row(), 3).text()))
eventIds.append(str(self.eventTableWidget.item(idx.row(), 4).text()))
self.snapshotTabWidget.setStatusTip("Snapshot data")
self.setSnapshotTabWindow(eventNames, eventTs, eventIds)
def setConfigTable(self):
data = self.retrieveConfigData()
if data:
self.setTable(data, self.configTableWidget)
def setSnapshotTabWindow(self, eventNames, eventTs, eventIds):
tabWidget = None
isNew = True
for i in range(len(eventIds)):
if self.tabWindowDict.has_key(eventIds[i]):
tabWidget = self.tabWindowDict[eventIds[i]]
else:
tabWidget = QTableWidget()
self.tabWindowDict[eventIds[i]] = tabWidget
QObject.connect(tabWidget, SIGNAL(_fromUtf8("cellDoubleClicked (int,int)")), self.__showArrayData)
data = self.retrieveMasarData(eventid=eventIds[i])
if data:
if isNew:
for j in range(self.snapshotTabWidget.count(), 0, -1):
self.snapshotTabWidget.removeTab(j)
self.pv4cDict.clear()
self.data4eid.clear()
self.arrayData.clear()
isNew = False
tabWidget.clear()
self.setSnapshotTable(data, tabWidget, eventIds[i])
tabWidget.resizeColumnsToContents()
ts = eventTs[i].split('.')[0]
label = QString.fromUtf8((eventNames[i]+': ' + ts))
self.snapshotTabWidget.addTab(tabWidget, label)
self.snapshotTabWidget.setTabText(i+1, label)
self.pv4cDict[str(eventIds[i])] = data['PV Name']
self.data4eid[str(eventIds[i])] = data
self.snapshotTabWidget.setCurrentIndex(1)
def __showArrayData(self, row, column):
if column != 5 and column != 6: # display the array value only
return
curWidget = self.snapshotTabWidget.currentWidget()
if not isinstance(curWidget, QTableWidget):
QMessageBox.warning(self, 'Warning', 'No snapshot is selected yet.')
return
eid = self.__find_key(self.tabWindowDict, curWidget)
if eid == 'comment':
QMessageBox.warning(self, 'Warning', 'It is comment panel.')
if eid == 'preview':
eid = self.previewId
pvname = str(curWidget.item(row, 0).text())
try:
arraySaved = self.arrayData[pvname+'_'+str(eid)]
except:
QMessageBox.warning(self, 'Warning', 'No array data found for this pv.')
return
if eid != 'preview':
try:
arrayLive = self.arrayData[pvname+"_"+str(eid)+'_live']
arrardlg = ShowArrayValueDlg(pvname, arraySaved, arrayLive)
except:
arrardlg = ShowArrayValueDlg(pvname, arraySaved)
else:
arrardlg = ShowArrayValueDlg(pvname, arraySaved)
arrardlg.exec_()
def setEventTable(self, data):
self.setTable(data, self.eventTableWidget)
def __setTableItem(self, table, row, col, text):
item = table.item(row, col)
if item:
item.setText(text)
else:
newitem = QTableWidgetItem(text)
newitem.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)
table.setItem(row, col, newitem)
def setSnapshotTable(self, data, table, eventid):
if data:
length = len(data.values()[0])
else:
print ('data is empty, exit.')
return
for i in range(1, len(data.values())):
if length != len(data.values()[i]):
QMessageBox.warning(self,
"Warning",
"Data length are not consistent.")
return
if isinstance(data, odict) and isinstance(table, QTableWidget):
table.setSortingEnabled(False)
table.clear()
nrows = len(data.values()[0])
# ('pv name label', 'dbr_type label', 'string value', 'int value', 'double value', 'status label', 'severity label',
# 'ioc time stamp label', 'ioc time stamp nano label', 'is_array', 'array_value'),
# => (pv_name, status, severity, ioc_timestamp, saved value)
# ncols = len(data) - 6
# ncols = ncols + 3 # 2 columns for live data and (live data - saved data), selected restore pv
ncols = len(data) - 3
table.setRowCount(nrows)
table.setColumnCount(ncols)
pvnames = data['PV Name']
status = data['Status']
severity = data['Severity']
ts = data['Time stamp']
ts_nano = data['Time stamp (nano)']
dbrtype = data['DBR']
s_value = data['S_value']
i_value = data['I_value']
d_value = data['D_value']
isConnected = data['isConnected']
is_array = data['isArray']
array_value = data['arrayValue']
keys = ['Name', 'Status', 'Severity', 'Time Stamp', 'Connection', 'Saved Value', 'Live Value', 'Delta', 'Not Restore']
table.setHorizontalHeaderLabels(keys)
for i in range(nrows):
item = table.item(i, 8)
if item:
item.setCheckState(False)
else:
item = QTableWidgetItem()
item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsUserCheckable)
table.setItem(i, 8, item)
item.setCheckState(False)
if pvnames[i]:
self.__setTableItem(table, i, 0, pvnames[i])
if status[i]:
self.__setTableItem(table, i, 1, str(status[i]))
if severity[i]:
self.__setTableItem(table, i, 2, str(severity[i]))
if ts[i]:
dt = str(datetime.datetime.fromtimestamp(ts[i]+ts_nano[i]*1.0e-9))
self.__setTableItem(table, i, 3, dt)
if is_array[i]:
self.__setTableItem(table, i, 5, self.__arrayTextFormat(array_value[i]))
self.arrayData[pvnames[i]+'_'+str(eventid)] = array_value[i]
else:
if dbrtype[i] in self.epicsDouble:
self.__setTableItem(table, i, 5, str(d_value[i]))
elif dbrtype[i] in self.epicsLong:
self.__setTableItem(table, i, 5, str(i_value[i]))
elif dbrtype[i] in self.epicsString:
self.__setTableItem(table, i, 5, str(s_value[i]))
elif dbrtype[i] in self.epicsNoAccess:
# channel are not connected.
pass
else:
print('invalid dbr type (code = %s)'%(dbrtype[i]))
if isConnected[i]:
self.__setTableItem(table, i, 4, str(bool(isConnected[i])))
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
else:
self.__setTableItem(table, i, 4, 'False')
item.setCheckState(True)
item.setSelected(True)
# disable user checkable function
item.setFlags(item.flags() ^ Qt.ItemIsUserCheckable)
for item_idx in range(9):
itemtmp = table.item(i, item_idx)
if not itemtmp:
itemtmp = QTableWidgetItem()
table.setItem(i, item_idx, itemtmp)
itemtmp.setBackground(self.brushbadpv)
table.setSortingEnabled(True)
else:
raise "Either given data is not an instance of OrderedDict or table is not an instance of QtGui.QTableWidget"
def setTable(self, data, table):
"""
Set data view.
The data has to be an ordered dictionary, and table is a QtGui.QTableWidget
Here is an example to construct an ordered dictionary.
"""
if data:
length = len(data.values()[0])
else:
print ('data is empty, exit.')
return
for i in range(1, len(data.values())):
if length != len(data.values()[i]):
QMessageBox.warning(self,
"Warning",
"Data length are not consistent.")
return
if isinstance(data, odict) and isinstance(table, QTableWidget):
nrows = len(data.values()[0])
ncols = len(data)
table.setRowCount(nrows)
table.setColumnCount(ncols)
# Removes all items in the view, and also all selections
table.clear()
table.setHorizontalHeaderLabels(data.keys())
n = 0
for key in data:
m = 0
for item in data[key]:
if not isinstance(item, basestring):
item = str(item)
if item:
newitem = QTableWidgetItem(item)
newitem.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)
table.setItem(m, n, newitem)
m += 1
n += 1
else:
raise "Either given data is not an instance of OrderedDict or table is not an instance of QtGui.QTableWidget"
def getSystemList(self):
try:
return self.mc.retrieveSystemList()
except:
QMessageBox.warning(self,
"Warning",
"Cannot connect to MASAR server.\nPlease check the serviceName, network connection, and service status.")
return
def retrieveConfigData(self):
data = odict()
params = {"system": self.system,
"servicename": self.__service,
"configname": self.currentConfigFilter}
try:
rpcResult = self.mc.retrieveServiceConfigs(params)
utctimes = rpcResult[3]
config_ts = []
for ut in utctimes:
ts = str(datetime.datetime.fromtimestamp(time.mktime(time.strptime(ut, self.time_format))) - self.UTC_OFFSET_TIMEDELTA)
config_ts.append(ts)
except:
QMessageBox.warning(self,
"Warning",
"Exception happened during retrieving configurations.")
return False
if not rpcResult:
return False
data['Name'] = rpcResult[1]
data['Description'] = rpcResult[2]
data['Date'] = config_ts
data['Version'] = rpcResult[4]
data['Id'] = rpcResult[0]
return data
def retrieveEventData(self,configids=None,confignames=None):
start = None
end = None
if self.timeRangeCheckBox.isChecked():
start = self.eventStartDateTime.dateTime().toPyDateTime() + self.UTC_OFFSET_TIMEDELTA
end = self.eventEndDateTime.dateTime().toPyDateTime() + self.UTC_OFFSET_TIMEDELTA
if start > end:
QMessageBox.warning(self,
"Warning",
"Please select a correct time range.")
return
event_ids = []
event_ts = []
event_desc = []
c_names = []
event_author = []
self.e2cDict.clear()
if configids:
for i in range(len(configids)):
cid = configids[i]
params = {'configid': cid,
"comment": self.eventConfigFilter,
"user": self.authorText}
if self.timeRangeCheckBox.isChecked():
params['start'] = str(start)
params['end'] = str(end)
try:
rpcResult = self.mc.retrieveServiceEvents(params)
except:
QMessageBox.warning(self,
"Warning",
"Except happened during retrieving events.")
return False
if not rpcResult:
return False
eids = rpcResult[0]
usertag = rpcResult[1]
utctimes = rpcResult[2]
author = rpcResult[3]
event_ids = event_ids[:] + (list(eids))[:]
event_desc = event_desc[:] + (list(usertag))[:]
event_author = event_author[:] + (list(author))[:]
for j in range(len(eids)):
self.e2cDict[str(eids[j])] = [cid, usertag[j],confignames[i]]
for ut in utctimes:
c_names.append(confignames[i])
ts = str(datetime.datetime.fromtimestamp(time.mktime(time.strptime(ut, self.time_format))) - self.UTC_OFFSET_TIMEDELTA)
event_ts.append(ts)
else:
return False
data = odict()
data['Config'] = c_names
data['Description'] = event_desc
data['Author'] = event_author
data['Time stamp'] = event_ts
data['Id'] = event_ids
return data
def retrieveMasarData(self, eventid=None):
data = odict()
params = {'eventid': eventid}
try:
rpcResult = self.mc.retrieveSnapshot(params)
except:
QMessageBox.warning(self,
"Warning",
"Except happened during retrieving snapshot data.")
return False
if not rpcResult:
return False
pvnames = rpcResult[0]
s_value = rpcResult[1]
d_value = rpcResult[2]
i_value = rpcResult[3]
dbrtype = rpcResult[4]
isConnected = rpcResult[5]
ts = rpcResult[6]
ts_nano = rpcResult[7]
severity = list(rpcResult[8])
status = list(rpcResult[9])
is_array = rpcResult[10]
raw_array_value = rpcResult[11]
array_value = []
for i in range(len(severity)):
try:
severity[i] = self.severityDict[severity[i]]
except:
severity[i] = 'N/A'
try:
status[i] = self.alarmDict[status[i]]
except:
status[i] = 'N/A'
if dbrtype[i] in self.epicsLong:
array_value.append(raw_array_value[i][2])
elif dbrtype[i] in self.epicsDouble:
array_value.append(raw_array_value[i][1])
elif dbrtype[i] in self.epicsString:
# string value
array_value.append(raw_array_value[i][0])
elif dbrtype[i] in self.epicsNoAccess:
# when the value is no_access, use the double value no matter what it is
array_value.append(raw_array_value[i][1])
data['PV Name'] = pvnames
data['Status'] = status
data['Severity'] = severity
data['Time stamp'] = ts
data['Time stamp (nano)'] = ts_nano
data['DBR'] = dbrtype
data['S_value'] = s_value
data['I_value'] = i_value
data['D_value'] = d_value
data['isConnected'] = isConnected
data['isArray'] = is_array
data['arrayValue'] = array_value
return data
def saveMachinePreviewData(self, eventid, confname, comment):
if not eventid:
QMessageBox.warning(self,
"Warning",
"Unknown event.")
return
params = {'eventid': str(eventid),
'configname': str(confname),
'user': str(comment[0]),
'desc': str(comment[1])}
try:
result = self.mc.updateSnapshotEvent(params)
except:
QMessageBox.warning(self,
"Warning",
"Except happened during update snapshot event.")
return False
if result:
QMessageBox.information(self,"Successful",
" Succeed to save preview")
else:
QMessageBox.information(self, "Failures",
"Failed to save preview.")
def getMachinePreviewData(self, configName):
params = {'configname': configName,
'servicename': 'masar'}
try:
rpcResult = self.mc.saveSnapshot(params)
except:
QMessageBox.warning(self,
"Warning",
"Except happened during getting machine preview.")
return False
if not rpcResult:
return False
eventid = rpcResult[0]
pvnames = rpcResult[1]
s_value = rpcResult[2]
d_value = rpcResult[3]
i_value = rpcResult[4]
dbrtype = rpcResult[5]
isConnected = rpcResult[6]
ts = rpcResult[7]
ts_nano = list(rpcResult[8])
severity = list(rpcResult[9])
status = list(rpcResult[10])
is_array = rpcResult[11]
raw_array_value = rpcResult[12]
array_value = []
for i in range(len(severity)):
try:
severity[i] = self.severityDict[severity[i]]
except:
severity[i] = 'N/A'
try:
status[i] = self.alarmDict[status[i]]
except:
status[i] = 'N/A'
if dbrtype[i] in self.epicsLong:
array_value.append(raw_array_value[i][2])
elif dbrtype[i] in self.epicsDouble:
array_value.append(raw_array_value[i][1])
elif dbrtype[i] in self.epicsString:
# string value
array_value.append(raw_array_value[i][0])
elif dbrtype[i] in self.epicsNoAccess:
# when the value is no_access, use the double value no matter what it is
array_value.append(raw_array_value[i][1])
data = odict()
data['PV Name'] = pvnames
data['Status'] = status
data['Severity'] = severity
data['Time stamp'] = ts
data['Time stamp (nano)'] = ts_nano
data['DBR'] = dbrtype
data['S_value'] = s_value
data['I_value'] = i_value
data['D_value'] = d_value
data['isConnected'] = isConnected
data['isArray'] = is_array
data['arrayValue'] = array_value
return (eventid, data)
def getLiveMachineData(self, pvlist):
params = {}
for pv in pvlist:
params[pv] = pv
# channelName,stringValue,doubleValue,longValue,dbrType,isConnected, is_array, array_value
array_value = []
try:
rpcResult = self.mc.getLiveMachine(params)
except:
QMessageBox.warning(self,
"Warning",
"Except happened during getting live machine.")
return False
if not rpcResult:
return False
channelName = rpcResult[0]
stringValue = rpcResult[1]
doubleValue = rpcResult[2]
longValue = rpcResult[3]
dbrtype = rpcResult[4]
isConnected = rpcResult[5]
is_array = rpcResult[6]
raw_array_value = rpcResult[7]
for i in range(len(is_array)):
if dbrtype[i] in self.epicsLong:
array_value.append(raw_array_value[i][2])
elif dbrtype[i] in self.epicsDouble:
array_value.append(raw_array_value[i][1])
elif dbrtype[i] in self.epicsString:
# string value
array_value.append(raw_array_value[i][0])
elif dbrtype[i] in self.epicsNoAccess:
# when the value is no_access, use the double value no matter what it is
array_value.append(raw_array_value[i][1])
return (channelName,stringValue,doubleValue,longValue,dbrtype,isConnected,is_array, array_value)
def saveDataFileAction(self):
"""
Save data into a CSV file.
"""
curWidget = self.snapshotTabWidget.currentWidget()
if not isinstance(curWidget, QTableWidget):
QMessageBox.warning(self, 'Warning', 'No snapshot is selected yet.')
return
eid = self.__find_key(self.tabWindowDict, curWidget)
# if eid == 'comment' or eid == 'preview':
# QMessageBox.warning(self, 'Warning', 'No restore, preview is selected.')
# return
data = self.data4eid[str(eid)]
pvnames = data['PV Name']
status = data['Status']
severity = data['Severity']
ts = data['Time stamp']
ts_nano = data['Time stamp (nano)']
dbrtype = data['DBR']
s_value = data['S_value']
i_value = data['I_value']
d_value = data['D_value']
isConnected = data['isConnected']
is_array = data['isArray']
array_value = data['arrayValue']
head = '# pv name, status, severity, time stamp, epics dbr, is connected, is array, value'
filename = QFileDialog.getSaveFileName(self, 'Save File', '.')
if not filename:
return
try:
fname = open(filename, 'w')
fname.write(head+'\n')
for i in range(len(pvnames)):
line = pvnames[i]
line += ','+str(status[i])
line += ','+str(severity[i])
line += ','+str(datetime.datetime.fromtimestamp(ts[i]+ts_nano[i]*1.0e-9))
line += ','+str(dbrtype[i])
line += ','+str(bool(isConnected[i]))
line += ','+str(bool(is_array[i]))
if is_array[i]:
line += ','+str(array_value[i])
else:
if dbrtype[i] in self.epicsDouble:
line += ','+str(d_value[i])
elif dbrtype[i] in self.epicsLong:
line += ','+str(i_value[i])
elif dbrtype[i] in self.epicsString:
line += ','+str(s_value[i])
else:
line += ''
fname.write(line+'\n')
fname.close()
except:
QMessageBox.warning(self,
"Warning",
"Cannot write to the file. Please check the writing permission.")
def mousePressEvent(self, event):
self._color = self.colordialog.getColor(self._color)
self._brush = QBrush(self._color)
class Dial(QGraphicsItem):
"""
Dial
"""
def __init__(self):
super(Dial, self).__init__()
self.angle = 0
# Colors
self.color = QColor(120, 120, 120, 255)
self.notchColor = QColor(115, 115, 115, 255)
self.normalBorderColor = QColor( 255, 255, 255, 30 )
self.selectedBorderColor = QColor( 255, 191, 0, 102 )
self.textColor = QColor( 30, 30, 30, 255 )
self.shadowColor = QColor(0, 0, 0, 75)
self.selectedShadowColor = QColor( 100, 100, 100, 255 )
# Settings
self.width, self.height = 75, 75
# Drop Shadow
self.shadowBlurRadius = 8
self.shadow = QGraphicsDropShadowEffect()
self.shadow.setBlurRadius(self.shadowBlurRadius)
self.shadow.setOffset(0, 0.5)
self.shadow.setColor(self.shadowColor)
self.setGraphicsEffect(self.shadow)
# Painter Definitions
self.pen = QPen()
gradient = QRadialGradient(self.boundingRect().center() + QPointF(0, -20), 80)
gradient.setColorAt(0, self.color.lighter(117))
gradient.setColorAt(1, self.color)
self.brush = QBrush(gradient)
self.font = QFont()
self.pen.setWidth(1)
self.pen.setColor(self.normalBorderColor)
self.brush.setColor(self.color)
self.font.setPointSize(10)
# Nodegraph Definitions
self.dragPoint = None
self.dragAngle = 0
self.dragFactor = 0
# Notch Specifications
self.notch = DialNotch()
self.notch.setParentItem(self)
self.updateNotch()
def boundingRect(self):
"""
Overrides QGraphicsItem's boundingRect() virtual public function and
returns a valid bounding rect based on calculated width and height.
"""
return QRectF(0, 0, self.width, self.height).adjusted(
-self.shadowBlurRadius, -self.shadowBlurRadius,
self.shadowBlurRadius, self.shadowBlurRadius)
def paint(self, painter, option, widget):
"""
Overrides QGraphicsItem's paint() virtual public function.
"""
painter.setPen(self.pen)
painter.setBrush(self.brush)
painter.drawEllipse(self.boundingRect())
def mousePressEvent(self, event):
self.dragPoint = event.scenePos()
self.dragAngle = self.angle
part = self.height / 2
distance = event.pos().y() - part
if distance == 0:
self.dragFactor = 0
else:
self.dragFactor = part / distance
def mouseMoveEvent(self, event):
scenePos = event.scenePos()
d = scenePos - self.dragPoint
self.angle = self.dragAngle + d.x() * self.dragFactor
self.updateNotch()
def mouseReleaseEvent(self, event):
self.dragPoint = None
self.dragAngle = 0
def updateNotch(self):
f = 0.02
dx = (self.width - self.notch.width) / 2
dy = (self.height - self.notch.height) / 2
x = math.sin(math.radians(self.angle)) * dx + dx
y = math.cos(math.radians(self.angle)) * dy + dy
self.notch.setPos(x, y)
sys.exit (1)
app= QApplication (sys.argv)
win= QMainWindow ()
scene= QGraphicsScene ()
item= QGraphicsPixmapItem ()
scene.addItem (item)
view= QGraphicsView (scene, win)
view.setFrameShadow (QFrame.Plain)
view.setFrameStyle (QFrame.NoFrame)
view.show()
brush = QBrush(QColor(0, 0, 0))
brush.setStyle(Qt.SolidPattern)
view.setBackgroundBrush(brush)
runner= OMIMMain (view, scene, item, sys.argv[1])
timer= QTimer (app)
timer.timeout.connect (runner.nextImage)
timer.start (float (sys.argv[2])*1000)
firstImage= QTimer.singleShot (200, runner.nextImage)
win.setCentralWidget (view)
win.showFullScreen ()
app.exec_ ()
def populateTree(self):
"""Populates tree view with information from ItemTracker."""
if len(self.errorIds):
self.mkError("{0} entries do not have valid "
"ItemTracker IDs in Bionumerics.".format(len(self.errorIds)))
for key, msg in self.errorIds.iteritems():
self.mkError("KEY: {0} {1}".format(key, msg))
if not len(self.selectedIds):
self.statusbar.showMessage("No items to process", 5000)
return
parents = {}
headers = ["Items", "Selected", "SelectedBy", "Viability", "Volume",
"DNA concentration", "UserName", "TubePresent", "InputDate",
"AlternID", "Status"]
self.treeWidget.setItemsExpandable(True)
self.treeWidget.setAlternatingRowColors(True)
self.treeWidget.setColumnCount(len(headers))
self.treeWidget.setHeaderLabels(headers)
msg = "Getting information from ItemTracker. Please wait..."
self.statusbar.showMessage(msg)
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(0)
self.progressBar.show()
(treeData, self.itemProperties,
message) = lims.GetDictionary((self.selectedIds.keys()))
if len(message):
for msg in message:
self.mkError("ItemTracker error: {0}".format(msg))
if not len(treeData):
self.mkError("Could not get data from ItemTracker for"
"selected entries")
self.statusBar().clearMessage()
self.progressBar.hide()
self.updateUi()
return
# bugfix: If ItemType property does not exist for the first item
# self.database is not set and tree view is not updated.
db = None
if not self.database:
for item in self.itemProperties.values():
try:
db = item["ItemType"]
except KeyError:
pass
if db == "Salmonella":
self.database = db
break
elif db == "Listeria":
self.database = db
break
self.progressBar.setMaximum(len(treeData))
count = 0
for key, value in treeData.iteritems():
count += 1
self.progressBar.setValue(count)
if not(value and isinstance(value, dict)):
self.mkWarn("No data returned for key {0}".format(key))
continue
items = {}
items[key] = value
for results in self.getData(items, key):
parent = parents.get(results[0])
if not parent:
parent_id = self.selectedIds[results[0]]
self.strainInfo[parent_id] = {self.database:[],
"Frozen Stock":[], "DNA":[]}
parent = QTreeWidgetItem(self.treeWidget,
[unicode(parent_id)])
brush = QBrush()
brush.setColor(Qt.blue)
parent.setForeground(0, brush)
parent.setIcon(0, QIcon(":/branch-closed.png"))
parent.setData(0, Qt.CheckStateRole, QVariant())
parents[results[0]] = parent
for children in results[1]:
itemName = self.itemProperties[children]["ItemName"]
if not self.itemIds.get(itemName):
self.itemIds[itemName] = children
childprops = []
childprops.append(unicode(itemName))
for header in headers[1:]:
try:
childprop = self.itemProperties[children][header]
if childprop is None or childprop == "":
childprops.append(unicode(""))
else:
childprops.append(unicode(childprop))
except KeyError:
childprops.append(unicode(""))
continue
childs = parents.get(children)
if not childs:
childs = QTreeWidgetItem(parent, childprops)
if self.itemProperties[children]["TubePresent"] == "-":
childs.setBackgroundColor(0, QColor(232, 87, 82))
childs.setForeground(0, QColor(255, 255, 255))
if self.itemProperties[children]["Selected"] == "yes":
childs.setBackgroundColor(0, QColor(119, 183, 83))
childs.setForeground(0, QColor(255, 255, 255))
itype = self.itemProperties[children]["ItemType"]
if itype:
self.strainInfo[parent_id][itype].append(itemName)
parents[children] = childs
childs.setCheckState(0, Qt.Unchecked)
self.treeWidget.expandAll()
for i in range(len(headers)):
self.treeWidget.resizeColumnToContents(i)
if not self.treeWidget.isEnabled():
self.treeWidget.setEnabled(True)
self.mkInfo("Processed <b>{0}</b> entries".format(len(treeData)))
self.progressBar.setValue(len(treeData))
self.progressBar.hide()
self.populatedTree = True
self.updateUi()
self.statusbar.showMessage("Ready", 5000)
def onSubmitClicked(self): self.wordsMatched = True self.allWordsMatched = True brushRed = QBrush(QColor(255,0,0)) brushRed.setStyle(Qt.SolidPattern) brushGreen = QBrush(QColor(0,255,0)) brushGreen.setStyle(Qt.SolidPattern) # validate whether the user all matched the blanks with a value #self.onNextSubmitValidation() textNotFilled = False for row in range(0, len(self.currentSentenceListInTable)): if self.sentenceToFillTable.item(row, 0).text() == self.currentSentenceListInTable[row]: textNotFilled = True if textNotFilled: QMessageBox.information(self, "Fill the sentences", "Match all the sentences in the table", QMessageBox.Ok) else: splittedSentence = [] foundWordInSentence = "" self.rightWordListCopy = self.rightWordList for row in range(0, len(self.currentSentenceListInTable)): sentenceFilled = str(self.sentenceToFillTable.item(row, 0).text()) newSplittedSentence = [word.strip() for word in sentenceFilled.split()] splittedSentence = [] for word in newSplittedSentence: match = re.search(r'\w+', word) if match: splittedSentence.append(str(match.group())) wordList = self.rightWordListCopy[row] if len(wordList) > 1: firstWord = wordList[0].strip() secondWord = wordList[1].strip() if ' ' in firstWord: for word in firstWord.split(): if word not in splittedSentence: self.wordsMatched = False else: if firstWord not in splittedSentence: self.wordsMatched = False if self.wordsMatched: ## check is valid only if the first word is matched if ' ' in secondWord: for word in secondWord.split(): if word not in splittedSentence: self.wordsMatched = False else: if secondWord not in splittedSentence: self.wordsMatched = False elif len(wordList) == 1: word = wordList[0].strip() if word not in splittedSentence: self.wordsMatched = False if self.wordsMatched: self.sentenceToFillTable.item(row, 0).setBackground(brushGreen) else: self.sentenceToFillTable.item(row, 0).setBackground(brushRed) self.allWordsMatched = False self.wordsMatched = True if self.allWordsMatched: self.nextButton.setEnabled(True) QMessageBox.information(self, "Fill the sentences", "All sentences are matched", QMessageBox.Ok)
