Python PyQt4.QtGui 模块，QBrush() 实例源码

def __init__(self, editor, token, count, qpos, parent=None):        
        '''Create a token.

        :param editor: DiagramEditor. Editor to show in. 
        :param token: Token value.
        :param count: Number of Tokens to create.
        :param qpos: Parent top right position.  
        :param parent=None: Parent Place Element
        '''
        QtGui.QGraphicsEllipseItem.__init__(self, qpos, parent)
        self.editor = editor
        self.setZValue(19)
        self.countToken = count
        self.countTokenLabel = QtGui.QGraphicsTextItem("%d"%self.countToken, self)
        self.countTokenLabel.setPos(QtCore.QPointF( qpos.x()-1, qpos.y()-4 ))
        self.setBrush(QtGui.QBrush(QtCore.Qt.green))
        self.token = token
        self.setToolTip( str(self.token) )
        self.setFlags(self.ItemIsSelectable | self.ItemIsMovable )
    #------------------------------------------------------------------------------------------------

def __init__(self, parent=None):  
        '''Create description canvas.

        :param parent: Abstract CPN element.
        '''
        super(DescriptionCanvas, self).__init__(parent)
        self.parent = parent
        self.text = self.parent.uniqueName
        self.setPen(QtGui.QPen(QtCore.Qt.darkYellow, 1))
        self.setBrush(QtGui.QBrush(QtCore.Qt.darkYellow))
        self.setFlags(self.ItemIsSelectable | self.ItemIsMovable | self.ItemSendsScenePositionChanges )
        self.label = QtGui.QGraphicsTextItem( "%s: %s"%(self.parent.uniqueName, self.parent.name), parent=self )  
#         self.label.setFlag(self.ItemIsMovable, True)
        rect = self.label.boundingRect()
        self.setRect(rect.x() + 30, rect.y() + 20, rect.width(), rect.height())
        self.label.setPos(rect.x() + 30, rect.y() + 20)
        self.label.setZValue(21)   
        self.setZValue(20)      
        self.visibility = False
        self.setVisibility( self.visibility ) 
    #------------------------------------------------------------------------------------------------

def setPolygon(self):
        '''Calculate position and rotation of the arc arrow head.'''
        rotDeg = 0            
        xlength = self.pos1.x() - self.pos2.x()
        ylength = self.pos1.y() - self.pos2.y()
        d = math.sqrt( math.pow( xlength , 2) + math.pow( ylength , 2) )        
        if d > 0:
            beta = math.acos( xlength / d )
            rotDeg = math.degrees( beta ) 

        self.arrowPolygonObject.setPolygon( QtGui.QPolygonF( [
                                                 QtCore.QPointF( (self.pos2.x() -10),  (self.pos2.y() +5)), 
                                                 QtCore.QPointF( (self.pos2.x() -10) , (self.pos2.y() -5)), 
                                                 QtCore.QPointF(       self.pos2.x() ,      self.pos2.y())
                                                 ] ) ) 

        self.arrowPolygonObject.setBrush( QtGui.QBrush(QtCore.Qt.black) )

        """ self.angle()!!!!!!!!!"""
#         self.arcLinePolygon.angle()
#         self.arcLinePolygon.rotate(rotDeg)
#         self.arcLinePolygon.setPos( self.pos2 ) 

    #------------------------------------------------------------------------------------------------

def setPolygon(self):
        rotDeg = 0            
        xlength = self.pos1.x() - self.pos2.x()
        ylength = self.pos1.y() - self.pos2.y()
        d = math.sqrt( math.pow( xlength , 2) + math.pow( ylength , 2) )        
        if d > 0:
            beta = math.acos( xlength / d )
            rotDeg = math.degrees( beta ) 

        self.arcLinePolygon.setPolygon( QtGui.QPolygonF( [
                                                 QtCore.QPointF( (self.pos2.x() -10),  (self.pos2.y() +5)), 
                                                 QtCore.QPointF( (self.pos2.x() -10) , (self.pos2.y() -5)), 
                                                 QtCore.QPointF(       self.pos2.x() ,      self.pos2.y())
                                                 ] ) ) 

        self.arcLinePolygon.setBrush( QtGui.QBrush(QtCore.Qt.black) )

        """ self.angle()!!!!!!!!!"""
#         self.arcLinePolygon.angle()
#         self.arcLinePolygon.rotate(rotDeg)
#         self.arcLinePolygon.setPos( self.pos2 ) 
    #------------------------------------------------------------------------------------------------

def paint(self, painter, option, index):
        rowdata = self.model.getrowdata(index.row())

        color = QtCore.Qt.white
        if "status" in rowdata.__dict__:
            if rowdata.status == "S":
                color = QtGui.QColor(204, 255, 204) # Light green
        else:                    
            color = QtGui.QColor(255, 204, 204) # Light red

        painter.save()
        painter.setPen(QtGui.QPen(QtCore.Qt.NoPen))
        painter.setBrush(QtGui.QBrush(color))
        painter.drawRect(option.rect)
        painter.restore()            
        QtGui.QItemDelegate.paint(self, painter, option, index)

def __init__(self):
        QtGui.QGraphicsScene.__init__(self)
        self.exitLoop = False
        self.loopMax = 0
        self.get_config()
        self._gridGroup = None
        self._mgridGroup = None
        self.setBackgroundBrush(QtGui.QColor(self.colors['background']))
        if os.path.exists(self.map_file):
            war = QtGui.QImageReader(self.map_file)
            wa = war.read()
            pixMap = QtGui.QPixmap.fromImage(wa)
        else:
            ratio = abs(self.map_upper_left[1] - self.map_lower_right[1]) / \
                     abs(self.map_upper_left[0] - self.map_lower_right[0])
            pixMap = QtGui.QPixmap(200 * ratio, 200)
            if self.map != '':
                painter = QtGui.QPainter(pixMap)
                brush = QtGui.QBrush(QtGui.QColor('white'))
                painter.fillRect(QtCore.QRectF(0, 0, 200 * ratio, 200), brush)
                painter.setPen(QtGui.QColor('lightgray'))
                painter.drawText(QtCore.QRectF(0, 0, 200 * ratio, 200), QtCore.Qt.AlignCenter,
                                 'Map not found.')
                painter.end()
        self.addPixmap(pixMap)
        w = self.width()
        h = self.height()
        if isinstance(self.line_width, float):
            if self.line_width < 1:
                self.line_width = w * self.line_width
        self.upper_left = [0, 0, self.map_upper_left[1], self.map_upper_left[0]]
        self.lower_right = [w, h, self.map_lower_right[1], self.map_lower_right[0]]
        self.setSceneRect(-w * 0.05, -h * 0.05, w * 1.1, h * 1.1)
        self._positions = {}
        self._setupCoordTransform()

def backgroundButtonGroupClicked(self, button):
        buttons = self.backgroundButtonGroup.buttons()
        for myButton in buttons:
            if myButton != button:
                button.setChecked(False)

        text = button.text()
        if text == "Blue Grid":
            self.scene.setBackgroundBrush(QtGui.QBrush(QtGui.QPixmap(':/images/background1.png')))
        elif text == "White Grid":
            self.scene.setBackgroundBrush(QtGui.QBrush(QtGui.QPixmap(':/images/background2.png')))
        elif text == "Gray Grid":
            self.scene.setBackgroundBrush(QtGui.QBrush(QtGui.QPixmap(':/images/background3.png')))
        else:
            self.scene.setBackgroundBrush(QtGui.QBrush(QtGui.QPixmap(':/images/background4.png')))

        self.scene.update()
        self.view.update()

def __init__(self, parent=None):
        QtGui.QGraphicsView.__init__(self, parent)
        self.scene = QtGui.QGraphicsScene(self)
        self.scene.setBackgroundBrush(QtGui.QBrush(QtCore.Qt.darkGray, QtCore.Qt.SolidPattern))
        self.setScene(self.scene)

        self.setDragMode(QtGui.QGraphicsView.ScrollHandDrag)
        self.setTransformationAnchor(QtGui.QGraphicsView.AnchorUnderMouse)
        self.viewport().setCursor(QtCore.Qt.CrossCursor)
        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)

        self._pan = False
        self._draw = False
        self._moved = False
        self._sel = False
        self.pen = None
        self.penid = None
        self.cmap = None
        self.penwidth = 4
        self._redoStack = []
        self._histStates = []
        self._baseRects = []

def drawPoint(self, qp, pt, isFirst, increaseRadius):
        # The first in green
        if isFirst:
            qp.setBrush(QtGui.QBrush(QtGui.QColor(0,255,0),QtCore.Qt.SolidPattern))
        # Other in red
        else:
            qp.setBrush(QtGui.QBrush(QtGui.QColor(255,0,0),QtCore.Qt.SolidPattern))

        # Standard radius
        r = 3.0
        # Increase maybe
        if increaseRadius:
            r *= 2.5
        # Draw
        qp.drawEllipse( pt, r, r )

    # Determine if the given candidate for a label path makes sense

def pushButtonAutoCheckClicked(self):
        root = self.treeWidget.invisibleRootItem()
        success = 0
        fail = 0
        for i in range(root.childCount()):
            item = root.child(i)
            exploit = self.__exploits[str(item.text(0))]
            if exploit.check():
                exploit.vulnerable = True
                w = self.__stackedWidgetController.getWidgetWithExploit(exploit)
                w.setCheckBoxVulnerableChecked(True)
                self.addExploitSuccess(exploit)
                success += 1
                item.setForeground(0, QBrush(QColor(Qt.green)))
            else:
                fail += 1
                item.setForeground(0, QBrush(QColor(Qt.red)))

        self.labelCheck.setText("Result: {0} OK - {1} Fail".format(success, fail))

def loadCanvas(self, path):
        info = _io.load_info(path)
        structure = info[0]['Structure']
        structure = structure[::-1]
        allitems = self.items()
        lenitems = len(allitems)
        bindingitems = len(BINDING_SITES)
        origamiitems = len(ORIGAMI_SITES)
        paletteindex = lenitems-bindingitems+9

        for i in range(0, origamiitems):
            colorindex = structure[i][2]
            allitems[paletteindex+i].setBrush(QtGui.QBrush(allcolors[colorindex]))

        self.evaluateCanvas()
        self.tableshort = info[0]['Extensions Short']
        self.tablelong = info[0]['Extensions Long']
        self.updateExtensions(self.tableshort)

def draw_scalebar(self, image):
        if self.window.display_settings_dialog.scalebar_groupbox.isChecked():
            pixelsize = self.window.display_settings_dialog.pixelsize.value()
            scalebar = self.window.display_settings_dialog.scalebar.value()
            length_camerapxl = scalebar / pixelsize
            length_displaypxl = int(round(self.width() * length_camerapxl / self.viewport_width()))
            height = max(int(round(0.15 * length_displaypxl)), 1)
            painter = QtGui.QPainter(image)
            painter.setPen(QtGui.QPen(QtCore.Qt.NoPen))
            painter.setBrush(QtGui.QBrush(QtGui.QColor('white')))
            x = self.width() - length_displaypxl - 35
            y = self.height() - height - 20
            painter.drawRect(x, y, length_displaypxl + 0, height + 0)
            if self.window.display_settings_dialog.scalebar_text.isChecked():
                font = painter.font()
                font.setPixelSize(20)
                painter.setFont(font)
                painter.setPen(QtGui.QColor('white'))
                text_spacer = 40
                text_width = length_displaypxl +2*text_spacer
                text_height = text_spacer
                painter.drawText(x-text_spacer, y-25, text_width, text_height, QtCore.Qt.AlignHCenter,str(scalebar)+' nm')
        return image

def resizeEvent(self, event):
        width = self.width()
        height = self.height()
        x = width/2
        y = height/2
        radius = max(width, height)/2
        for c in ('active', 'active_pressed', 'unactive', 'unactive_pressed'):
            grad = getattr(self, '{}_grad'.format(c))
            grad.setCenter(x, y)
            grad.setRadius(radius)
            grad.setFocalPoint(x, y)
            setattr(self, '{}_color'.format(c), QtGui.QBrush(grad))
        self.set_released_colors()
#        if self.isCheckable():
#            self.current_color = self.active_color if self.isChecked() else self.unactive_color
#            self.current_pen = self.active_pen if self.isChecked() else self.unactive_pen
#        else:
#            self.current_color = self.active_color
#            self.current_pen = self.active_pen

def __init__(self, parent=None):
        QtGui.QWizardPage.__init__(self, parent)
        self._item_funcs = {}

        self.setPixmap(QtGui.QWizard.LogoPixmap, QtGui.QPixmap(":/logo.jpg"))

        layout = QtGui.QVBoxLayout()

        self._panel = QtGui.QWidget()

        self._status_label = QtGui.QLabel()
        self._status_label.setAutoFillBackground(True)
        palette = self._status_label.palette()
        gradient = QtGui.QLinearGradient(0, 0, 0, 15)
        gradient.setColorAt(0.0, Qt.QColor.fromRgb(60, 150, 255))
        gradient.setColorAt(0.5, Qt.QColor.fromRgb(0,  85, 227))
        gradient.setColorAt(1.0, Qt.QColor.fromRgb(60, 150, 255))
        gradient.setSpread(QtGui.QGradient.RepeatSpread)
        palette.setBrush(QtGui.QPalette.Window, QtGui.QBrush(gradient))
        palette.setBrush(QtGui.QPalette.WindowText, Qt.Qt.white)

        layout.addWidget(self._panel)
        layout.addStretch()
        layout.addWidget(self._status_label)
        self.setLayout(layout)

def setConsoleColor(self, color):
        fmt = self.consoleView.currentCharFormat()
        fmt.setForeground(QtGui.QBrush(QtGui.QColor(color)))
        self.consoleView.setCurrentCharFormat(fmt)

def __init__(self, parent = None):  
        '''Create abstract item.

        :param parent: `gui.DiagramEditor`. Editor to show in. 
        '''
        self.parent = parent
        super(AbstractItem, self).__init__(parent)
        self.tokens = None        
        self.name = ""
        self.posCallbacks = []
        self.connectorList = []

        self.setPen(QtGui.QPen(QtCore.Qt.black, 2))
        self.setBrush(QtGui.QBrush(QtCore.Qt.white))
        self.setFlags(self.ItemIsSelectable | self.ItemIsMovable | self.ItemSendsScenePositionChanges)

        self.planeMap = {
                         "northWest":set(),
                         "north":set(),
                         "northEast":set(),
                         "east":set(),
                         "southEast":set(),
                         "south":set(),
                         "southWest":set(),
                         "west":set()
                         }
        self.connectorMap = {
                         "northWest":[],
                         "north":[],
                         "northEast":[],
                         "east":[],
                         "southEast":[],
                         "south":[],
                         "southWest":[],
                         "west":[]
                         }
    #------------------------------------------------------------------------------------------------

def __init__(self, direction, parent=None):
        '''Create a port

        :param direction:  Port direction: (i)nput, (o)utput, (io) bidirectional.
        :param parent: Parent port place.
        '''
        super(PortItem, self).__init__(QtCore.QRectF(-4.0,-4.0,17.0,17.0), parent)
        self.posChangeCallbacks = []
        self.setBrush(QtGui.QBrush(QtCore.Qt.white))
        self.setFlags(self.ItemIsSelectable | self.ItemIsMovable | self.ItemSendsScenePositionChanges)
        self.label = QtGui.QGraphicsTextItem("", self)
        self.label.setPos(QtCore.QPointF( -4, -7))
        self.direction = direction
        self.setZValue(9)
    #------------------------------------------------------------------------------------------------

def initTransition(self, loadFromFile):  
        '''Initialize transition.

        :param loadFromFile: Flag determining, whether the transition is loaded from file.
        '''
        pos = self.scenePos()        
        self.createItem(self.editor, self.name, nodeType="transition")   
        rect = self.boundingRect()    

        if not self.substitutionTransition:    
            self.guardLabel = QtGui.QGraphicsTextItem(self.guardExpression, self)
            self.guardLabel.setFlags( self.ItemIsSelectable | self.ItemIsMovable )   
            self.guardLabel.setPos(pos.x() + rect.width()/2, pos.y() - 20)
            self.guardLabel.setPlainText( self.guardExpression )
        else:            
            if not loadFromFile:
                self.editor.mainWindow.addSubnetEditor(self.name)
            self.subnetBorder = QtGui.QGraphicsRectItem( pos.x() - 5, pos.y()-5, rect.width()+9, rect.height()+9, parent=self )
            self.subnetBorder.setFlag( self.ItemStacksBehindParent, True ) 
            self.subnetBorder.setPen(QtGui.QPen(QtCore.Qt.black, 2))
            self.subnetBorder.setBrush(QtGui.QBrush(QtCore.Qt.white))
            self.subnetBorder.setZValue(11)
            self.guardExpression = ""

        self.setPos(self.position)
        self.setZValue(10)

        self.editor.visualTransitions.append(self)
        self.editor.diagramScene.addItem(self)
    #------------------------------------------------------------------------------------------------

def __init__(self):
        super(QtGui.QMainWindow, self).__init__()    
        self.diagramScene = QtGui.QGraphicsScene(self)  
        uic.loadUi('arrow.ui', self)  
        self.graphicsView.setScene( self.diagramScene )
        t1 = QtGui.QGraphicsRectItem(QtCore.QRectF(20,20,100,50 )) 
        t1.setBrush(QtGui.QBrush(QtCore.Qt.white))
#         t1.setFlag( QtGui.QGraphicsItem.ItemIsSelectable | QtGui.QGraphicsItem.ItemIsMoveable )
        self.diagramScene.addItem(t1) 
        p1 = QtGui.QGraphicsEllipseItem(QtCore.QRectF(200,200,100,50))
        p1.setBrush(QtGui.QBrush(QtCore.Qt.white))
#         p1.setFlags( QtGui.QGraphicsItem.ItemIsSelectable | QtGui.QGraphicsItem.ItemIsMoveable )
        arc1 = ArcItem(self, self.diagramScene)
        arc1.arcLine.setLine(20,20,200,200)
        arc1.setPolygon()
        self.diagramScene.addItem(p1)
        self.show()
        pass

def draw_predictions(file_path, predictions, class_index,
                     score_low, score_high):
    img = QtGui.QImage(file_path)
    painter = QtGui.QPainter(img)
    for i, pred in enumerate(predictions):
        if class_index > 0 and pred.class_index != class_index: continue
        if pred.score < score_low or pred.score > score_high: continue
        class_name = CLASS_NAMES[pred.class_index]
        x1, y1, x2, y2 = map(int, pred.bbox)
        # bbox
        painter.setPen(QtGui.QPen(PRESET_COLORS[pred.class_index], 10.0))
        # painter.setPen(QtGui.QPen(QtGui.QColor(0, 116, 217), 10.0))
        painter.setBrush(QtGui.QBrush())
        painter.drawRect(x1, y1, x2 - x1 + 1, y2 - y1 + 1)
        # label background rect
        painter.setPen(QtGui.QPen(PRESET_COLORS[pred.class_index], 2.0))
        painter.setBrush(QtGui.QBrush(PRESET_COLORS[pred.class_index]))
        # painter.setPen(QtGui.QPen(QtGui.QColor(0, 116, 217), 2.0))
        # painter.setBrush(QtGui.QBrush(QtGui.QColor(0, 116, 217)))
        if class_index > 0:
            painter.drawRect(x1, y1, min(x2 - x1 + 1, 100), 30)
        else:
            painter.drawRect(x1, y1, min(x2 - x1 + 1, 200), 30)
        # label text
        painter.setPen(QtGui.QPen(QtGui.QColor(255, 255, 255)))
        painter.setBrush(QtGui.QBrush())
        painter.setFont(QtGui.QFont('Arial', 20, QtGui.QFont.Bold))
        if class_index > 0:
            painter.drawText(x1 + 4, y1 + 24, '{:.2f}'.format(pred.score))
        else:
            painter.drawText(x1 + 4, y1 + 24,
                             '{} {:.2f}'.format(class_name, pred.score))
    return img

def addGeneration(self, st):
        if (st.technology[:6] != 'Fossil' or self.show_fossil) and st.generation > 0:
            p = self.mapFromLonLat(QtCore.QPointF(st.lon, st.lat))
            size = sqrt(float(st.generation) * (self.capacity_area / 2000) / pi)
            east = self.destinationxy(st.lon, st.lat, 90., size)
            pe = self.mapFromLonLat(QtCore.QPointF(east[0], st.lat))
            north = self.destinationxy(st.lon, st.lat, 0., size)
            pn = self.mapFromLonLat(QtCore.QPointF(st.lon, north[1]))
            x_d = p.x() - pe.x()
            y_d = pn.y() - p.y()
            el = QtGui.QGraphicsEllipseItem(p.x() - x_d / 2, p.y() - y_d / 2, x_d, y_d)
            if self.show_capacity_fill:
                brush = QtGui.QBrush()
                brush.setColor(QtGui.QColor(self.colors[st.technology]))
            #     brush.setStyle(QtCore.Qt.Dense1Pattern)
                brush.setStyle(QtCore.Qt.SolidPattern)
                el.setBrush(brush)
                el.setOpacity(self.capacity_opacity)
            if self.colors['border'] != '':
                el.setPen(QtGui.QColor(self.colors['border']))
            else:
                el.setPen(QtGui.QColor(self.colors[st.technology]))
            el.setZValue(1)
            self.addItem(el)
            self._stationGroups[st.name].append(el)
            self._stationCircles[st.technology].append(el)
            self._generationGroup.addToGroup(el)

def addLabel(self,name,color=None):
        item = QtGui.QListWidgetItem()
        if color:
            brush = QtGui.QBrush(color)
            brush.setStyle(QtCore.Qt.SolidPattern)
            item.setBackground(brush)
            brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
            brush.setStyle(QtCore.Qt.SolidPattern)
            item.setForeground(brush)
        item.setText(name)
        self.listWidget.addItem(item)
        return item

def addLabel(self,name,color=None):
        item = QtGui.QListWidgetItem()
        if color:
            brush = QtGui.QBrush(color)
            brush.setStyle(QtCore.Qt.SolidPattern)
            item.setBackground(brush)
            brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
            brush.setStyle(QtCore.Qt.SolidPattern)
            item.setForeground(brush)
        item.setText(name)
        self.listWidget.addItem(item)
        return item

def mouseMoveEvent(self,event):
        # _logger.info('event: %s' %event.__class__)
        # _logger.info('release mouse button %s' %event.buttons())




        if event.button()== Qt.LeftButton:

            # cursor = self.textCursor()
            # # _logger.info('release mouse')
            # if cursor.hasSelection():
            #     start = cursor.selectionStart()
            #     end = cursor.selectionEnd()



            # set selected text color before releasing mouse button
            tmp = self.textCursor().charFormat()
            # tmp.setBackground(QtGui.QBrush(self.palette().highlight().color()))
            # tmp.setForeground(QtGui.QBrush(self.palette().background().color()))
            tmp.setBackground(QtGui.QBrush(self.palette().text().color()))
            tmp.setForeground(QtGui.QBrush(self.palette().base().color()))

            self.textCursor().setCharFormat(tmp)
            # print 'cursor changed'
            # self.textCursor().setPosition(3)

        super(PyInterp,self).mouseMoveEvent(event)

def adornGraphicsVerticalLayout(self, MainWindow):
        self.scene = QtGui.QGraphicsScene(self.centralwidget)

        self.graphicsView = QtGui.QGraphicsView(self.scene)
        self.graphicsView.setFrameShadow(QtGui.QFrame.Raised)
        self.graphicsView.setLineWidth(3)
        self.graphicsView.setVerticalScrollBarPolicy(
            QtCore.Qt.ScrollBarAlwaysOn)
        self.graphicsView.setHorizontalScrollBarPolicy(
            QtCore.Qt.ScrollBarAlwaysOn)
        self.graphicsView.setTransformationAnchor(
            QtGui.QGraphicsView.AnchorUnderMouse)
        self.graphicsView.setResizeAnchor(
            QtGui.QGraphicsView.AnchorUnderMouse)
        self.graphicsView.setBackgroundBrush(
            QtGui.QBrush(QtGui.QColor(245,245,245)))
        self.graphicsView.setFrameShape(QtGui.QFrame.NoFrame)
        self.graphicsView.setObjectName(_fromUtf8("graphicsView"))
        self.graphicsVerticalLayout.addWidget(self.graphicsView)

        self.displayHorizontalLayout = QtGui.QHBoxLayout()
        self.displayHorizontalLayout.setObjectName(
            _fromUtf8("displayHorizontalLayout"))
        self.graphicsVerticalLayout.addLayout(self.displayHorizontalLayout)

        self.displayHorizontalLayout.addStretch(1)
        self.displayFileButton = QtGui.QPushButton(self.centralwidget)
        self.displayFileButton.setToolTip("Various files and figures will "
            "show up in this box as they are\nbeing produced by the PySCUBA "
            "analysis of your data.\nClick on any of those and it will be "
            "displayed in an adjacent\ngraphics box.")
        self.displayFileButton.setObjectName(_fromUtf8("displayFileButton"))
        self.displayHorizontalLayout.addWidget(self.displayFileButton)
        self.displayHorizontalLayout.addStretch(1)

def __init__(self, parent=None):
        super(QTestView, self).__init__(parent)
        self.scene = QtGui.QGraphicsScene(self)
        self.scene.setBackgroundBrush(QtGui.QBrush(QtCore.Qt.darkGray, QtCore.Qt.SolidPattern))
        self.setScene(self.scene)

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 removeExploitSuccess(self, exploit):
        self.__exploitsSuccess.remove(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.black)))

def setItemsLoaded(self, names):
        self.setEnabledItems(True)
        if names:
            root = self.treeWidget.invisibleRootItem()
            for name in names:
                for i in range(root.childCount()):
                    item = root.child(i)
                    if item.text(0) == name:
                        widget = self.__stackedWidgetController.getWidgetWithExploit(name)
                        widget.setCheckBoxVulnerableChecked()
                        item.setForeground(0, QBrush(QColor(Qt.green)))

def clearCanvas(self):
        allitems = self.items()
        lenitems = len(allitems)
        bindingitems = len(BINDING_SITES)
        origamiitems = len(ORIGAMI_SITES)
        paletteindex = lenitems-bindingitems+9

        for i in range(0, origamiitems):
            allitems[paletteindex+i].setBrush(QtGui.QBrush(defaultcolor))

        self.saveExtensions(['None', 'None', 'None', 'None', 'None', 'None', 'None'], ['None', 'None', 'None', 'None', 'None', 'None', 'None'])
        self.updateExtensions(['None', 'None', 'None', 'None', 'None', 'None', 'None'])
        self.evaluateCanvas()

def __init__(self, height, color=QtGui.QColor(200, 200, 200)):
        QtGui.QGraphicsItem.__init__(self)
        self.rect.setHeight(height)
        self.pen = QtGui.QPen(QtCore.Qt.NoPen)
        self.brush = QtGui.QBrush(color)

def hoverEnterEvent(self, event):
        self.pen = QtGui.QPen(QtCore.Qt.red)
        self.brush = QtGui.QBrush(QtGui.QColor(255, 88, 88))
        self.update()

def hoverLeaveEvent(self, event):
        self.pen = QtGui.QPen(QtCore.Qt.blue)
        self.brush = QtGui.QBrush(QtGui.QColor(255, 88, 88, 150))
        self.update()

def build_graph(self):
        for c, ports in self.graph.port_id_dict.items():
            rows = []
            for p, port in ports.items():
                if port.is_output and not port.hidden:
                    port_item = QtGui.QStandardItem(port.name)
                    port_name = '{}:{}'.format(port.client.name, port.name)
                    port_item.setData(port_name, NameRole)
                    port_item.setData(True, PortRole)
                    full_port_item = QtGui.QStandardItem(port_name)
                    setBold(port_item)
                    port_id = QtGui.QStandardItem('{}:{}'.format(port.client.id, port.id))
                    port_id.setData('{}:{}'.format(port.client.id, port.id), NameRole)
                    setBold(port_id)
                    rows.append([port_item, port_id, full_port_item])
            if rows:
               client_item = QtGui.QStandardItem(' {}'.format(port.client.name))
               client_item.setData('{}:.*'.format(port.client.name), NameRole)
               client_item.setData(QtGui.QBrush(QtCore.Qt.gray), QtCore.Qt.ForegroundRole)
               client_id = QtGui.QStandardItem(str(port.client.id))
               client_id.setData('{}:.*'.format(port.client.id), NameRole)
               client_id.setData(QtGui.QBrush(QtCore.Qt.gray), QtCore.Qt.ForegroundRole)
               self.graph_model.appendRow([client_item, client_id])
               for r in rows:
                   self.graph_model.appendRow(r)
        self.input_table.resizeColumnsToContents()
        self.input_table.resizeRowsToContents()

def mark_user(self):
        textCursor2 = self.postdata_textEdit.textCursor()
        print(textCursor2.selectedText())
        self.datawrapper.postdata.maindata['username'] = textCursor2.selectedText()
        keyword = textCursor2.charFormat()
        keyword.setForeground(QtGui.QBrush(Qt.blue))
        keyword.setFontWeight(QtGui.QFont.Bold)
        textCursor2.setCharFormat(keyword)
        # textCursor2.setPosition(end,QtGui.QTextCursor.KeepAnchor)
        self.postdata_textEdit.setTextCursor(textCursor2)

def mark_pwd(self):

        textCursor2 = self.postdata_textEdit.textCursor()
        print(textCursor2.selectedText())
        self.datawrapper.postdata.maindata['password'] = textCursor2.selectedText()
        keyword = textCursor2.charFormat()
        keyword.setForeground(QtGui.QBrush(Qt.blue))
        keyword.setFontWeight(QtGui.QFont.Bold)
        textCursor2.setCharFormat(keyword)
        # textCursor2.setPosition(end,QtGui.QTextCursor.KeepAnchor)
        self.postdata_textEdit.setTextCursor(textCursor2)

def event_enable(self, row_list, state):
        color = QtCore.QVariant(QtGui.QBrush(QtCore.Qt.black if state else QtCore.Qt.gray))
        for row in row_list:
            data = self.event_buffer[row]
            if isinstance(data.event, ConnectionEvent): continue
            data.enabled = state
            for c in range(self.model.columnCount()):
                self.model.item(row, c).setData(color, QtCore.Qt.ForegroundRole)

def DRAW_CLASSIC_POINTS(self, Painter):

        # -------------------------------------------------------------------
        Painter.setPen( QPen( QColor("#FFF"), 2 ) );
        Painter.drawPolyline( self.poly( self.CANDLES_POINTS ) );

        Painter.setBrush(QBrush(QColor(255, 255, 255))) # color
        Painter.setPen(QPen(QColor("#F00"), 2)) # circle border diameter

        p = self.CANDLES_POINT_W;

        for x, y in self.CANDLES_POINTS:
            Painter.drawEllipse(QRectF(x - p/2, y - p/2, p, p));

        # -------------------------------------------------------------------

    # =======================================================================

def DRAW_CLASSIC_CANDLES(self, Painter):

        # -------------------------------------------------------------------
        # CLASSIC CANDLES

        #Painter.setPen(QPen(QColor("#FFF"), 1, Qt.NoPen));
        Painter.setPen(QPen(QColor("#FFF"), 1));

        for x_offset, y_enter, y_exit, max_val, min_val, is_growing, e_1, e_2, e_3, e_4, _upd in self.CANDLES:

            try:

                # -------------------------------------------------------
                # LINES -> drawPolyline == from_x, from_y, to_x, to_y
                if self.DRAW_PICK_LINES:
                    Painter.drawPolyline( QPoint(x_offset+self.CANDLE_W/2, min_val), QPoint(x_offset+self.CANDLE_W/2, max_val) );

                # -------------------------------------------------------                    
                # CANDLES -> drawRect == from_x, from_y, length_x, length_y
                #Painter.setPen(QPen(QColor("#444"), 0));

                if is_growing:
                    Painter.setBrush( QBrush(self.CANDLE_G_COLOR) );
                else:
                    Painter.setBrush( QBrush(self.CANDLE_R_COLOR) );

                Painter.drawRect( x_offset, y_enter, self.CANDLE_W, y_exit-y_enter );

                # -------------------------------------------------------                    

            except Exception as _NoneTypeError:

                print(_NoneTypeError)
                print("x: "+str(x_offset)+" y: "+str(y_enter))
                Painter.end()
                exit();

        # -------------------------------------------------------------------

    # =======================================================================

def __init__(self, parent=None):
        BaseUpgradePage.__init__(self, parent)
        self.setTitle('Pool Instance')
        self.setSubTitle('Please select the Pool Server instance')

        #panel = QtGui.QWidget(self)
        panel = self

        self.instanceCB = QtGui.QComboBox(panel)
        self.instanceCB.setDuplicatesEnabled(False)
        self.instanceCB.setEditable(False)
        self.registerField(self.p_instance_key, self.instanceCB)

        layout = QtGui.QGridLayout(panel)
        instanceLabel = QtGui.QLabel('instance:', panel)
        spacer = QtGui.QSpacerItem(
            20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
        self.statusLabel = QtGui.QLabel(panel)

        self.statusLabel.setAutoFillBackground(True)
        palette = self.statusLabel.palette()
        palette.setBrush(QtGui.QPalette.Window, QtGui.QBrush(
            Qt.QColor.fromRgb(200, 200, 200)))

        layout.setColumnStretch(0, 0)
        layout.setColumnStretch(1, 1)
        layout.addWidget(instanceLabel, 0, 0, Qt.Qt.AlignRight)
        layout.addWidget(self.instanceCB, 0, 1, Qt.Qt.AlignLeft)
        layout.addItem(spacer, 1, 0, 1, 2)

        layout.addWidget(self.statusLabel, 2, 0, 1, 2)

        self.connect(self.instanceCB,
                     QtCore.SIGNAL('currentIndexChanged(int)'),
                     QtCore.SIGNAL('completeChanged()'))

def __init__(self, parent=None):
        BaseUpgradePage.__init__(self, parent)
        self.setTitle('Version')
        self.setSubTitle('Please select the version to upgrade to')

        panel = self

        self.versionCB = QtGui.QComboBox(panel)
        self.versionCB.setDuplicatesEnabled(False)
        self.versionCB.setEditable(False)
        self.registerField(self.p_version_key, self.versionCB)

        layout = QtGui.QGridLayout(panel)
        versionLabel = QtGui.QLabel('version:', panel)
        spacer = QtGui.QSpacerItem(
            20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
        self.statusLabel = QtGui.QLabel(panel)

        self.statusLabel.setAutoFillBackground(True)
        palette = self.statusLabel.palette()
        palette.setBrush(QtGui.QPalette.Window, QtGui.QBrush(
            Qt.QColor.fromRgb(200, 200, 200)))

        layout.setColumnStretch(0, 0)
        layout.setColumnStretch(1, 1)
        layout.addWidget(versionLabel, 0, 0, Qt.Qt.AlignRight)
        layout.addWidget(self.versionCB, 0, 1, Qt.Qt.AlignLeft)
        layout.addItem(spacer, 1, 0, 1, 2)

        layout.addWidget(self.statusLabel, 2, 0, 1, 2)

def SetPointToSelection(self):
        pass
        if  self._checkLoadLayer() ==False:
            return

        tbl =self.tblPhotos
        if len(tbl.selectedItems())==0:
            return

        pl=[]
        for p in tbl.selectedItems():
            a=p.data(32)
            if a is not None :
                pl.append(a)

        if self.AskUpdatePoint(pl) is False:
            return

        if len(pl):
            self.canvas.freeze(True)
            self.SetPhotoPosition(pl,self.canvas.center())
            self.canvas.freeze(False)
            self.canvas.refresh()

            i=0
            for p in tbl.selectedItems():
                if p.row()==1 :
                    p.setBackground(QBrush(QColor('#FFFFFF')))

def AddMorePhotosToList(self):

        oldst=self.loadListCount
        n=100

        QApplication.setOverrideCursor(Qt.WaitCursor)
        if not self.GetPhotosList( self.loadListCount+1,self.loadListCount+n):
            QApplication.restoreOverrideCursor()
            return

        tbl=self.tblPhotos
        tbl.verticalHeader().resizeSection(0,50)

        for i in range(oldst,self.loadListCount) :
            fn=os.path.join(self.folderpath,self.photolist[i].filename)
            self.photolist[i].filePath=fn
            tp=os.path.join(os.path.join(self.folderpath,'thumb'),str(self.photolist[i].p_id)+'.png')
            self.photolist[i].thumbPath=tp
            item=ImgWidget(fn,tp,self)
            hd=QTableWidgetItem(str(self.photolist[i].p_id))
            tbl.insertColumn(i)
            tbl.setHorizontalHeaderItem(i,hd)
            tbl.setCellWidget(0,i,item)
            b=QtGui.QTableWidgetItem(self.photolist[i].filename)
            b.setData(32,self.photolist[i])
            tbl.setItem(1,i, b)
            if self.photolist[i].lon==0 and self.photolist[i].lat==0:
                tbl.item(1,i).setBackground(QBrush(QColor('#CCFFFF')))
            if self.photolist[i].keywords :
                tbl.setItem(2,i, QtGui.QTableWidgetItem(self.photolist[i].keywords))

            QgsMessageLog.logMessage(u"LoadPhoto..." + str(i), tag="LoadMorePhotoThread", level=QgsMessageLog.INFO )

        QApplication.restoreOverrideCursor()

def AddPhotosToList(self):

        oldst=self.loadListCount

        QApplication.setOverrideCursor(Qt.WaitCursor)

        if not self.GetPhotosList( self.loadListCount+1,self.loadListCount+self.loadmax):
            QApplication.restoreOverrideCursor()
            return


        tbl=self.tblPhotos
        tbl.verticalHeader().resizeSection(0,50)

        self.ClearTableCells()

        for i in range(oldst,self.loadListCount) :
            fn=os.path.join(self.folderpath,self.photolist[i].filename)
            self.photolist[i].filePath=fn
            tp=os.path.join(os.path.join(self.folderpath,'thumb'),str(self.photolist[i].p_id)+'.png')
            self.photolist[i].thumbPath=tp
            item=ImgWidget(fn,tp,self)
            pos=i-oldst
            hd=QTableWidgetItem(str(i+1))
            tbl.setHorizontalHeaderItem(pos,hd)
            tbl.setCellWidget(0,pos,item)
            b=QtGui.QTableWidgetItem(self.photolist[i].filename)
            b.setData(32,self.photolist[i])
            tbl.setItem(1,i, b)

            if self.photolist[i].lon==0 and self.photolist[i].lat==0:
                tbl.item(1,i).setBackground(QBrush(QColor('#CCFFFF')))

            if self.photolist[i].keywords :
                tbl.setItem(2,pos, QtGui.QTableWidgetItem(self.photolist[i].keywords))

            QgsMessageLog.logMessage(u"LoadPhoto..." + str(i), tag="LoadPhotoThread", level=QgsMessageLog.INFO )

        QApplication.restoreOverrideCursor()

def __init__(self, editor, name, position, guardExpression = None, uniqueName="t0", loadFromFile=False, substitutionTransition=False, subnet=None):
        '''Create transition item.

        :param editor: `gui.DiagramEditor`. Editor to show in.
        :param name: Name of the CPN element assigned by the user. 
        :param position: Position of this item in the `gui.DiagramScene`.
        :param guardExpression: The guard expression for this transition.
        :param uniqueName: Unique name of this transition used by the simulator.
        :param loadFromFile: Flag determining, whether the transition is loaded from file.
        :param substitutionTransition: Flag indication a substitutaion transition.
        :param subnet: Name of the subnet this transition is contained in.
        '''
        super(TransitionItem, self).__init__(None)
        self.editor = editor
        self.name = name
        self.substitutionTransition = substitutionTransition
        self.subnet = subnet
#         self.superNet = editor.subnet
        self.position = position
        self.uniqueName = uniqueName
        self.enabled = False
        self.guardExpression = guardExpression
        self.subnetBorder = None
        self.exceptionString = ""
        self.modeString = ""
        self.setBrush(QtGui.QBrush(QtCore.Qt.white))

        logging.debug("-------Create----Transition-------------------%s---------%s----------"%(uniqueName, name))
        logging.debug( "editor %s position %s Guard Expression %s"%(editor, position, guardExpression))
        logging.debug( "loadFromFile %s substitution Transition %s subnet %s"%(loadFromFile, substitutionTransition, subnet))
        logging.debug("-----------------------------------------------------------------------------------")

        if not self.substitutionTransition:
            if not loadFromFile:
                self.guardDiag = NameDialog(title="Enter Guard Expression", default="True")
                self.guardDiag.accepted.connect( self.acceptEditGuard )
                self.guardDiag.show()    
                try:
                    self.transition = Transition( self.uniqueName, Expression(self.guardExpression) )
                    self.editor.mainWindow.simulator.net.add_transition( self.transition ) 
                    self.editor.mainWindow.simulator.transitions.append( self )
                except SyntaxError:
                    item = QtGui.QListWidgetItem( str( sys.exc_info()[1] ) )
                    item.setTextColor(QtCore.Qt.red)
                    self.editor.mainWindow.logWidget.addItem( item )
        self.initTransition(loadFromFile)
    #-------------------------------------------------------------------------------------------------

def data(self, index, role):
        if not index.isValid():
            return None
        entry = self.collectionData[index.row()][1]
        field = self.displayedFields()[index.column()]
        if role == QtCore.Qt.DisplayRole or role == QtCore.Qt.ToolTipRole:
            if re.match(r'^Result [0-9]+$',field):
                number = int(re.match(r'^Result ([0-9]+)$',field).groups()[0]) - 1 # counting!!!
                try:
                    resValue = float(entry['result'][number])
                    if self.resultViewMode == CollectionModel.ResultViewRaw:
                        res = unicode(resValue)
                    elif self.resultViewMode == CollectionModel.ResultViewRounded:
                        resValue = round(resValue,2)
                        res = unicode(resValue)
                    elif self.resultViewMode == CollectionModel.ResultViewPercent:
                        resValue = round(resValue * 100,2)
                        res = unicode(resValue) + '%'
                    else:
                        raise Exception('Wrong result view mode!')
                except (KeyError,IndexError,TypeError):
                    res = '---'
            else:
                try:
                    res = entry['config'][field]
                except KeyError:
                    res = 'XXX'
            return res
        elif role == QtCore.Qt.BackgroundColorRole:
            if entry['DuplicateMarker']:
                return QtGui.QBrush(self.DuplicateColor)
            elif entry['status'] == 'FAILED':
                return QtGui.QBrush(self.FailedColor)
            elif entry['status'] == 'INTERRUPTED':
                return QtGui.QBrush(self.InterruptedColor)
            elif entry['status'] == 'RUNNING':
                return QtGui.QBrush(self.RunningColor)
            else:
                return None
        else:
            return None

    # column (field) headers